/* Generated by Cython 3.1.4 */

/* BEGIN: Cython Metadata
{
    "distutils": {
        "depends": [
            "networkit/cython_helper.h"
        ],
        "include_dirs": [
            "networkit"
        ],
        "language": "c++",
        "name": "networkit.centrality",
        "sources": [
            "networkit/centrality.pyx"
        ]
    },
    "module_name": "networkit.centrality"
}
END: Cython Metadata */

#ifndef PY_SSIZE_T_CLEAN
#define PY_SSIZE_T_CLEAN
#endif /* PY_SSIZE_T_CLEAN */
/* InitLimitedAPI */
#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API)
  #define CYTHON_LIMITED_API 1
#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_1_4"
#define CYTHON_HEX_VERSION 0x030104F0
#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 HAVE_LONG_LONG
  #define HAVE_LONG_LONG
#endif
#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 1
  #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
#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
#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_CLINE_IN_TRACEBACK
  #define CYTHON_CLINE_IN_TRACEBACK 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 0
  #undef CYTHON_USE_TYPE_SPECS
  #define CYTHON_USE_TYPE_SPECS 1
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_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
  #undef CYTHON_USE_FREELISTS
  #define CYTHON_USE_FREELISTS 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
#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 && PY_VERSION_HEX >= 0x030800B1)
#endif
#endif
#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
#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 CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME
  #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100
#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)
#ifdef _MSC_VER
    #ifndef _MSC_STDINT_H_
        #if _MSC_VER < 1300
            typedef unsigned char     uint8_t;
            typedef unsigned short    uint16_t;
            typedef unsigned int      uint32_t;
        #else
            typedef unsigned __int8   uint8_t;
            typedef unsigned __int16  uint16_t;
            typedef unsigned __int32  uint32_t;
        #endif
    #endif
    #if _MSC_VER < 1300
        #ifdef _WIN64
            typedef unsigned long long  __pyx_uintptr_t;
        #else
            typedef unsigned int        __pyx_uintptr_t;
        #endif
    #else
        #ifdef _WIN64
            typedef unsigned __int64    __pyx_uintptr_t;
        #else
            typedef unsigned __int32    __pyx_uintptr_t;
        #endif
    #endif
#else
    #include <stdint.h>
    typedef uintptr_t  __pyx_uintptr_t;
#endif
#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 >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
#else
  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
#endif
#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))

/* 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 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))
#elif CYTHON_BACKPORT_VECTORCALL
  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
                                            size_t nargsf, PyObject *kwnames);
  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
#else
  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
#endif
#if PY_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 __PYX_LIMITED_VERSION_HEX < 0x03090000
  #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
  #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 && PY_VERSION_HEX >= 0x03080000
#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
    PyObject_GC_Del(obj);\
    Py_DECREF(type);\
}
#else
#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
  #define __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
  #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
#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 __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 __PYX_LIMITED_VERSION_HEX >= 0x030d0000
  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
#else
  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
      PyObject *module = PyImport_AddModule(name);
      Py_XINCREF(module);
      return module;
  }
#endif
#if 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>
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif

#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__networkit__centrality
#define __PYX_HAVE_API__networkit__centrality
/* Early includes */
#include <stdint.h>
#include "ios"
#include "new"
#include "stdexcept"
#include "typeinfo"
#include <vector>
#include <utility>

    #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)
    // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully
    #include <type_traits>

    namespace cython_std {
    template <typename T> typename std::remove_reference<T>::type&& move(T& t) noexcept { return std::move(t); }
    template <typename T> typename std::remove_reference<T>::type&& move(T&& t) noexcept { return std::move(t); }
    }

    #endif
    
#include <networkit/base/Algorithm.hpp>
#include <string.h>
#include <string_view>
#include <string>
#include <map>
#include <set>
#include "cython_helper.h"
#include <algorithm>
#include <networkit/structures/Cover.hpp>
#include <networkit/structures/Partition.hpp>
#include <networkit/dynamics/GraphEvent.hpp>
#include <networkit/base/DynAlgorithm.hpp>
#include <unordered_set>
#include <networkit/Globals.hpp>
#include <networkit/graph/Graph.hpp>
#include <networkit/graph/SpanningForest.hpp>
#include <networkit/graph/KruskalMSF.hpp>
#include <networkit/graph/PrimMSF.hpp>
#include <networkit/graph/RandomMaximumSpanningForest.hpp>
#include <networkit/graph/UnionMaximumSpanningForest.hpp>
#include "limits.h"
#include <networkit/centrality/Centrality.hpp>
#include <networkit/centrality/Betweenness.hpp>
#include <networkit/centrality/ApproxBetweenness.hpp>
#include <networkit/centrality/EstimateBetweenness.hpp>
#include <networkit/centrality/KadabraBetweenness.hpp>
#include <networkit/centrality/DynBetweenness.hpp>
#include <networkit/centrality/DynApproxBetweenness.hpp>
#include <networkit/centrality/DynBetweennessOneNode.hpp>
#include <networkit/centrality/Closeness.hpp>
#include <networkit/centrality/ApproxCloseness.hpp>
#include <networkit/centrality/DegreeCentrality.hpp>
#include <networkit/centrality/HarmonicCloseness.hpp>
#include <networkit/centrality/TopCloseness.hpp>
#include <networkit/centrality/TopHarmonicCloseness.hpp>
#include <networkit/centrality/DynTopHarmonicCloseness.hpp>
#include <networkit/centrality/LocalPartitionCoverage.hpp>
#include <networkit/centrality/GroupDegree.hpp>
#include <networkit/centrality/GedWalk.hpp>
#include <networkit/centrality/ApproxGroupBetweenness.hpp>
#include <networkit/centrality/GroupCloseness.hpp>
#include <networkit/centrality/GroupClosenessGrowShrink.hpp>
#include <networkit/centrality/GroupClosenessLocalSwaps.hpp>
#include <networkit/centrality/GroupHarmonicCloseness.hpp>
#include <networkit/centrality/GroupClosenessLocalSearch.hpp>
#include <networkit/centrality/KPathCentrality.hpp>
#include <networkit/centrality/KatzCentrality.hpp>
#include <networkit/centrality/DynKatzCentrality.hpp>
#include <networkit/centrality/LocalClusteringCoefficient.hpp>
#include <networkit/centrality/LocalSquareClusteringCoefficient.hpp>
#include <networkit/centrality/Sfigality.hpp>
#include <networkit/centrality/PermanenceCentrality.hpp>
#include <networkit/centrality/LaplacianCentrality.hpp>
#include <networkit/centrality/CoreDecomposition.hpp>
#include <networkit/centrality/EigenvectorCentrality.hpp>
#include <networkit/centrality/PageRank.hpp>
#include <networkit/centrality/SpanningEdgeCentrality.hpp>
#include <networkit/centrality/ApproxElectricalCloseness.hpp>
#include <networkit/centrality/ForestCentrality.hpp>
#include <networkit/centrality/ApproxSpanningEdge.hpp>
#include <networkit/centrality/ComplexPaths.hpp>
#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[] = {
  "networkit/centrality.pyx",
  "<stringsource>",
  "networkit/base.pxd",
  "networkit/structures.pxd",
  "networkit/dynamics.pxd",
  "networkit/graph.pxd",
};
/* #### Code section: utility_code_proto_before_types ### */
/* Atomics.proto */
#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)
    #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)
    #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_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)
    #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
    #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)
    #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
#if CYTHON_ATOMICS
    #define __pyx_add_acquisition_count(memview)\
             __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview))
    #define __pyx_sub_acquisition_count(memview)\
            __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview))
#else
    #define __pyx_add_acquisition_count(memview)\
            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
    #define __pyx_sub_acquisition_count(memview)\
            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
#endif

/* IncludeStructmemberH.proto */
#include <structmember.h>

/* CriticalSections.proto */
#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#define __Pyx_PyCriticalSection void*
#define __Pyx_PyCriticalSection2 void*
#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs
#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs
#define __Pyx_PyCriticalSection_End1(cs)
#define __Pyx_PyCriticalSection_End2(cs)
#else
#define __Pyx_PyCriticalSection PyCriticalSection
#define __Pyx_PyCriticalSection2 PyCriticalSection2
#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin
#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin
#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End
#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End
#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

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

/* "structures.pxd":8
 * from libcpp.string cimport string
 * 
 * ctypedef uint64_t count             # <<<<<<<<<<<<<<
 * ctypedef uint64_t index
 * ctypedef uint64_t edgeid
*/
typedef uint64_t __pyx_t_9networkit_10structures_count;

/* "structures.pxd":9
 * 
 * ctypedef uint64_t count
 * ctypedef uint64_t index             # <<<<<<<<<<<<<<
 * ctypedef uint64_t edgeid
 * ctypedef index node
*/
typedef uint64_t __pyx_t_9networkit_10structures_index;

/* "structures.pxd":10
 * ctypedef uint64_t count
 * ctypedef uint64_t index
 * ctypedef uint64_t edgeid             # <<<<<<<<<<<<<<
 * ctypedef index node
 * ctypedef double coordinate
*/
typedef uint64_t __pyx_t_9networkit_10structures_edgeid;

/* "structures.pxd":11
 * ctypedef uint64_t index
 * ctypedef uint64_t edgeid
 * ctypedef index node             # <<<<<<<<<<<<<<
 * ctypedef double coordinate
 * ctypedef double edgeweight
*/
typedef __pyx_t_9networkit_10structures_index __pyx_t_9networkit_10structures_node;

/* "structures.pxd":12
 * ctypedef uint64_t edgeid
 * ctypedef index node
 * ctypedef double coordinate             # <<<<<<<<<<<<<<
 * ctypedef double edgeweight
 * 
*/
typedef double __pyx_t_9networkit_10structures_coordinate;

/* "structures.pxd":13
 * ctypedef index node
 * ctypedef double coordinate
 * ctypedef double edgeweight             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "cython_helper.h":
*/
typedef double __pyx_t_9networkit_10structures_edgeweight;
/* #### Code section: complex_type_declarations ### */
/* #### Code section: type_declarations ### */

/*--- Type declarations ---*/
struct __pyx_obj_9networkit_4base__CythonParentClass;
struct __pyx_obj_9networkit_4base_Algorithm;
struct __pyx_obj_9networkit_10structures_Cover;
struct __pyx_obj_9networkit_10structures_Partition;
struct __pyx_obj_9networkit_8dynamics_GraphEvent;
struct __pyx_obj_9networkit_5graph_Graph;
struct __pyx_obj_9networkit_5graph_NodeIntAttribute;
struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute;
struct __pyx_obj_9networkit_5graph_NodeStringAttribute;
struct __pyx_obj_9networkit_5graph_EdgeIntAttribute;
struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute;
struct __pyx_obj_9networkit_5graph_EdgeStringAttribute;
struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest;
struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest;
struct __pyx_obj_9networkit_10centrality_Centrality;
struct __pyx_obj_9networkit_10centrality_Betweenness;
struct __pyx_obj_9networkit_10centrality_ApproxBetweenness;
struct __pyx_obj_9networkit_10centrality_EstimateBetweenness;
struct __pyx_obj_9networkit_10centrality_KadabraBetweenness;
struct __pyx_obj_9networkit_10centrality_DynBetweenness;
struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness;
struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode;
struct __pyx_obj_9networkit_10centrality_Closeness;
struct __pyx_obj_9networkit_10centrality_ApproxCloseness;
struct __pyx_obj_9networkit_10centrality_DegreeCentrality;
struct __pyx_obj_9networkit_10centrality_HarmonicCloseness;
struct __pyx_obj_9networkit_10centrality_TopCloseness;
struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness;
struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness;
struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage;
struct __pyx_obj_9networkit_10centrality_GroupDegree;
struct __pyx_obj_9networkit_10centrality_GedWalk;
struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness;
struct __pyx_obj_9networkit_10centrality_GroupCloseness;
struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink;
struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps;
struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness;
struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch;
struct __pyx_obj_9networkit_10centrality_KPathCentrality;
struct __pyx_obj_9networkit_10centrality_KatzCentrality;
struct __pyx_obj_9networkit_10centrality_DynKatzCentrality;
struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient;
struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient;
struct __pyx_obj_9networkit_10centrality_Sfigality;
struct __pyx_obj_9networkit_10centrality_PermanenceCentrality;
struct __pyx_obj_9networkit_10centrality_LaplacianCentrality;
struct __pyx_obj_9networkit_10centrality_CoreDecomposition;
struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality;
struct __pyx_obj_9networkit_10centrality_PageRank;
struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality;
struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness;
struct __pyx_obj_9networkit_10centrality_ForestCentrality;
struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge;
struct __pyx_obj_9networkit_10centrality_ComplexPathMode;
struct __pyx_obj_9networkit_10centrality_ComplexPaths;
struct __pyx_defaults;

/* "base.pxd":9
 * 		bool_t hasFinished() except +
 * 
 * cdef class _CythonParentClass:             # <<<<<<<<<<<<<<
 * 	cdef _Algorithm *_this
 * 
*/
struct __pyx_obj_9networkit_4base__CythonParentClass {
  PyObject_HEAD
  NetworKit::Algorithm *_this;
};


/* "base.pxd":12
 * 	cdef _Algorithm *_this
 * 
 * cdef class Algorithm(_CythonParentClass):             # <<<<<<<<<<<<<<
 * 	pass
*/
struct __pyx_obj_9networkit_4base_Algorithm {
  struct __pyx_obj_9networkit_4base__CythonParentClass __pyx_base;
};


/* "structures.pxd":50
 * 		set[index] getSubsetIds() except +
 * 
 * cdef class Cover:             # <<<<<<<<<<<<<<
 * 	cdef _Cover _this
 * 	cdef setThis(self, _Cover& other)
*/
struct __pyx_obj_9networkit_10structures_Cover {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_10structures_Cover *__pyx_vtab;
  NetworKit::Cover _this;
};


/* "structures.pxd":86
 * 		index operator[](index) except +
 * 
 * cdef class Partition:             # <<<<<<<<<<<<<<
 * 	cdef _Partition _this
 * 	cdef setThis(self, _Partition& other)
*/
struct __pyx_obj_9networkit_10structures_Partition {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_10structures_Partition *__pyx_vtab;
  NetworKit::Partition _this;
};


/* "dynamics.pxd":36
 * 		bool_t operator>=(_GraphEvent)
 * 
 * cdef class GraphEvent:             # <<<<<<<<<<<<<<
 * 	cdef _GraphEvent _this
*/
struct __pyx_obj_9networkit_8dynamics_GraphEvent {
  PyObject_HEAD
  NetworKit::GraphEvent _this;
};


/* "graph.pxd":289
 * 		void swap(_EdgeStringAttribute& other)
 * 
 * cdef class Graph:             # <<<<<<<<<<<<<<
 * 	cdef _Graph _this
 * 	cdef setThis(self, _Graph& other)
*/
struct __pyx_obj_9networkit_5graph_Graph {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_Graph *__pyx_vtab;
  NetworKit::Graph _this;
};


/* "graph.pxd":293
 * 	cdef setThis(self, _Graph& other)
 * 
 * cdef class NodeIntAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeIntAttribute _this
 * 	cdef _NodeIntAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_NodeIntAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_NodeIntAttribute *__pyx_vtab;
  NetworKit::Graph::NodeIntAttribute _this;
  NetworKit::Graph::NodeIntAttribute::Iterator _iter;
  NetworKit::Graph::NodeIntAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":300
 * 	cdef setThis(self, _NodeIntAttribute& other, _Graph* graph)
 * 
 * cdef class NodeDoubleAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeDoubleAttribute _this
 * 	cdef _NodeDoubleAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_NodeDoubleAttribute *__pyx_vtab;
  NetworKit::Graph::NodeDoubleAttribute _this;
  NetworKit::Graph::NodeDoubleAttribute::Iterator _iter;
  NetworKit::Graph::NodeDoubleAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":307
 * 	cdef setThis(self, _NodeDoubleAttribute& other, _Graph* graph)
 * 
 * cdef class NodeStringAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeStringAttribute _this
 * 	cdef _NodeStringAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_NodeStringAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_NodeStringAttribute *__pyx_vtab;
  NetworKit::Graph::NodeStringAttribute _this;
  NetworKit::Graph::NodeStringAttribute::Iterator _iter;
  NetworKit::Graph::NodeStringAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":314
 * 	cdef setThis(self, _NodeStringAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeIntAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeIntAttribute _this
 * 	cdef _EdgeIntAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_EdgeIntAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_EdgeIntAttribute *__pyx_vtab;
  NetworKit::Graph::EdgeIntAttribute _this;
  NetworKit::Graph::EdgeIntAttribute::Iterator _iter;
  NetworKit::Graph::EdgeIntAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":321
 * 	cdef setThis(self, _EdgeIntAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeDoubleAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeDoubleAttribute _this
 * 	cdef _EdgeDoubleAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_EdgeDoubleAttribute *__pyx_vtab;
  NetworKit::Graph::EdgeDoubleAttribute _this;
  NetworKit::Graph::EdgeDoubleAttribute::Iterator _iter;
  NetworKit::Graph::EdgeDoubleAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":328
 * 	cdef setThis(self, _EdgeDoubleAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeStringAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeStringAttribute _this
 * 	cdef _EdgeStringAttribute._AttributeIterator _iter
*/
struct __pyx_obj_9networkit_5graph_EdgeStringAttribute {
  PyObject_HEAD
  struct __pyx_vtabstruct_9networkit_5graph_EdgeStringAttribute *__pyx_vtab;
  NetworKit::Graph::EdgeStringAttribute _this;
  NetworKit::Graph::EdgeStringAttribute::Iterator _iter;
  NetworKit::Graph::EdgeStringAttribute::Iterator _stopiter;
  NetworKit::Graph *_G;
};


/* "graph.pxd":364
 * 		bool_t inMSF(node u, node v) except +
 * 
 * cdef class RandomMaximumSpanningForest(Algorithm):             # <<<<<<<<<<<<<<
 * 	cdef vector[double] _attribute
 * 	cdef Graph _G
*/
struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  std::vector<double>  _attribute;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "graph.pxd":379
 * 		bool_t inUMSF(node u, node v) except +
 * 
 * cdef class UnionMaximumSpanningForest(Algorithm):             # <<<<<<<<<<<<<<
 * 	cdef Graph _G
*/
struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":36
 * 		double centralization() except +
 * 
 * cdef class Centrality(Algorithm):             # <<<<<<<<<<<<<<
 * 	""" Abstract base class for centrality measures"""
 * 
*/
struct __pyx_obj_9networkit_10centrality_Centrality {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":140
 * 		vector[double] edgeScores() except +
 * 
 * cdef class Betweenness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	Betweenness(G, normalized=False, computeEdgeCentrality=False)
*/
struct __pyx_obj_9networkit_10centrality_Betweenness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":183
 * 		count numberOfSamples() except +
 * 
 * cdef class ApproxBetweenness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 *  	ApproxBetweenness(G, epsilon=0.01, delta=0.1, universalConstant=1.0)
*/
struct __pyx_obj_9networkit_10centrality_ApproxBetweenness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":224
 * 		_EstimateBetweenness(_Graph, count, bool_t, bool_t) except +
 * 
 * cdef class EstimateBetweenness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	EstimateBetweenness(G, nSamples, normalized=False, parallel=False)
*/
struct __pyx_obj_9networkit_10centrality_EstimateBetweenness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":264
 * 		double getOmega() except +
 * 
 * cdef class KadabraBetweenness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	KadabraBetweenness(Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0, unionSample = 0, startFactor = 100
*/
struct __pyx_obj_9networkit_10centrality_KadabraBetweenness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
};


/* "networkit/centrality.pyx":415
 * 		double score(node) except +
 * 
 * cdef class DynBetweenness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynBetweenness(G)
*/
struct __pyx_obj_9networkit_10centrality_DynBetweenness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":487
 * 		count getNumberOfSamples() except +
 * 
 * cdef class DynApproxBetweenness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynApproxBetweenness(G, epsilon=0.01, delta=0.1, storePredecessors=True, universalConstant=1.0)
*/
struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":587
 * 		double getbcx() except +
 * 
 * cdef class DynBetweennessOneNode(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynBetweennessOneNode(G, x)
*/
struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":684
 * 		_Closeness(_Graph, bool, bool) except +
 * 
 * cdef class Closeness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	Closeness(G, normalized, checkConnectedness)
*/
struct __pyx_obj_9networkit_10centrality_Closeness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":749
 * 		vector[double] getSquareErrorEstimates() except +
 * 
 * cdef class ApproxCloseness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ApproxCloseness(G, nSamples, epsilon=0.1, normalized=False, type=networkit.centrality.ClosenessType.OUTBOUND)
*/
struct __pyx_obj_9networkit_10centrality_ApproxCloseness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":804
 * 		_DegreeCentrality(_Graph, bool_t normalized, bool_t outdeg, bool_t ignoreSelfLoops) except +
 * 
 * cdef class DegreeCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DegreeCentrality(G, normalized=False, outDeg=True, ignoreSelfLoops=True)
*/
struct __pyx_obj_9networkit_10centrality_DegreeCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":836
 * 		_HarmonicCloseness(_Graph, bool_t) except +
 * 
 * cdef class HarmonicCloseness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	HarmonicCloseness(G, normalized=True)
*/
struct __pyx_obj_9networkit_10centrality_HarmonicCloseness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":872
 * 
 * 
 * cdef class TopCloseness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	TopCloseness(G, k=1, first_heu=True, sec_heu=True)
*/
struct __pyx_obj_9networkit_10centrality_TopCloseness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":974
 * 
 * 
 * cdef class TopHarmonicCloseness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	TopHarmonicCloseness(G, k=1, useNBbound=False)
*/
struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1079
 * 		vector[edgeweight] topkScoresList(bool_t) except +
 * 
 * cdef class DynTopHarmonicCloseness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynTopHarmonicCloseness(G, k=1, useBFSbound=True)
*/
struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1184
 * 		_LocalPartitionCoverage(_Graph, _Partition) except +
 * 
 * cdef class LocalPartitionCoverage(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	LocalPartitionCoverage(G, P)
*/
struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
  struct __pyx_obj_9networkit_10structures_Partition *_P;
};


/* "networkit/centrality.pyx":1213
 * 		count scoreOfGroup(vector[node]) except +
 * 
 * cdef class GroupDegree(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupDegree(G, k = 1, countGroupNodes = True)
*/
struct __pyx_obj_9networkit_10centrality_GroupDegree {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1325
 * 		double scoreOfGroup[InputIt](InputIt first, InputIt last, double epsilon) except +
 * 
 * cdef class GedWalk(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GedWalk(Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = networkit.centrality.BoundStrategy.GEOMETRIC, gs = networkit.centrality.GreedyStrategy.LAZY, spectralDelta = 0.5)
*/
struct __pyx_obj_9networkit_10centrality_GedWalk {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1440
 * 		count scoreOfGroup(vector[node]) except +
 * 
 * cdef class ApproxGroupBetweenness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ApproxGroupBetweenness(G, groupSize, epsilon)
*/
struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1502
 * 			double scoreOfGroup(vector[node]) except +
 * 
 * cdef class GroupCloseness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupCloseness(G, k=1, H=0)
*/
struct __pyx_obj_9networkit_10centrality_GroupCloseness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1586
 * 		count maxIterations
 * 
 * cdef class GroupClosenessGrowShrink(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupClosenessGrowShrink(Graph G, group, extended = False, insertions = 0)
*/
struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1646
 * 		count numberOfSwaps() except +
 * 
 * cdef class GroupClosenessLocalSwaps(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupClosenessLocalSwaps(Graph G, group, maxSwaps = 0)
*/
struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1706
 * 		double scoreOfGroup[InputIt](_Graph G, InputIt first, InputIt last) except +
 * 
 * cdef class GroupHarmonicCloseness(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupHarmonicCloseness(Graph G, k = 1)
*/
struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1779
 * 		count maxIterations
 * 
 * cdef class GroupClosenessLocalSearch(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	GroupClosenessLocalSearch(Graph G, group, runGrowShrink, maxIterations)
*/
struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":1852
 * 		_KPathCentrality(_Graph, double, count) except +
 * 
 * cdef class KPathCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	KPathCentrality(G, alpha=0.2, k=0)
*/
struct __pyx_obj_9networkit_10centrality_KPathCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":1891
 * 		_EdgeDirection edgeDirection
 * 
 * cdef class KatzCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	KatzCentrality(G, alpha=0, beta=0.1, tol=1e-8)
*/
struct __pyx_obj_9networkit_10centrality_KatzCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":1941
 * 		bool_t areDistinguished(node, node) except +
 * 
 * cdef class DynKatzCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	""""
 * 	DynKatzCentrality(G, k, groupOnly=False, tolerance=1e-9)
*/
struct __pyx_obj_9networkit_10centrality_DynKatzCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2024
 * 		_LocalClusteringCoefficient(_Graph, bool_t) except +
 * 
 * cdef class LocalClusteringCoefficient(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	LocalClusteringCoefficient(G, turbo=False)
*/
struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2056
 * 
 * 
 * cdef class LocalSquareClusteringCoefficient(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	LocalSquareClusteringCoefficient(G)
*/
struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2078
 * 		_Sfigality(_Graph) except +
 * 
 * cdef class Sfigality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	Sfigality(G)
*/
struct __pyx_obj_9networkit_10centrality_Sfigality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2102
 * 		double getPermanence(node u) except +
 * 
 * cdef class PermanenceCentrality(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	PermanenceCentrality(Graph G, Partition P)
*/
struct __pyx_obj_9networkit_10centrality_PermanenceCentrality {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
  struct __pyx_obj_9networkit_10structures_Partition *_P;
};


/* "networkit/centrality.pyx":2168
 * 		_LaplacianCentrality(_Graph, bool_t) except +
 * 
 * cdef class LaplacianCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	LaplacianCentrality(G, normalized=False)
*/
struct __pyx_obj_9networkit_10centrality_LaplacianCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2202
 * 		vector[node] getNodeOrder() except +
 * 
 * cdef class CoreDecomposition(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	CoreDecomposition(G, normalized=False, enforceBucketQueueAlgorithm=False, storeNodeOrder = False)
*/
struct __pyx_obj_9networkit_10centrality_CoreDecomposition {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2283
 * 		_EigenvectorCentrality(_Graph, double tol) except +
 * 
 * cdef class EigenvectorCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	EigenvectorCentrality(G, tol=1e-9)
*/
struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2334
 * 		count maxIterations
 * 
 * cdef class PageRank(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	PageRank(G, damp=0.85, tol=1e-9, normalized=False, distributeSinks=SinkHandling.NoSinkHandling)
*/
struct __pyx_obj_9networkit_10centrality_PageRank {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2427
 * 		vector[double] scores() except +
 * 
 * cdef class SpanningEdgeCentrality(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	SpanningEdgeCentrality(G, tol = 0.1)
*/
struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":2487
 * 		vector[double] computeExactDiagonal(double tol) except +
 * 
 * cdef class ApproxElectricalCloseness(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ApproxElectricalCloseness(G, eps = 0.1, kappa = 0.3)
*/
struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2554
 * 		vector[double] &getDiagonal() except +
 * 
 * cdef class ForestCentrality(Centrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ForestCentrality(G, root, eps=0.1, kappa=0.3)
*/
struct __pyx_obj_9networkit_10centrality_ForestCentrality {
  struct __pyx_obj_9networkit_10centrality_Centrality __pyx_base;
};


/* "networkit/centrality.pyx":2606
 * 		vector[edgeweight] scores() except +
 * 
 * cdef class ApproxSpanningEdge(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ApproxSpanningEdge(G, eps = 0.1)
*/
struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":2942
 * 		allNodes,
 * 
 * cdef class ComplexPathMode(object):             # <<<<<<<<<<<<<<
 * 	SINGLE_NODE = _Mode.singleNode
 * 	ALL_NODES   = _Mode.allNodes
*/
struct __pyx_obj_9networkit_10centrality_ComplexPathMode {
  PyObject_HEAD
};


/* "networkit/centrality.pyx":2954
 * 		_Graph &getComplexGraph() except +
 * 
 * cdef class ComplexPaths(Algorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ComplexPaths(G, threshold, mode, start)
*/
struct __pyx_obj_9networkit_10centrality_ComplexPaths {
  struct __pyx_obj_9networkit_4base_Algorithm __pyx_base;
  struct __pyx_obj_9networkit_5graph_Graph *_G;
};


/* "networkit/centrality.pyx":2642
 * 		return (<_ApproxSpanningEdge*>(self._this)).scores();
 * 
 * def ranking(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ranking(G, algorithm=networkit.centrality.Betweenness, normalized=False)
*/
struct __pyx_defaults {
  PyObject_HEAD
  PyObject *arg0;
};



/* "structures.pxd":50
 * 		set[index] getSubsetIds() except +
 * 
 * cdef class Cover:             # <<<<<<<<<<<<<<
 * 	cdef _Cover _this
 * 	cdef setThis(self, _Cover& other)
*/

struct __pyx_vtabstruct_9networkit_10structures_Cover {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_10structures_Cover *, NetworKit::Cover &);
};
static struct __pyx_vtabstruct_9networkit_10structures_Cover *__pyx_vtabptr_9networkit_10structures_Cover;


/* "structures.pxd":86
 * 		index operator[](index) except +
 * 
 * cdef class Partition:             # <<<<<<<<<<<<<<
 * 	cdef _Partition _this
 * 	cdef setThis(self, _Partition& other)
*/

struct __pyx_vtabstruct_9networkit_10structures_Partition {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_10structures_Partition *, NetworKit::Partition &);
};
static struct __pyx_vtabstruct_9networkit_10structures_Partition *__pyx_vtabptr_9networkit_10structures_Partition;


/* "graph.pxd":289
 * 		void swap(_EdgeStringAttribute& other)
 * 
 * cdef class Graph:             # <<<<<<<<<<<<<<
 * 	cdef _Graph _this
 * 	cdef setThis(self, _Graph& other)
*/

struct __pyx_vtabstruct_9networkit_5graph_Graph {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_Graph *, NetworKit::Graph &);
};
static struct __pyx_vtabstruct_9networkit_5graph_Graph *__pyx_vtabptr_9networkit_5graph_Graph;


/* "graph.pxd":293
 * 	cdef setThis(self, _Graph& other)
 * 
 * cdef class NodeIntAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeIntAttribute _this
 * 	cdef _NodeIntAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_NodeIntAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_NodeIntAttribute *, NetworKit::Graph::NodeIntAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_NodeIntAttribute *__pyx_vtabptr_9networkit_5graph_NodeIntAttribute;


/* "graph.pxd":300
 * 	cdef setThis(self, _NodeIntAttribute& other, _Graph* graph)
 * 
 * cdef class NodeDoubleAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeDoubleAttribute _this
 * 	cdef _NodeDoubleAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_NodeDoubleAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute *, NetworKit::Graph::NodeDoubleAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_NodeDoubleAttribute *__pyx_vtabptr_9networkit_5graph_NodeDoubleAttribute;


/* "graph.pxd":307
 * 	cdef setThis(self, _NodeDoubleAttribute& other, _Graph* graph)
 * 
 * cdef class NodeStringAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _NodeStringAttribute _this
 * 	cdef _NodeStringAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_NodeStringAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_NodeStringAttribute *, NetworKit::Graph::NodeStringAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_NodeStringAttribute *__pyx_vtabptr_9networkit_5graph_NodeStringAttribute;


/* "graph.pxd":314
 * 	cdef setThis(self, _NodeStringAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeIntAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeIntAttribute _this
 * 	cdef _EdgeIntAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_EdgeIntAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute *, NetworKit::Graph::EdgeIntAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_EdgeIntAttribute *__pyx_vtabptr_9networkit_5graph_EdgeIntAttribute;


/* "graph.pxd":321
 * 	cdef setThis(self, _EdgeIntAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeDoubleAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeDoubleAttribute _this
 * 	cdef _EdgeDoubleAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_EdgeDoubleAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute *, NetworKit::Graph::EdgeDoubleAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_EdgeDoubleAttribute *__pyx_vtabptr_9networkit_5graph_EdgeDoubleAttribute;


/* "graph.pxd":328
 * 	cdef setThis(self, _EdgeDoubleAttribute& other, _Graph* graph)
 * 
 * cdef class EdgeStringAttribute:             # <<<<<<<<<<<<<<
 * 	cdef _EdgeStringAttribute _this
 * 	cdef _EdgeStringAttribute._AttributeIterator _iter
*/

struct __pyx_vtabstruct_9networkit_5graph_EdgeStringAttribute {
  PyObject *(*setThis)(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute *, NetworKit::Graph::EdgeStringAttribute &, NetworKit::Graph *);
};
static struct __pyx_vtabstruct_9networkit_5graph_EdgeStringAttribute *__pyx_vtabptr_9networkit_5graph_EdgeStringAttribute;
/* #### 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 */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
#else
#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
#endif

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

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

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

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

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

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

/* GetModuleGlobalName.proto */
#if CYTHON_USE_DICT_VERSIONS
#define __Pyx_GetModuleGlobalName(var, name)  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

/* PyFunctionFastCall.proto */
#if CYTHON_FAST_PYCALL
#if !CYTHON_VECTORCALL
#define __Pyx_PyFunction_FastCall(func, args, nargs)\
    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs);
#endif
#define __Pyx_BUILD_ASSERT_EXPR(cond)\
    (sizeof(char [1 - 2*!(cond)]) - 1)
#ifndef Py_MEMBER_SIZE
#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
#endif
#if !CYTHON_VECTORCALL
#if PY_VERSION_HEX >= 0x03080000
  #include "frameobject.h"
  #define __Pxy_PyFrame_Initialize_Offsets()
  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
#else
  static size_t __pyx_pyframe_localsplus_offset = 0;
  #include "frameobject.h"
  #define __Pxy_PyFrame_Initialize_Offsets()\
    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
  #define __Pyx_PyFrame_GetLocalsplus(frame)\
    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
#endif
#endif
#endif

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

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

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

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

/* IncludeStringH.proto */
#include <string.h>

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

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

/* fastcall.proto */
#if CYTHON_AVOID_BORROWED_REFS
    #define __Pyx_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

/* KeywordStringCheck.proto */
static CYTHON_INLINE int __Pyx_CheckKeywordStrings(const char* function_name, PyObject *kw);

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

/* 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);

/* RejectKeywords.proto */
static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds);

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

/* 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
);

/* CallCFunction.proto */
#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)

/* UnpackUnboundCMethod.proto */
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

/* 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

/* ArgTypeTest.proto */
#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
        __Pyx__ArgTypeTest(obj, type, name, exact))
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);

/* MoveIfSupported.proto */
#if CYTHON_USE_CPP_STD_MOVE
  #include <utility>
  #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x)
#else
  #define __PYX_STD_MOVE_IF_SUPPORTED(x) x
#endif

/* GetTopmostException.proto */
#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

/* PyObjectFastCallMethod.proto */
#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000
#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL)
#else
static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf);
#endif

/* PyLongBinop.proto */
#if !CYTHON_COMPILING_IN_PYPY
static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
#else
#define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
#endif

/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/* PyLongCompare.proto */
static CYTHON_INLINE int __Pyx_PyLong_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace);

/* PyLongBinop.proto */
#if !CYTHON_COMPILING_IN_PYPY
static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
#else
#define __Pyx_PyLong_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\
    (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2))
#endif

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

/* ObjectGetItem.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);
#else
#define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
#endif

/* ListAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
        Py_INCREF(x);
        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
        L->ob_item[len] = x;
        #else
        PyList_SET_ITEM(list, len, x);
        #endif
        __Pyx_SET_SIZE(list, len + 1);
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif

/* PyObjectDelAttr.proto */
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL)
#else
#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n)
#endif

/* PyObjectSetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);
#else
#define __Pyx_PyObject_DelAttrStr(o,n)   __Pyx_PyObject_DelAttr(o,n)
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif

/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);

/* PyObjectCallNoArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);

/* PyObjectGetMethod.proto */
static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);

/* PyObjectCallMethod0.proto */
static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);

/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

/* UnpackTupleError.proto */
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);

/* UnpackTuple2.proto */
static CYTHON_INLINE int __Pyx_unpack_tuple2(
    PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple);
static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
    PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
static int __Pyx_unpack_tuple2_generic(
    PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple);

/* dict_iter.proto */
static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
                                                   Py_ssize_t* p_orig_length, int* p_is_dict);
static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
                                              PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);

/* ListCompAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len)) {
        Py_INCREF(x);
        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
        L->ob_item[len] = x;
        #else
        PyList_SET_ITEM(list, len, x);
        #endif
        __Pyx_SET_SIZE(list, len + 1);
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif

/* pybytes_as_double.proto */
static double __Pyx_SlowPyString_AsDouble(PyObject *obj);
static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length);
static CYTHON_INLINE double __Pyx_PyBytes_AsDouble(PyObject *obj) {
    char* as_c_string;
    Py_ssize_t size;
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE
    as_c_string = PyBytes_AS_STRING(obj);
    size = PyBytes_GET_SIZE(obj);
#else
    if (PyBytes_AsStringAndSize(obj, &as_c_string, &size) < 0) {
        return (double)-1;
    }
#endif
    return __Pyx__PyBytes_AsDouble(obj, as_c_string, size);
}
static CYTHON_INLINE double __Pyx_PyByteArray_AsDouble(PyObject *obj) {
    char* as_c_string;
    Py_ssize_t size;
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE
    as_c_string = PyByteArray_AS_STRING(obj);
    size = PyByteArray_GET_SIZE(obj);
#else
    as_c_string = PyByteArray_AsString(obj);
    if (as_c_string == NULL) {
        return (double)-1;
    }
    size = PyByteArray_Size(obj);
#endif
    return __Pyx__PyBytes_AsDouble(obj, as_c_string, size);
}

/* pyunicode_as_double.proto */
#if !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS
static const char* __Pyx__PyUnicode_AsDouble_Copy(const void* data, const int kind, char* buffer, Py_ssize_t start, Py_ssize_t end) {
    int last_was_punctuation;
    Py_ssize_t i;
    last_was_punctuation = 1;
    for (i=start; i <= end; i++) {
        Py_UCS4 chr = PyUnicode_READ(kind, data, i);
        int is_punctuation = (chr == '_') | (chr == '.');
        *buffer = (char)chr;
        buffer += (chr != '_');
        if (unlikely(chr > 127)) goto parse_failure;
        if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure;
        last_was_punctuation = is_punctuation;
    }
    if (unlikely(last_was_punctuation)) goto parse_failure;
    *buffer = '\0';
    return buffer;
parse_failure:
    return NULL;
}
static double __Pyx__PyUnicode_AsDouble_inf_nan(const void* data, int kind, Py_ssize_t start, Py_ssize_t length) {
    int matches = 1;
    Py_UCS4 chr;
    Py_UCS4 sign = PyUnicode_READ(kind, data, start);
    int is_signed = (sign == '-') | (sign == '+');
    start += is_signed;
    length -= is_signed;
    switch (PyUnicode_READ(kind, data, start)) {
        #ifdef Py_NAN
        case 'n':
        case 'N':
            if (unlikely(length != 3)) goto parse_failure;
            chr = PyUnicode_READ(kind, data, start+1);
            matches &= (chr == 'a') | (chr == 'A');
            chr = PyUnicode_READ(kind, data, start+2);
            matches &= (chr == 'n') | (chr == 'N');
            if (unlikely(!matches)) goto parse_failure;
            return (sign == '-') ? -Py_NAN : Py_NAN;
        #endif
        case 'i':
        case 'I':
            if (unlikely(length < 3)) goto parse_failure;
            chr = PyUnicode_READ(kind, data, start+1);
            matches &= (chr == 'n') | (chr == 'N');
            chr = PyUnicode_READ(kind, data, start+2);
            matches &= (chr == 'f') | (chr == 'F');
            if (likely(length == 3 && matches))
                return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
            if (unlikely(length != 8)) goto parse_failure;
            chr = PyUnicode_READ(kind, data, start+3);
            matches &= (chr == 'i') | (chr == 'I');
            chr = PyUnicode_READ(kind, data, start+4);
            matches &= (chr == 'n') | (chr == 'N');
            chr = PyUnicode_READ(kind, data, start+5);
            matches &= (chr == 'i') | (chr == 'I');
            chr = PyUnicode_READ(kind, data, start+6);
            matches &= (chr == 't') | (chr == 'T');
            chr = PyUnicode_READ(kind, data, start+7);
            matches &= (chr == 'y') | (chr == 'Y');
            if (unlikely(!matches)) goto parse_failure;
            return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
        case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            break;
        default:
            goto parse_failure;
    }
    return 0.0;
parse_failure:
    return -1.0;
}
static double __Pyx_PyUnicode_AsDouble_WithSpaces(PyObject *obj) {
    double value;
    const char *last;
    char *end;
    Py_ssize_t start, length = PyUnicode_GET_LENGTH(obj);
    const int kind = PyUnicode_KIND(obj);
    const void* data = PyUnicode_DATA(obj);
    start = 0;
    while (Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, start)))
        start++;
    while (start < length - 1 && Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, length - 1)))
        length--;
    length -= start;
    if (unlikely(length <= 0)) goto fallback;
    value = __Pyx__PyUnicode_AsDouble_inf_nan(data, kind, start, length);
    if (unlikely(value == -1.0)) goto fallback;
    if (value != 0.0) return value;
    if (length < 40) {
        char number[40];
        last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length);
        if (unlikely(!last)) goto fallback;
        value = PyOS_string_to_double(number, &end, NULL);
    } else {
        char *number = (char*) PyMem_Malloc((length + 1) * sizeof(char));
        if (unlikely(!number)) goto fallback;
        last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length);
        if (unlikely(!last)) {
            PyMem_Free(number);
            goto fallback;
        }
        value = PyOS_string_to_double(number, &end, NULL);
        PyMem_Free(number);
    }
    if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) {
        return value;
    }
fallback:
    return __Pyx_SlowPyString_AsDouble(obj);
}
#endif
static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj) {
#if !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS
    if (unlikely(__Pyx_PyUnicode_READY(obj) == -1))
        return (double)-1;
    if (likely(PyUnicode_IS_ASCII(obj))) {
        const char *s;
        Py_ssize_t length;
        s = PyUnicode_AsUTF8AndSize(obj, &length);
        return __Pyx__PyBytes_AsDouble(obj, s, length);
    }
    return __Pyx_PyUnicode_AsDouble_WithSpaces(obj);
#else
    return __Pyx_SlowPyString_AsDouble(obj);
#endif
}

/* pynumber_float.proto */
static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj);
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : __Pyx__PyNumber_Float(x))

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

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

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

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

/* dict_setdefault.proto */
static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type);

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

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

/* CallTypeTraverse.proto */
#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 */
static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ);

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

/* CythonFunctionShared.proto */
#define __Pyx_CyFunction_USED
#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
#define __Pyx_CYFUNCTION_CCLASS        0x04
#define __Pyx_CYFUNCTION_COROUTINE     0x08
#define __Pyx_CyFunction_GetClosure(f)\
    (((__pyx_CyFunctionObject *) (f))->func_closure)
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
  #define __Pyx_CyFunction_GetClassObj(f)\
      (((__pyx_CyFunctionObject *) (f))->func_classobj)
#else
  #define __Pyx_CyFunction_GetClassObj(f)\
      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
#endif
#define __Pyx_CyFunction_SetClassObj(f, classobj)\
    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
#define __Pyx_CyFunction_Defaults(type, f)\
    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
typedef struct {
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject_HEAD
    PyObject *func;
#elif PY_VERSION_HEX < 0x030900B1
    PyCFunctionObject func;
#else
    PyCMethodObject func;
#endif
#if CYTHON_BACKPORT_VECTORCALL ||\
        (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL)
    __pyx_vectorcallfunc func_vectorcall;
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *func_weakreflist;
#endif
    PyObject *func_dict;
    PyObject *func_name;
    PyObject *func_qualname;
    PyObject *func_doc;
    PyObject *func_globals;
    PyObject *func_code;
    PyObject *func_closure;
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
    PyObject *func_classobj;
#endif
    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_BACKPORT_VECTORCALL || 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);

/* PyObjectVectorCallKwBuilder.proto */
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

/* PyObjectVectorCallMethodKwBuilder.proto */
#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000
#define __Pyx_Object_VectorcallMethod_CallFromBuilder PyObject_VectorcallMethod
#else
static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames);
#endif

/* GetAttr3.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);

/* RaiseUnexpectedTypeError.proto */
static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);

/* PySequenceContains.proto */
static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
    int result = PySequence_Contains(seq, item);
    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}

/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

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

/* HasAttr.proto */
#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

/* CallNextTpDealloc.proto */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc);

/* CallNextTpTraverse.proto */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse);

/* CallNextTpClear.proto */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear);

/* TypeImport.proto */
#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_4
#define __PYX_HAVE_RT_ImportType_proto_3_1_4
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#include <stdalign.h>
#endif
#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
#define __PYX_GET_STRUCT_ALIGNMENT_3_1_4(s) alignof(s)
#else
#define __PYX_GET_STRUCT_ALIGNMENT_3_1_4(s) sizeof(void*)
#endif
enum __Pyx_ImportType_CheckSize_3_1_4 {
   __Pyx_ImportType_CheckSize_Error_3_1_4 = 0,
   __Pyx_ImportType_CheckSize_Warn_3_1_4 = 1,
   __Pyx_ImportType_CheckSize_Ignore_3_1_4 = 2
};
static PyTypeObject *__Pyx_ImportType_3_1_4(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_4 check_size);
#endif

/* ValidateBasesTuple.proto */
#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
#endif

/* PyType_Ready.proto */
CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);

/* DelItemOnTypeDict.proto */
static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k);
#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k)

/* SetupReduce.proto */
static int __Pyx_setup_reduce(PyObject* type_obj);

/* GetVTable.proto */
static void* __Pyx_GetVtable(PyTypeObject *type);

/* ListPack.proto */
static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...);

/* GetAttr.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);

/* Globals.proto */
static PyObject* __Pyx_Globals(void);

/* ImportDottedModule.proto */
static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple);
static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple);

/* Py3UpdateBases.proto */
static PyObject* __Pyx_PEP560_update_bases(PyObject *bases);

/* CalculateMetaclass.proto */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);

/* SetNameInClass.proto */
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
#define __Pyx_SetNameInClass(ns, name, value)\
    (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value))
#elif CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_SetNameInClass(ns, name, value)\
    (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value))
#else
#define __Pyx_SetNameInClass(ns, name, value)  PyObject_SetItem(ns, name, value)
#endif

/* PyObjectCall2Args.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);

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

/* Py3ClassCreate.proto */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
                                           PyObject *mkw, PyObject *modname, PyObject *doc);
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
                                      PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);

/* GetNameInClass.proto */
#define __Pyx_GetNameInClass(var, nmspace, name)  (var) = __Pyx__GetNameInClass(nmspace, name)
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name);

/* CLineInTraceback.proto */
#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 */
#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);

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

/* LengthHint.proto */
#if CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_PyObject_LengthHint(o, defaultval)  (defaultval)
#else
#define __Pyx_PyObject_LengthHint(o, defaultval)  PyObject_LengthHint(o, defaultval)
#endif

/* CppExceptionConversion.proto */
#ifndef __Pyx_CppExn2PyErr
#include <new>
#include <typeinfo>
#include <stdexcept>
#include <ios>
static void __Pyx_CppExn2PyErr() {
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
  } catch (const std::bad_typeid& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::ios_base::failure& exn) {
    PyErr_SetString(PyExc_IOError, exn.what());
  } catch (const std::out_of_range& exn) {
    PyErr_SetString(PyExc_IndexError, exn.what());
  } catch (const std::overflow_error& exn) {
    PyErr_SetString(PyExc_OverflowError, exn.what());
  } catch (const std::range_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::underflow_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(enum NetworKit::ApproxCloseness::ClosenessType value);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::ApproxCloseness::ClosenessType __Pyx_PyLong_As_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE uint64_t __Pyx_PyLong_As_uint64_t(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(enum NetworKit::GedWalk::BoundStrategy value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(enum NetworKit::GedWalk::GreedyStrategy value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_EdgeDirection(enum NetworKit::EdgeDirection value);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::EdgeDirection __Pyx_PyLong_As_enum__NetworKit_3a__3a_EdgeDirection(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(enum NetworKit::PageRank::Norm value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(enum NetworKit::PageRank::SinkHandling value);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::PageRank::Norm __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(enum NetworKit::ComplexPathAlgorithm::Mode value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint64_t(uint64_t value);

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

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::ClosenessVariant __Pyx_PyLong_As_enum__NetworKit_3a__3a_ClosenessVariant(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::GedWalk::BoundStrategy __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::GedWalk::GreedyStrategy __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::PageRank::SinkHandling __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(PyObject *);

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

/* CIntFromPy.proto */
static CYTHON_INLINE enum NetworKit::ComplexPathAlgorithm::Mode __Pyx_PyLong_As_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(enum NetworKit::ClosenessVariant value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value);

/* 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

/* 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 */
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);

/* 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 "libcpp.vector" */

/* Module declarations from "libcpp.utility" */

/* Module declarations from "libcpp" */

/* Module declarations from "networkit.base" */

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

/* Module declarations from "libcpp.string_view" */

/* Module declarations from "libcpp.string" */

/* Module declarations from "libcpp.map" */

/* Module declarations from "libcpp.set" */

/* Module declarations from "networkit.structures" */

/* Module declarations from "networkit.dynamics" */

/* Module declarations from "networkit.dynbase" */

/* Module declarations from "libcpp.unordered_set" */

/* Module declarations from "networkit.graph" */

/* Module declarations from "networkit.centrality" */
static PyObject *__Pyx_EnumBase = 0;
static PyObject *__Pyx_FlagBase = 0;
static PyObject *__pyx_f_9networkit_10centrality___pyx_unpickle_ComplexPathMode__set_state(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *, PyObject *); /*proto*/
static PyObject *__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(enum NetworKit::ClosenessVariant); /*proto*/
static PyObject *__pyx_convert_vector_to_py_double(std::vector<double>  const &); /*proto*/
static PyObject *__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double(std::pair<__pyx_t_9networkit_10structures_node,double>  const &); /*proto*/
static PyObject *__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  const &); /*proto*/
static PyObject *__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(std::vector<__pyx_t_9networkit_10structures_node>  const &); /*proto*/
static PyObject *__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(std::vector<__pyx_t_9networkit_10structures_edgeweight>  const &); /*proto*/
static PyObject *__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight(std::pair<__pyx_t_9networkit_10structures_node,__pyx_t_9networkit_10structures_edgeweight>  const &); /*proto*/
static PyObject *__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(std::vector<std::pair<__pyx_t_9networkit_10structures_node,__pyx_t_9networkit_10structures_edgeweight> >  const &); /*proto*/
static std::vector<__pyx_t_9networkit_10structures_node>  __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(PyObject *); /*proto*/
/* #### Code section: typeinfo ### */
/* #### Code section: before_global_var ### */
#define __Pyx_MODULE_NAME "networkit.centrality"
extern int __pyx_module_is_main_networkit__centrality;
int __pyx_module_is_main_networkit__centrality = 0;

/* Implementation of "networkit.centrality" */
/* #### Code section: global_var ### */
static PyObject *__pyx_builtin_object;
static PyObject *__pyx_builtin_staticmethod;
static PyObject *__pyx_builtin_RuntimeError;
static PyObject *__pyx_builtin_TypeError;
static PyObject *__pyx_builtin_enumerate;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_super;
static PyObject *__pyx_builtin_NotImplemented;
static PyObject *__pyx_builtin_sorted;
static PyObject *__pyx_builtin_NotImplementedError;
static PyObject *__pyx_builtin_sum;
static PyObject *__pyx_builtin_MemoryError;
/* #### Code section: string_decls ### */
static const char __pyx_k_G[] = "G";
static const char __pyx_k_H[] = "H";
static const char __pyx_k_P[] = "P";
static const char __pyx_k_Q[] = "\200\001\330\004\n\210+\220Q";
static const char __pyx_k_S[] = "S";
static const char __pyx_k_T[] = "\200\021\360\026\000\003\013\320\n\035\230T\240\030\250\027\260\001";
static const char __pyx_k_d[] = "\320\001(\250\001\360(\000\003\013\320\n&\240d\250(\260.\300\001\300\021";
static const char __pyx_k_i[] = "i";
static const char __pyx_k_k[] = "k";
static const char __pyx_k_n[] = "n";
static const char __pyx_k_u[] = "u";
static const char __pyx_k_v[] = "v";
static const char __pyx_k_x[] = "x";
static const char __pyx_k_AQ[] = "\200\021\330\002\t\210\023\210A\210Q";
static const char __pyx_k_HD[] = "\320\001\021\220\021\360 \000\003\013\320\n \240\004\240H\250D\260\001\260\021";
static const char __pyx_k_HM[] = "\200\021\360\026\000\003\013\320\n \240\004\240H\250M\270\021";
static const char __pyx_k_HN[] = "\200\021\360\026\000\003\013\320\n \240\004\240H\250N\270!";
static const char __pyx_k_NO[] = "NO";
static const char __pyx_k_No[] = "No";
static const char __pyx_k__6[] = ".";
static const char __pyx_k__7[] = "?";
static const char __pyx_k__8[] = "\200\021\360\014\000\003\t\210\001";
static const char __pyx_k_bs[] = "bs";
static const char __pyx_k_gc[] = "gc";
static const char __pyx_k_gs[] = "gs";
static const char __pyx_k_hk[] = "\200\021\360\030\000\003\013\320\n\032\230$\230h\240k\260\021";
static const char __pyx_k_rx[] = "rx";
static const char __pyx_k_ry[] = "ry";
static const char __pyx_k_t8[] = "\200\021\360\026\000\003\013\320\n'\240t\2508\260>\300\021";
static const char __pyx_k_4xz[] = "\200\021\360\020\000\003\013\320\n\033\2304\230x\240z\260\021";
static const char __pyx_k_D_Q[] = "\200\021\360\026\000\003\013\320\n$\240D\250\010\260\t\270\021\270#\270Q";
static const char __pyx_k_D_q[] = "\200\021\360\026\000\003\013\320\n$\240D\250\010\260\007\260q";
static const char __pyx_k_HIQ[] = "\200\021\360\026\000\003\n\320\t \240\004\240H\250I\260Q";
static const char __pyx_k_H_A[] = "\200\021\330\002\n\320\n \240\004\240H\320,<\270A";
static const char __pyx_k_QfA[] = "\200\001\330\004-\250Q\250f\260A";
static const char __pyx_k_SUM[] = "SUM";
static const char __pyx_k_Sum[] = "Sum";
static const char __pyx_k_T_1[] = "\200\021\360\026\000\003\013\320\n\035\230T\240\030\320);\2701";
static const char __pyx_k_T_2[] = "\200\021\360\030\000\003\013\320\n\035\230T\240\030\250\030\260\021";
static const char __pyx_k_T_3[] = "\200\021\360\030\000\003\013\320\n%\240T\250\030\260\027\270\001";
static const char __pyx_k_T_q[] = "\200\021\360 \000\003\013\320\n\035\230T\240\030\250\026\250q\260\001";
static const char __pyx_k_XWA[] = "\200\021\360\032\000\003\013\320\n!\240\024\240X\250W\260A";
static const char __pyx_k_XXQ[] = "\200\021\360\030\000\003\013\320\n!\240\024\240X\250X\260Q";
static const char __pyx_k_X_1[] = "\200\021\360\032\000\003\013\320\n!\240\024\240X\250^\2701";
static const char __pyx_k_X_A[] = "\200\021\360\030\000\003\013\320\n!\240\024\240X\250_\270A";
static const char __pyx_k_d_1[] = "\320\001\"\240!\360(\000\003\013\320\n&\240d\250(\260(\270!\2701";
static const char __pyx_k_d_2[] = "\320\001)\250\021\360(\000\003\013\320\n&\240d\250(\260/\300\021\300!";
static const char __pyx_k_d_B[] = "\200\021\360\026\000\003\013\320\n\036\230d\240(\320*B\300!";
static const char __pyx_k_d_Q[] = "\200\021\360\026\000\003\013\320\n\036\230d\240'\250\034\260Q";
static const char __pyx_k_doc[] = "__doc__";
static const char __pyx_k_eps[] = "eps";
static const char __pyx_k_err[] = "err";
static const char __pyx_k_evz[] = "evz";
static const char __pyx_k_get[] = "get";
static const char __pyx_k_hiq[] = "\200\021\360\034\000\003\013\320\n\032\230$\230h\240i\250q";
static const char __pyx_k_hoQ[] = "\200\021\360\026\000\003\013\320\n\032\230$\230h\240o\260Q";
static const char __pyx_k_key[] = "key";
static const char __pyx_k_new[] = "__new__";
static const char __pyx_k_pop[] = "pop";
static const char __pyx_k_run[] = "run";
static const char __pyx_k_sum[] = "sum";
static const char __pyx_k_tol[] = "tol";
static const char __pyx_k_top[] = "top";
static const char __pyx_k_val[] = "val";
static const char __pyx_k_2T_a[] = "\200\021\360\026\000\003\n\210\022\2102\210T\220\030\230\021\230$\230a";
static const char __pyx_k_4x_1[] = "\200\021\360\032\000\003\013\320\n\033\2304\230x\240|\2601";
static const char __pyx_k_4x_B[] = "\200\021\360\026\000\003\013\320\n#\2404\240x\320/B\300!";
static const char __pyx_k_4xwa[] = "\200\021\360\026\000\003\013\320\n#\2404\240x\250w\260a";
static const char __pyx_k_4xxq[] = "\200\021\360\030\000\003\013\320\n#\2404\240x\250x\260q";
static const char __pyx_k_D_3a[] = "\200\021\360\030\000\003\013\320\n$\240D\250\010\260\n\270!\2703\270a";
static const char __pyx_k_D_AS[] = "\200\021\360\026\000\003\013\320\n$\240D\250\010\260\014\270A\270S\300\001";
static const char __pyx_k_H4Fa[] = "\200\021\360\026\000\003\013\320\n(\250\004\250H\3204F\300a";
static const char __pyx_k_H4Gq[] = "\200\021\360\026\000\003\013\320\n(\250\004\250H\3204G\300q";
static const char __pyx_k_HF_1[] = "\200\021\360 \000\003\013\320\n \240\004\240H\250F\260!\2601";
static const char __pyx_k_H_Qc[] = "\200\021\360$\000\003\013\320\n \240\004\240H\320,=\270Q\270c\300\021";
static const char __pyx_k_LAZY[] = "LAZY";
static const char __pyx_k_Lazy[] = "Lazy";
static const char __pyx_k_Norm[] = "Norm";
static const char __pyx_k_T_1B[] = "\200\021\360\020\000\003\013\320\n%\240T\250\030\3201B\300!";
static const char __pyx_k_T_1J[] = "\200\021\360\020\000\003\013\320\n%\240T\250\030\3201J\310!";
static const char __pyx_k_T_aq[] = "\200\021\360 \000\003\013\320\n%\240T\250\030\260\035\270a\270q";
static const char __pyx_k_X_C1[] = "\200\021\360\026\000\003\013\320\n!\240\024\240X\320-C\3001";
static const char __pyx_k_beta[] = "beta";
static const char __pyx_k_d_6a[] = "\200\021\360\026\000\003\013\210,\220d\230(\320\"6\260a";
static const char __pyx_k_damp[] = "damp";
static const char __pyx_k_dict[] = "__dict__";
static const char __pyx_k_diff[] = "diff";
static const char __pyx_k_enum[] = "enum";
static const char __pyx_k_func[] = "__func__";
static const char __pyx_k_hm1A[] = "\200\021\360 \000\003\013\320\n\032\230$\230h\240m\2601\260A";
static const char __pyx_k_init[] = "__init__";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_math[] = "math";
static const char __pyx_k_mode[] = "mode";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_node[] = "node";
static const char __pyx_k_pair[] = "pair";
static const char __pyx_k_root[] = "root";
static const char __pyx_k_self[] = "self";
static const char __pyx_k_spec[] = "__spec__";
static const char __pyx_k_sqrt[] = "sqrt";
static const char __pyx_k_t7_a[] = "\200\021\360\026\000\003\013\320\n'\240t\2507\260,\270a";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_type[] = "type";
static const char __pyx_k_z_aq[] = "\250z\270\025\270a\270q\300\001\300\021";
static const char __pyx_k_4x_Qa[] = "\200\021\360 \000\003\013\320\n#\2404\240x\250~\270Q\270a";
static const char __pyx_k_4xvQa[] = "\200\021\360 \000\003\013\320\n#\2404\240x\250v\260Q\260a";
static const char __pyx_k_T_1EQ[] = "\200\021\360\030\000\003\013\320\n%\240T\250\030\3201E\300Q";
static const char __pyx_k_T_1K1[] = "\200\021\360\026\000\003\013\320\n%\240T\250\030\3201K\3101";
static const char __pyx_k_XWA_2[] = "\200\021\360\030\000\003\013\320\n!\240\024\240X\250W\260A";
static const char __pyx_k_alpha[] = "alpha";
static const char __pyx_k_bound[] = "bound";
static const char __pyx_k_d_2_2[] = "\200\021\360\026\000\003\013\210,\220d\230(\320\"2\260!";
static const char __pyx_k_delta[] = "delta";
static const char __pyx_k_graph[] = "graph";
static const char __pyx_k_group[] = "group";
static const char __pyx_k_index[] = "index";
static const char __pyx_k_items[] = "items";
static const char __pyx_k_kappa[] = "kappa";
static const char __pyx_k_q_T_A[] = "\320\001\037\230q\360&\000\003\013\320\n\035\230T\240\030\250\037\270\001\270\023\270A";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_score[] = "score";
static const char __pyx_k_start[] = "start";
static const char __pyx_k_state[] = "state";
static const char __pyx_k_super[] = "super";
static const char __pyx_k_t83EQ[] = "\200\021\360\026\000\003\013\320\n'\240t\2508\3203E\300Q";
static const char __pyx_k_t83Fa[] = "\200\021\360\022\000\003\013\320\n'\240t\2508\3203F\300a";
static const char __pyx_k_t8_6a[] = "\200\021\360\026\000\003\013\210-\220t\2308\320#6\260a";
static const char __pyx_k_third[] = "third";
static const char __pyx_k_turbo[] = "turbo";
static const char __pyx_k_4x_B_1[] = "\200\021\360 \000\003\013\320\n#\2404\240x\320/B\300!\3001";
static const char __pyx_k_4x_Faq[] = "\200\021\360\032\000\003\013\320\n\033\2304\230x\320'F\300a\300q";
static const char __pyx_k_4x_Naq[] = "\200\021\360\032\000\003\013\320\n#\2404\240x\320/N\310a\310q";
static const char __pyx_k_4xxq_2[] = "\200\021\360\032\000\003\013\320\n\033\2304\230x\240x\250q";
static const char __pyx_k_T_aq_2[] = "\200\021\360 \000\003\013\320\n\035\230T\240\030\250\035\260a\260q";
static const char __pyx_k_cutoff[] = "cutoff";
static const char __pyx_k_dict_2[] = "_dict";
static const char __pyx_k_enable[] = "enable";
static const char __pyx_k_getbcx[] = "getbcx";
static const char __pyx_k_l1norm[] = "l1norm";
static const char __pyx_k_l2norm[] = "l2norm";
static const char __pyx_k_lambda[] = "<lambda>";
static const char __pyx_k_length[] = "_length";
static const char __pyx_k_module[] = "module";
static const char __pyx_k_object[] = "object";
static const char __pyx_k_outDeg[] = "outDeg";
static const char __pyx_k_pickle[] = "pickle";
static const char __pyx_k_reduce[] = "__reduce__";
static const char __pyx_k_scores[] = "scores";
static const char __pyx_k_sorted[] = "sorted";
static const char __pyx_k_square[] = "square";
static const char __pyx_k_update[] = "update";
static const char __pyx_k_vector[] = "vector";
static const char __pyx_k_GedWalk[] = "GedWalk";
static const char __pyx_k_HB_4D_Q[] = "\200\021\360\026\000\003\n\210\031\220\"\220H\230B\320\0364\260D\270\010\300\r\310Q";
static const char __pyx_k_INBOUND[] = "INBOUND";
static const char __pyx_k_Inbound[] = "Inbound";
static const char __pyx_k_IntEnum[] = "IntEnum";
static const char __pyx_k_IntFlag[] = "IntFlag";
static const char __pyx_k_L1_NORM[] = "L1_NORM";
static const char __pyx_k_L2_NORM[] = "L2_NORM";
static const char __pyx_k_Q_t72Gq[] = "\320\001-\250Q\360$\000\003\013\320\n'\240t\2507\3202G\300q\310\001";
static const char __pyx_k_a_4x_Qa[] = "\320\001&\240a\360(\000\003\013\320\n\033\2304\230x\240~\260Q\260a";
static const char __pyx_k_b_0_HIQ[] = "\200\021\360\026\000\003\n\210\025\210b\220\010\230\002\320\0320\260\004\260H\270I\300Q";
static const char __pyx_k_b_4x7Gq[] = "\200\021\360\026\000\003\n\210\025\210b\220\010\230\002\320\032+\2504\250x\3207G\300q";
static const char __pyx_k_disable[] = "disable";
static const char __pyx_k_dynbase[] = "dynbase";
static const char __pyx_k_epsilon[] = "epsilon";
static const char __pyx_k_getPLci[] = "getPLci";
static const char __pyx_k_inEdges[] = "inEdges";
static const char __pyx_k_maximum[] = "maximum";
static const char __pyx_k_members[] = "__members__";
static const char __pyx_k_n_nodes[] = "n_nodes";
static const char __pyx_k_prepare[] = "__prepare__";
static const char __pyx_k_q_4x_aq[] = "\320\001'\240q\360(\000\003\013\320\n\033\2304\230x\240\177\260a\260q";
static const char __pyx_k_ranking[] = "ranking";
static const char __pyx_k_reverse[] = "reverse";
static const char __pyx_k_rnode_x[] = "rnode_x";
static const char __pyx_k_rnode_y[] = "rnode_y";
static const char __pyx_k_sec_heu[] = "sec_heu";
static const char __pyx_k_DA_6_Zt1[] = "\200\021\360&\000\003!\240\r\320-D\300A\330\004\t\210\030\220\032\2306\240\024\240Z\250t\2601";
static const char __pyx_k_IN_EDGES[] = "IN_EDGES";
static const char __pyx_k_OUTBOUND[] = "OUTBOUND";
static const char __pyx_k_Outbound[] = "Outbound";
static const char __pyx_k_PageRank[] = "PageRank";
static const char __pyx_k_SPECTRAL[] = "SPECTRAL";
static const char __pyx_k_STANDARD[] = "STANDARD";
static const char __pyx_k_SciPyEVZ[] = "SciPyEVZ";
static const char __pyx_k_Spectral[] = "Spectral";
static const char __pyx_k_Standard[] = "Standard";
static const char __pyx_k_add_note[] = "add_note";
static const char __pyx_k_allNodes[] = "allNodes";
static const char __pyx_k_extended[] = "extended";
static const char __pyx_k_getCover[] = "getCover";
static const char __pyx_k_getOmega[] = "getOmega";
static const char __pyx_k_getScore[] = "getScore";
static const char __pyx_k_getSigma[] = "getSigma";
static const char __pyx_k_getstate[] = "__getstate__";
static const char __pyx_k_groupVec[] = "groupVec";
static const char __pyx_k_maxSwaps[] = "maxSwaps";
static const char __pyx_k_module_2[] = "__module__";
static const char __pyx_k_nSamples[] = "nSamples";
static const char __pyx_k_nodeList[] = "nodeList";
static const char __pyx_k_outEdges[] = "outEdges";
static const char __pyx_k_parallel[] = "parallel";
static const char __pyx_k_prMatrix[] = "prMatrix";
static const char __pyx_k_pyx_type[] = "__pyx_type";
static const char __pyx_k_qualname[] = "__qualname__";
static const char __pyx_k_rankList[] = "rankList";
static const char __pyx_k_set_name[] = "__set_name__";
static const char __pyx_k_setstate[] = "__setstate__";
static const char __pyx_k_spectrum[] = "spectrum";
static const char __pyx_k_ALL_NODES[] = "ALL_NODES";
static const char __pyx_k_Closeness[] = "Closeness";
static const char __pyx_k_GEOMETRIC[] = "GEOMETRIC";
static const char __pyx_k_Geometric[] = "Geometric";
static const char __pyx_k_OUT_EDGES[] = "OUT_EDGES";
static const char __pyx_k_Q_iq_1_4q[] = "\320\000\030\230\r\240Q\360(\000\002\017\210i\220q\230\003\2301\330\001\013\2104\210q\330\001\010\210\n\220'\230\021";
static const char __pyx_k_Sfigality[] = "Sfigality";
static const char __pyx_k_TypeError[] = "TypeError";
static const char __pyx_k_a_4x_Qa_2[] = "\320\001&\240a\360(\000\003\013\320\n#\2404\240x\250~\270Q\270a";
static const char __pyx_k_a_iq_1_4q[] = "\320\000\031\230\035\240a\360*\000\002\017\210i\220q\230\003\2301\330\001\013\2104\210q\330\001\010\210\n\220(\230!";
static const char __pyx_k_algorithm[] = "algorithm";
static const char __pyx_k_enumerate[] = "enumerate";
static const char __pyx_k_first_heu[] = "first_heu";
static const char __pyx_k_getSigmax[] = "getSigmax";
static const char __pyx_k_groupOnly[] = "groupOnly";
static const char __pyx_k_groupSize[] = "groupSize";
static const char __pyx_k_isenabled[] = "isenabled";
static const char __pyx_k_iterNodes[] = "iterNodes";
static const char __pyx_k_metaclass[] = "__metaclass__";
static const char __pyx_k_normalize[] = "normalize";
static const char __pyx_k_prev_node[] = "prev_node";
static const char __pyx_k_pyx_state[] = "__pyx_state";
static const char __pyx_k_q_4x_aq_2[] = "\320\001'\240q\360(\000\003\013\320\n#\2404\240x\250\177\270a\270q";
static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
static const char __pyx_k_scoreList[] = "scoreList";
static const char __pyx_k_threshold[] = "threshold";
static const char __pyx_k_tolerance[] = "tolerance";
static const char __pyx_k_Centrality[] = "Centrality";
static const char __pyx_k_STOCHASTIC[] = "STOCHASTIC";
static const char __pyx_k_Stochastic[] = "Stochastic";
static const char __pyx_k_T_1_Qa_XWA[] = "\200\021\360\026\000\003\006\200T\210\027\220\003\2201\330\003\t\210\034\220Q\220a\330\002\n\210/\230\024\230X\240W\250A";
static const char __pyx_k_T_1_Qa_XXQ[] = "\200\021\360\026\000\003\006\200T\210\027\220\003\2201\330\003\t\210\034\220Q\220a\330\002\n\210/\230\024\230X\240X\250Q";
static const char __pyx_k_T_1_Qa_X_A[] = "\200\021\360\"\000\003\006\200T\210\027\220\003\2201\330\003\t\210\034\220Q\220a\330\002\n\210/\230\024\230X\240_\260A";
static const char __pyx_k_centrality[] = "centrality";
static const char __pyx_k_edgeScores[] = "edgeScores";
static const char __pyx_k_eigenvalue[] = "eigenvalue";
static const char __pyx_k_inputGroup[] = "inputGroup";
static const char __pyx_k_insertions[] = "insertions";
static const char __pyx_k_isDirected[] = "isDirected";
static const char __pyx_k_normFactor[] = "normFactor";
static const char __pyx_k_normalized[] = "normalized";
static const char __pyx_k_pyx_result[] = "__pyx_result";
static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
static const char __pyx_k_ranking_id[] = "ranking_id";
static const char __pyx_k_singleNode[] = "singleNode";
static const char __pyx_k_useNBbound[] = "useNBbound";
static const char __pyx_k_Betweenness[] = "Betweenness";
static const char __pyx_k_GENERALIZED[] = "GENERALIZED";
static const char __pyx_k_Generalized[] = "Generalized";
static const char __pyx_k_GroupDegree[] = "GroupDegree";
static const char __pyx_k_MemoryError[] = "MemoryError";
static const char __pyx_k_PickleError[] = "PickleError";
static const char __pyx_k_SINGLE_NODE[] = "SINGLE_NODE";
static const char __pyx_k_T_1_Qa_XV1A[] = "\200\021\360 \000\003\006\200T\210\027\220\003\2201\330\003\t\210\034\220Q\220a\330\002\n\210/\230\024\230X\240V\2501\250A";
static const char __pyx_k_eigenvector[] = "eigenvector";
static const char __pyx_k_getAdopters[] = "getAdopters";
static const char __pyx_k_getDiagonal[] = "getDiagonal";
static const char __pyx_k_getDistance[] = "getDistance";
static const char __pyx_k_mro_entries[] = "__mro_entries__";
static const char __pyx_k_q_uIQc_A_ha[] = "\320\001\027\220{\240!\330\002\007\200q\210\017\220u\230I\240Q\240c\250\033\260A\340\002\006\200h\210a";
static const char __pyx_k_rankPerNode[] = "rankPerNode";
static const char __pyx_k_startFactor[] = "startFactor";
static const char __pyx_k_unionSample[] = "unionSample";
static const char __pyx_k_useBFSbound[] = "useBFSbound";
static const char __pyx_k_ComplexPaths[] = "ComplexPaths";
static const char __pyx_k_DynAlgorithm[] = "DynAlgorithm";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_SinkHandling[] = "SinkHandling";
static const char __pyx_k_TopCloseness[] = "TopCloseness";
static const char __pyx_k_getNodeOrder[] = "getNodeOrder";
static const char __pyx_k_getPartition[] = "getPartition";
static const char __pyx_k_hb_oXQa_nHAQ[] = "\200\021\360\014\000\003\016\320\r!\240\021\240$\240h\250b\260\001\330\002\006\200o\220X\230Q\230a\330\002\006\200n\220H\230A\230Q";
static const char __pyx_k_includeTrail[] = "includeTrail";
static const char __pyx_k_initializing[] = "_initializing";
static const char __pyx_k_is_coroutine[] = "_is_coroutine";
static const char __pyx_k_member_names[] = "_member_names_";
static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
static const char __pyx_k_scoreOfGroup[] = "scoreOfGroup";
static const char __pyx_k_staticmethod[] = "staticmethod";
static const char __pyx_k_stringsource[] = "<stringsource>";
static const char __pyx_k_use_setstate[] = "use_setstate";
static const char __pyx_k_3aq_Bd_gQ_U_1[] = "\200\021\330\002\013\2103\210a\210q\220\004\220B\220d\230$\230g\240Q\330\002\t\210\024\210U\220!\2201";
static const char __pyx_k_BoundStrategy[] = "BoundStrategy";
static const char __pyx_k_ClosenessType[] = "ClosenessType";
static const char __pyx_k_EdgeDirection[] = "EdgeDirection";
static const char __pyx_k_SciPyPageRank[] = "SciPyPageRank";
static const char __pyx_k_class_getitem[] = "__class_getitem__";
static const char __pyx_k_deterministic[] = "deterministic";
static const char __pyx_k_getPermanence[] = "getPermanence";
static const char __pyx_k_maxCoreNumber[] = "maxCoreNumber";
static const char __pyx_k_maxIterations[] = "maxIterations";
static const char __pyx_k_numberOfSwaps[] = "numberOfSwaps";
static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
static const char __pyx_k_runGrowShrink[] = "runGrowShrink";
static const char __pyx_k_spectralDelta[] = "spectralDelta";
static const char __pyx_k_topkNodesList[] = "topkNodesList";
static const char __pyx_k_DynBetweenness[] = "DynBetweenness";
static const char __pyx_k_GreedyStrategy[] = "GreedyStrategy";
static const char __pyx_k_GroupCloseness[] = "GroupCloseness";
static const char __pyx_k_KatzCentrality[] = "KatzCentrality";
static const char __pyx_k_NoSinkHandling[] = "NoSinkHandling";
static const char __pyx_k_NotImplemented[] = "NotImplemented";
static const char __pyx_k_PageRankMatrix[] = "PageRankMatrix";
static const char __pyx_k_T_Cq_ARt2U_d_Q[] = "\200\021\360\026\000\003\006\200T\210\033\220C\220q\330\003\007\200}\220A\220R\220t\2302\230U\240$\240d\250&\260\001\340\002\t\210\024\210Q";
static const char __pyx_k_centralization[] = "centralization";
static const char __pyx_k_computeFarness[] = "computeFarness";
static const char __pyx_k_groupMaxDegree[] = "groupMaxDegree";
static const char __pyx_k_q_Qk_AQ_q_y_Kq[] = "\320\001\027\220q\330\002\005\200Q\200k\220\021\330\003\t\320\t\034\230A\230Q\330\002\007\200q\210\n\220%\220y\240\001\240\023\240K\250q";
static const char __pyx_k_storeNodeOrder[] = "storeNodeOrder";
static const char __pyx_k_topkScoresList[] = "topkScoresList";
static const char __pyx_k_ApproxCloseness[] = "ApproxCloseness";
static const char __pyx_k_ComplexPathMode[] = "ComplexPathMode";
static const char __pyx_k_DistributeSinks[] = "DistributeSinks";
static const char __pyx_k_KPathCentrality[] = "KPathCentrality";
static const char __pyx_k_SciPyEVZ___init[] = "SciPyEVZ.__init__";
static const char __pyx_k_countGroupNodes[] = "countGroupNodes";
static const char __pyx_k_distributeSinks[] = "distributeSinks";
static const char __pyx_k_getComplexGraph[] = "getComplexGraph";
static const char __pyx_k_groupMaxGedWalk[] = "groupMaxGedWalk";
static const char __pyx_k_ignoreSelfLoops[] = "ignoreSelfLoops";
static const char __pyx_k_numberOfSamples[] = "numberOfSamples";
static const char __pyx_k_prepareSpectrum[] = "prepareSpectrum";
static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
static const char __pyx_k_Centrality_score[] = "Centrality.score";
static const char __pyx_k_ClosenessVariant[] = "_ClosenessVariant";
static const char __pyx_k_DegreeCentrality[] = "DegreeCentrality";
static const char __pyx_k_ForestCentrality[] = "ForestCentrality";
static const char __pyx_k_NO_SINK_HANDLING[] = "NO_SINK_HANDLING";
static const char __pyx_k_SciPyEVZ__length[] = "SciPyEVZ._length";
static const char __pyx_k_T_3a_6_d_4_Fha_Q[] = "\200\021\360\026\000\003\006\200T\210\032\2203\220a\330\003\007\200|\2206\230\021\230$\230d\240&\250\003\2504\320/F\300h\310a\330\002\t\210\024\210Q";
static const char __pyx_k_areDistinguished[] = "areDistinguished";
static const char __pyx_k_runApproximation[] = "runApproximation";
static const char __pyx_k_AdaptiveGeometric[] = "AdaptiveGeometric";
static const char __pyx_k_ApproxBetweenness[] = "ApproxBetweenness";
static const char __pyx_k_Centrality_scores[] = "Centrality.scores";
static const char __pyx_k_CoreDecomposition[] = "CoreDecomposition";
static const char __pyx_k_DynKatzCentrality[] = "DynKatzCentrality";
static const char __pyx_k_HarmonicCloseness[] = "HarmonicCloseness";
static const char __pyx_k_groupMaxCloseness[] = "groupMaxCloseness";
static const char __pyx_k_storePredecessors[] = "storePredecessors";
static const char __pyx_k_universalConstant[] = "universalConstant";
static const char __pyx_k_ADAPTIVE_GEOMETRIC[] = "ADAPTIVE_GEOMETRIC";
static const char __pyx_k_ApproxSpanningEdge[] = "ApproxSpanningEdge";
static const char __pyx_k_Centrality_maximum[] = "Centrality.maximum";
static const char __pyx_k_Centrality_ranking[] = "Centrality.ranking";
static const char __pyx_k_ClosenessVariant_2[] = "ClosenessVariant";
static const char __pyx_k_KadabraBetweenness[] = "KadabraBetweenness";
static const char __pyx_k_SpectralCentrality[] = "SpectralCentrality";
static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
static const char __pyx_k_getIntraClustering[] = "getIntraClustering";
static const char __pyx_k_getNumberOfSamples[] = "getNumberOfSamples";
static const char __pyx_k_numberOfIterations[] = "numberOfIterations";
static const char __pyx_k_relativeRankErrors[] = "relativeRankErrors";
static const char __pyx_k_EstimateBetweenness[] = "EstimateBetweenness";
static const char __pyx_k_LaplacianCentrality[] = "LaplacianCentrality";
static const char __pyx_k_NotImplementedError[] = "NotImplementedError";
static const char __pyx_k_SciPyEVZ_normFactor[] = "SciPyEVZ.normFactor";
static const char __pyx_k_getApproximateScore[] = "getApproximateScore";
static const char __pyx_k_groupMaxBetweenness[] = "groupMaxBetweenness";
static const char __pyx_k_networkit_algebraic[] = "networkit.algebraic";
static const char __pyx_k_q_q_E_iq_nA_m1_l_gQ[] = "\320\001\027\220q\330\002\007\200q\320\010\034\230E\240\031\250!\340\002\006\200i\210q\330\002\006\200n\220A\340\002\006\200m\2201\330\002\006\200l\220!\330\002\006\200g\210Q";
static const char __pyx_k_1D_A_WCxq_oXQb_nHARq[] = "\200\021\360\014\000\003\016\210^\2301\230D\240\010\250\004\250A\330\002\r\320\r\"\240!\240:\250W\260C\260x\270q\340\002\006\200o\220X\230Q\230b\240\001\240\021\330\002\006\200n\220H\230A\230R\230q\240\001";
static const char __pyx_k_ComplexPaths_getPLci[] = "ComplexPaths.getPLci";
static const char __pyx_k_DynApproxBetweenness[] = "DynApproxBetweenness";
static const char __pyx_k_DynBetweenness_score[] = "DynBetweenness.score";
static const char __pyx_k_GedWalk_scoreOfGroup[] = "GedWalk.scoreOfGroup";
static const char __pyx_k_GroupDegree_getScore[] = "GroupDegree.getScore";
static const char __pyx_k_PermanenceCentrality[] = "PermanenceCentrality";
static const char __pyx_k_SciPyPageRank___init[] = "SciPyPageRank.__init__";
static const char __pyx_k_TopHarmonicCloseness[] = "TopHarmonicCloseness";
static const char __pyx_k_adjacencyEigenvector[] = "adjacencyEigenvector";
static const char __pyx_k_computeExactDiagonal[] = "computeExactDiagonal";
static const char __pyx_k_networkit_centrality[] = "networkit.centrality";
static const char __pyx_k_DynBetweennessOneNode[] = "DynBetweennessOneNode";
static const char __pyx_k_DynBetweenness_scores[] = "DynBetweenness.scores";
static const char __pyx_k_DynKatzCentrality_top[] = "DynKatzCentrality.top";
static const char __pyx_k_EigenvectorCentrality[] = "EigenvectorCentrality";
static const char __pyx_k_SciPyPageRank__length[] = "SciPyPageRank._length";
static const char __pyx_k_computeEdgeCentrality[] = "computeEdgeCentrality";
static const char __pyx_k_getNumberOfIterations[] = "getNumberOfIterations";
static const char __pyx_k_symmetricEigenvectors[] = "symmetricEigenvectors";
static const char __pyx_k_ApproxGroupBetweenness[] = "ApproxGroupBetweenness";
static const char __pyx_k_Betweenness_edgeScores[] = "Betweenness.edgeScores";
static const char __pyx_k_ComplexPaths_normalize[] = "ComplexPaths.normalize";
static const char __pyx_k_DynBetweenness_ranking[] = "DynBetweenness.ranking";
static const char __pyx_k_GroupHarmonicCloseness[] = "GroupHarmonicCloseness";
static const char __pyx_k_LocalPartitionCoverage[] = "LocalPartitionCoverage";
static const char __pyx_k_SpanningEdgeCentrality[] = "SpanningEdgeCentrality";
static const char __pyx_k_SpectralCentrality_run[] = "SpectralCentrality.run";
static const char __pyx_k_oQ_Qa_d_FaxvUYYaaeeiij[] = "\320\001)\250\021\360(\000\003\004\330\003\016\210o\230Q\330\t\n\330\003\t\210\034\220Q\220a\330\002\n\210,\220d\230(\240-\320/F\300a\300x\310v\320UY\320Ya\320ae\320ei\320ij";
static const char __pyx_k_DynKatzCentrality_bound[] = "DynKatzCentrality.bound";
static const char __pyx_k_DynTopHarmonicCloseness[] = "DynTopHarmonicCloseness";
static const char __pyx_k_GedWalk___reduce_cython[] = "GedWalk.__reduce_cython__";
static const char __pyx_k_GedWalk_groupMaxGedWalk[] = "GedWalk.groupMaxGedWalk";
static const char __pyx_k_getSquareErrorEstimates[] = "getSquareErrorEstimates";
static const char __pyx_k_ComplexPaths_getAdopters[] = "ComplexPaths.getAdopters";
static const char __pyx_k_GroupClosenessGrowShrink[] = "GroupClosenessGrowShrink";
static const char __pyx_k_GroupClosenessLocalSwaps[] = "GroupClosenessLocalSwaps";
static const char __pyx_k_GroupDegree_scoreOfGroup[] = "GroupDegree.scoreOfGroup";
static const char __pyx_k_PageRank___reduce_cython[] = "PageRank.__reduce_cython__";
static const char __pyx_k_SciPyEVZ_prepareSpectrum[] = "SciPyEVZ.prepareSpectrum";
static const char __pyx_k_SciPyPageRank_normFactor[] = "SciPyPageRank.normFactor";
static const char __pyx_k_networkit_centrality_pyx[] = "networkit/centrality.pyx";
static const char __pyx_k_runParallelApproximation[] = "runParallelApproximation";
static const char __pyx_k_ApproxElectricalCloseness[] = "ApproxElectricalCloseness";
static const char __pyx_k_ApproxSpanningEdge_scores[] = "ApproxSpanningEdge.scores";
static const char __pyx_k_Centrality_centralization[] = "Centrality.centralization";
static const char __pyx_k_Closeness___reduce_cython[] = "Closeness.__reduce_cython__";
static const char __pyx_k_GedWalk___setstate_cython[] = "GedWalk.__setstate_cython__";
static const char __pyx_k_GroupClosenessLocalSearch[] = "GroupClosenessLocalSearch";
static const char __pyx_k_KadabraBetweenness_scores[] = "KadabraBetweenness.scores";
static const char __pyx_k_Sfigality___reduce_cython[] = "Sfigality.__reduce_cython__";
static const char __pyx_k_SpectralCentrality___init[] = "SpectralCentrality.__init__";
static const char __pyx_k_SpectralCentrality_scores[] = "SpectralCentrality.scores";
static const char __pyx_k_groupMaxHarmonicCloseness[] = "groupMaxHarmonicCloseness";
static const char __pyx_k_Centrality___reduce_cython[] = "Centrality.__reduce_cython__";
static const char __pyx_k_CoreDecomposition_getCover[] = "CoreDecomposition.getCover";
static const char __pyx_k_DynApproxBetweenness_score[] = "DynApproxBetweenness.score";
static const char __pyx_k_GroupDegree_groupMaxDegree[] = "GroupDegree.groupMaxDegree";
static const char __pyx_k_KadabraBetweenness_ranking[] = "KadabraBetweenness.ranking";
static const char __pyx_k_LocalClusteringCoefficient[] = "LocalClusteringCoefficient";
static const char __pyx_k_PageRank___setstate_cython[] = "PageRank.__setstate_cython__";
static const char __pyx_k_S_D_S_aq_aq_U_q_gRwar_BgQb[] = "\200\001\360(\000\002\t\210\001\330\001\005\200S\210\001\210\021\330\001\004\200D\210\002\210#\210S\220\001\220\021\330\002\t\210\021\330\001\013\210;\220a\220q\330\001\013\210;\220a\220q\330\001\005\200U\210%\210q\220\001\330\002\006\200g\210R\210w\220a\220r\230\021\230\"\230B\230g\240Q\240b\250\001\250\021\330\001\010\210\001";
static const char __pyx_k_SpectralCentrality_ranking[] = "SpectralCentrality.ranking";
static const char __pyx_k_TopCloseness_topkNodesList[] = "TopCloseness.topkNodesList";
static const char __pyx_k_hk_A_1_kkmmn_1_7_1_2DNRS_1[] = "\200\001\360\006\000\005\010\200\177\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\220?\240(\250!\2501\330\004\007\200|\2207\230!\330\0101\260\021\3202D\300N\320RS\330\004\013\2101";
static const char __pyx_k_Betweenness___reduce_cython[] = "Betweenness.__reduce_cython__";
static const char __pyx_k_Closeness___setstate_cython[] = "Closeness.__setstate_cython__";
static const char __pyx_k_DynApproxBetweenness_scores[] = "DynApproxBetweenness.scores";
static const char __pyx_k_GedWalk_getApproximateScore[] = "GedWalk.getApproximateScore";
static const char __pyx_k_GroupCloseness_scoreOfGroup[] = "GroupCloseness.scoreOfGroup";
static const char __pyx_k_GroupDegree___reduce_cython[] = "GroupDegree.__reduce_cython__";
static const char __pyx_k_KadabraBetweenness_getOmega[] = "KadabraBetweenness.getOmega";
static const char __pyx_k_PageRank_numberOfIterations[] = "PageRank.numberOfIterations";
static const char __pyx_k_Sfigality___setstate_cython[] = "Sfigality.__setstate_cython__";
static const char __pyx_k_TopCloseness_topkScoresList[] = "TopCloseness.topkScoresList";
static const char __pyx_k_a_m1_l_gQ_T_Kq_e4vZq_t1E_Rq[] = "\200\021\360\014\000\003\007\320\006\026\220a\340\002\006\200m\2201\330\002\006\200l\220!\330\002\006\200g\210Q\340\002\005\200T\210\021\330\003\020\220\004\220K\230q\340\003\020\220\001\340\002\006\200e\2104\210v\220Z\230q\330\003\007\200t\2101\210E\220\024\220\\\240\021\240#\240R\240q\330\002\t\210\021";
static const char __pyx_k_enforceBucketQueueAlgorithm[] = "enforceBucketQueueAlgorithm";
static const char __pyx_k_Centrality___setstate_cython[] = "Centrality.__setstate_cython__";
static const char __pyx_k_ComplexPaths___reduce_cython[] = "ComplexPaths.__reduce_cython__";
static const char __pyx_k_ComplexPaths_getComplexGraph[] = "ComplexPaths.getComplexGraph";
static const char __pyx_k_DynApproxBetweenness_ranking[] = "DynApproxBetweenness.ranking";
static const char __pyx_k_DynBetweennessOneNode_getbcx[] = "DynBetweennessOneNode.getbcx";
static const char __pyx_k_ForestCentrality_getDiagonal[] = "ForestCentrality.getDiagonal";
static const char __pyx_k_TopCloseness___reduce_cython[] = "TopCloseness.__reduce_cython__";
static const char __pyx_k_pyx_unpickle_ComplexPathMode[] = "__pyx_unpickle_ComplexPathMode";
static const char __pyx_k_Betweenness___setstate_cython[] = "Betweenness.__setstate_cython__";
static const char __pyx_k_GroupCloseness_computeFarness[] = "GroupCloseness.computeFarness";
static const char __pyx_k_GroupDegree___setstate_cython[] = "GroupDegree.__setstate_cython__";
static const char __pyx_k_SciPyPageRank_prepareSpectrum[] = "SciPyPageRank.prepareSpectrum";
static const char __pyx_k_SpanningEdgeCentrality_scores[] = "SpanningEdgeCentrality.scores";
static const char __pyx_k_SpectralCentrality_normFactor[] = "SpectralCentrality.normFactor";
static const char __pyx_k_3aq_ar_WHIQa_AT_WHIQa_fCq_d_3c[] = "\200\001\360 \000\002\014\2103\210a\210q\330\001\016\210a\210r\220\021\220!\330\001\005\200W\210H\220I\230Q\230a\330\002\014\210A\210T\220\021\220&\230\001\340\001\005\200W\210H\220I\230Q\230a\330\003\006\200f\210C\210q\330\004\005\330\003\006\200d\210!\2103\210c\220\027\230\001\230\025\230a\230r\240\021\240!\330\004\020\220\007\220q\230\005\230Q\230b\240\001\240\021\330\004\016\210a\210t\2201\220F\230*\240A\240Q\330\001\010\210\001";
static const char __pyx_k_ComplexPaths___setstate_cython[] = "ComplexPaths.__setstate_cython__";
static const char __pyx_k_CoreDecomposition_getNodeOrder[] = "CoreDecomposition.getNodeOrder";
static const char __pyx_k_CoreDecomposition_getPartition[] = "CoreDecomposition.getPartition";
static const char __pyx_k_DynBetweennessOneNode_getSigma[] = "DynBetweennessOneNode.getSigma";
static const char __pyx_k_DynBetweenness___reduce_cython[] = "DynBetweenness.__reduce_cython__";
static const char __pyx_k_GroupCloseness___reduce_cython[] = "GroupCloseness.__reduce_cython__";
static const char __pyx_k_KatzCentrality___reduce_cython[] = "KatzCentrality.__reduce_cython__";
static const char __pyx_k_TopCloseness___setstate_cython[] = "TopCloseness.__setstate_cython__";
static const char __pyx_k_restrictTopKComputationToNodes[] = "restrictTopKComputationToNodes";
static const char __pyx_k_A_G1F_a_vWA_q_q_q_0_AWKwa_0_AWK[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\0170\260\004\260A\260W\270K\300w\310a\340\010\017\320\0170\260\004\260A\260W\270K\300q";
static const char __pyx_k_ApproxCloseness___reduce_cython[] = "ApproxCloseness.__reduce_cython__";
static const char __pyx_k_ApproxGroupBetweenness___reduce[] = "ApproxGroupBetweenness.__reduce_cython__";
static const char __pyx_k_ComplexPathMode___reduce_cython[] = "ComplexPathMode.__reduce_cython__";
static const char __pyx_k_CoreDecomposition_maxCoreNumber[] = "CoreDecomposition.maxCoreNumber";
static const char __pyx_k_DynApproxBetweenness___setstate[] = "DynApproxBetweenness.__setstate_cython__";
static const char __pyx_k_DynBetweennessOneNode_getSigmax[] = "DynBetweennessOneNode.getSigmax";
static const char __pyx_k_DynTopHarmonicCloseness_ranking[] = "DynTopHarmonicCloseness.ranking";
static const char __pyx_k_GroupHarmonicCloseness___reduce[] = "GroupHarmonicCloseness.__reduce_cython__";
static const char __pyx_k_KPathCentrality___reduce_cython[] = "KPathCentrality.__reduce_cython__";
static const char __pyx_k_LocalPartitionCoverage___reduce[] = "LocalPartitionCoverage.__reduce_cython__";
static const char __pyx_k_PermanenceCentrality___setstate[] = "PermanenceCentrality.__setstate_cython__";
static const char __pyx_k_SciPyEVZ_G_normalized_False_Com[] = "\n\tSciPyEVZ(G, normalized=False)\n\n\tCompute Eigenvector centrality using algebraic meh\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph of which to compute the centrality.\n\tnormalized : bool, optional\n\t\tWhether to normalize the results or not. Default: False\n\t";
static const char __pyx_k_SciPyPageRank_G_damp_0_95_norma[] = "\n\tSciPyPageRank(G, damp=0.95, normalized=False)\n\n\tCompute Eigenvector centrality using algebraic meh\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph of which to compute the centrality.\n\tdamp : float, optional\n\t\tDamping factor used for computation. Default: 0.95\n\tnormalized : bool, optional\n\t\tWhether to normalize the results or not. Default: False\n\t";
static const char __pyx_k_SpanningEdgeCentrality___reduce[] = "SpanningEdgeCentrality.__reduce_cython__";
static const char __pyx_k_SpectralCentrality_G_normalized[] = "\n\tSpectralCentrality(G, normalized=False)\n\n\tAbstract class to compute the spectral centrality of a graph. This class needs to be supplied with methods\n\tto generate the correct matrices and do the correct normalization.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph of which to compute the centrality.\n\tnormalized : bool, optional\n\t\tWhether to normalize the results or not. Default: False\n\t";
static const char __pyx_k_TopHarmonicCloseness___setstate[] = "TopHarmonicCloseness.__setstate_cython__";
static const char __pyx_k_ApproxBetweenness___reduce_cytho[] = "ApproxBetweenness.__reduce_cython__";
static const char __pyx_k_ApproxBetweenness___setstate_cyt[] = "ApproxBetweenness.__setstate_cython__";
static const char __pyx_k_ApproxBetweenness_numberOfSample[] = "ApproxBetweenness.numberOfSamples";
static const char __pyx_k_ApproxCloseness___setstate_cytho[] = "ApproxCloseness.__setstate_cython__";
static const char __pyx_k_ApproxCloseness_getSquareErrorEs[] = "ApproxCloseness.getSquareErrorEstimates";
static const char __pyx_k_ApproxElectricalCloseness___redu[] = "ApproxElectricalCloseness.__reduce_cython__";
static const char __pyx_k_ApproxElectricalCloseness___sets[] = "ApproxElectricalCloseness.__setstate_cython__";
static const char __pyx_k_ApproxElectricalCloseness_comput[] = "ApproxElectricalCloseness.computeExactDiagonal";
static const char __pyx_k_ApproxElectricalCloseness_getDia[] = "ApproxElectricalCloseness.getDiagonal";
static const char __pyx_k_ApproxGroupBetweenness___setstat[] = "ApproxGroupBetweenness.__setstate_cython__";
static const char __pyx_k_ApproxGroupBetweenness_groupMaxB[] = "ApproxGroupBetweenness.groupMaxBetweenness";
static const char __pyx_k_ApproxGroupBetweenness_scoreOfGr[] = "ApproxGroupBetweenness.scoreOfGroup";
static const char __pyx_k_ApproxSpanningEdge___reduce_cyth[] = "ApproxSpanningEdge.__reduce_cython__";
static const char __pyx_k_ApproxSpanningEdge___setstate_cy[] = "ApproxSpanningEdge.__setstate_cython__";
static const char __pyx_k_ComplexPathMode___setstate_cytho[] = "ComplexPathMode.__setstate_cython__";
static const char __pyx_k_CoreDecomposition___reduce_cytho[] = "CoreDecomposition.__reduce_cython__";
static const char __pyx_k_CoreDecomposition___setstate_cyt[] = "CoreDecomposition.__setstate_cython__";
static const char __pyx_k_DegreeCentrality___reduce_cython[] = "DegreeCentrality.__reduce_cython__";
static const char __pyx_k_DegreeCentrality___setstate_cyth[] = "DegreeCentrality.__setstate_cython__";
static const char __pyx_k_DynApproxBetweenness___reduce_cy[] = "DynApproxBetweenness.__reduce_cython__";
static const char __pyx_k_DynApproxBetweenness_getNumberOf[] = "DynApproxBetweenness.getNumberOfSamples";
static const char __pyx_k_DynBetweennessOneNode___reduce_c[] = "DynBetweennessOneNode.__reduce_cython__";
static const char __pyx_k_DynBetweennessOneNode___setstate[] = "DynBetweennessOneNode.__setstate_cython__";
static const char __pyx_k_DynBetweennessOneNode_getDistanc[] = "DynBetweennessOneNode.getDistance";
static const char __pyx_k_DynBetweenness___setstate_cython[] = "DynBetweenness.__setstate_cython__";
static const char __pyx_k_DynKatzCentrality___reduce_cytho[] = "DynKatzCentrality.__reduce_cython__";
static const char __pyx_k_DynKatzCentrality___setstate_cyt[] = "DynKatzCentrality.__setstate_cython__";
static const char __pyx_k_DynKatzCentrality_areDistinguish[] = "DynKatzCentrality.areDistinguished";
static const char __pyx_k_DynTopHarmonicCloseness___reduce[] = "DynTopHarmonicCloseness.__reduce_cython__";
static const char __pyx_k_DynTopHarmonicCloseness___setsta[] = "DynTopHarmonicCloseness.__setstate_cython__";
static const char __pyx_k_DynTopHarmonicCloseness_topkNode[] = "DynTopHarmonicCloseness.topkNodesList";
static const char __pyx_k_DynTopHarmonicCloseness_topkScor[] = "DynTopHarmonicCloseness.topkScoresList";
static const char __pyx_k_EigenvectorCentrality___reduce_c[] = "EigenvectorCentrality.__reduce_cython__";
static const char __pyx_k_EigenvectorCentrality___setstate[] = "EigenvectorCentrality.__setstate_cython__";
static const char __pyx_k_Error_group_must_be_a_list_of_no[] = "Error, group must be a list of nodes.";
static const char __pyx_k_Error_object_not_properly_initia[] = "Error, object not properly initialized";
static const char __pyx_k_Error_the_third_parameter_must_b[] = "Error: the third parameter must be either a bool or a ClosenessVariant";
static const char __pyx_k_Error_you_may_not_use_Centrality[] = "Error, you may not use Centrality directly, use a sub-class instead";
static const char __pyx_k_EstimateBetweenness___reduce_cyt[] = "EstimateBetweenness.__reduce_cython__";
static const char __pyx_k_EstimateBetweenness___setstate_c[] = "EstimateBetweenness.__setstate_cython__";
static const char __pyx_k_ForestCentrality___reduce_cython[] = "ForestCentrality.__reduce_cython__";
static const char __pyx_k_ForestCentrality___setstate_cyth[] = "ForestCentrality.__setstate_cython__";
static const char __pyx_k_GroupClosenessGrowShrink___reduc[] = "GroupClosenessGrowShrink.__reduce_cython__";
static const char __pyx_k_GroupClosenessGrowShrink___setst[] = "GroupClosenessGrowShrink.__setstate_cython__";
static const char __pyx_k_GroupClosenessGrowShrink_groupMa[] = "GroupClosenessGrowShrink.groupMaxCloseness";
static const char __pyx_k_GroupClosenessGrowShrink_numberO[] = "GroupClosenessGrowShrink.numberOfIterations";
static const char __pyx_k_GroupClosenessLocalSearch___redu[] = "GroupClosenessLocalSearch.__reduce_cython__";
static const char __pyx_k_GroupClosenessLocalSearch___sets[] = "GroupClosenessLocalSearch.__setstate_cython__";
static const char __pyx_k_GroupClosenessLocalSearch_groupM[] = "GroupClosenessLocalSearch.groupMaxCloseness";
static const char __pyx_k_GroupClosenessLocalSearch_number[] = "GroupClosenessLocalSearch.numberOfIterations";
static const char __pyx_k_GroupClosenessLocalSwaps___reduc[] = "GroupClosenessLocalSwaps.__reduce_cython__";
static const char __pyx_k_GroupClosenessLocalSwaps___setst[] = "GroupClosenessLocalSwaps.__setstate_cython__";
static const char __pyx_k_GroupClosenessLocalSwaps_groupMa[] = "GroupClosenessLocalSwaps.groupMaxCloseness";
static const char __pyx_k_GroupClosenessLocalSwaps_numberO[] = "GroupClosenessLocalSwaps.numberOfSwaps";
static const char __pyx_k_GroupCloseness___setstate_cython[] = "GroupCloseness.__setstate_cython__";
static const char __pyx_k_GroupCloseness_groupMaxCloseness[] = "GroupCloseness.groupMaxCloseness";
static const char __pyx_k_GroupHarmonicCloseness___setstat[] = "GroupHarmonicCloseness.__setstate_cython__";
static const char __pyx_k_GroupHarmonicCloseness_groupMaxH[] = "GroupHarmonicCloseness.groupMaxHarmonicCloseness";
static const char __pyx_k_GroupHarmonicCloseness_scoreOfGr[] = "GroupHarmonicCloseness.scoreOfGroup";
static const char __pyx_k_HarmonicCloseness___reduce_cytho[] = "HarmonicCloseness.__reduce_cython__";
static const char __pyx_k_HarmonicCloseness___setstate_cyt[] = "HarmonicCloseness.__setstate_cython__";
static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())";
static const char __pyx_k_KPathCentrality___setstate_cytho[] = "KPathCentrality.__setstate_cython__";
static const char __pyx_k_KadabraBetweenness___reduce_cyth[] = "KadabraBetweenness.__reduce_cython__";
static const char __pyx_k_KadabraBetweenness___setstate_cy[] = "KadabraBetweenness.__setstate_cython__";
static const char __pyx_k_KadabraBetweenness_getNumberOfIt[] = "KadabraBetweenness.getNumberOfIterations";
static const char __pyx_k_KadabraBetweenness_topkNodesList[] = "KadabraBetweenness.topkNodesList";
static const char __pyx_k_KadabraBetweenness_topkScoresLis[] = "KadabraBetweenness.topkScoresList";
static const char __pyx_k_KatzCentrality___setstate_cython[] = "KatzCentrality.__setstate_cython__";
static const char __pyx_k_LaplacianCentrality___reduce_cyt[] = "LaplacianCentrality.__reduce_cython__";
static const char __pyx_k_LaplacianCentrality___setstate_c[] = "LaplacianCentrality.__setstate_cython__";
static const char __pyx_k_LocalClusteringCoefficient___red[] = "LocalClusteringCoefficient.__reduce_cython__";
static const char __pyx_k_LocalClusteringCoefficient___set[] = "LocalClusteringCoefficient.__setstate_cython__";
static const char __pyx_k_LocalPartitionCoverage___setstat[] = "LocalPartitionCoverage.__setstate_cython__";
static const char __pyx_k_LocalSquareClusteringCoefficient[] = "LocalSquareClusteringCoefficient";
static const char __pyx_k_Max_iterations_cannot_be_a_negat[] = "Max iterations cannot be a negative number.";
static const char __pyx_k_Not_implemented_for_directed_gra[] = "Not implemented for directed graphs; use centrality.EigenvectorCentrality instead";
static const char __pyx_k_Note_that_Cython_is_deliberately[] = "Note 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.";
static const char __pyx_k_PermanenceCentrality___reduce_cy[] = "PermanenceCentrality.__reduce_cython__";
static const char __pyx_k_PermanenceCentrality_getIntraClu[] = "PermanenceCentrality.getIntraClustering";
static const char __pyx_k_PermanenceCentrality_getPermanen[] = "PermanenceCentrality.getPermanence";
static const char __pyx_k_SpanningEdgeCentrality___setstat[] = "SpanningEdgeCentrality.__setstate_cython__";
static const char __pyx_k_SpanningEdgeCentrality_runApprox[] = "SpanningEdgeCentrality.runApproximation";
static const char __pyx_k_SpanningEdgeCentrality_runParall[] = "SpanningEdgeCentrality.runParallelApproximation";
static const char __pyx_k_SpectralCentrality_prepareSpectr[] = "SpectralCentrality.prepareSpectrum";
static const char __pyx_k_SpectralCentrality_ranking_local[] = "SpectralCentrality.ranking.<locals>.<lambda>";
static const char __pyx_k_TopCloseness_restrictTopKComputa[] = "TopCloseness.restrictTopKComputationToNodes";
static const char __pyx_k_TopHarmonicCloseness___reduce_cy[] = "TopHarmonicCloseness.__reduce_cython__";
static const char __pyx_k_TopHarmonicCloseness_restrictTop[] = "TopHarmonicCloseness.restrictTopKComputationToNodes";
static const char __pyx_k_TopHarmonicCloseness_topkNodesLi[] = "TopHarmonicCloseness.topkNodesList";
static const char __pyx_k_TopHarmonicCloseness_topkScoresL[] = "TopHarmonicCloseness.topkScoresList";
static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
static const char __pyx_k_self__this_cannot_be_converted_t[] = "self._this cannot be converted to a Python object for pickling";
static const char __pyx_k_LocalSquareClusteringCoefficient_2[] = "LocalSquareClusteringCoefficient.__reduce_cython__";
static const char __pyx_k_LocalSquareClusteringCoefficient_3[] = "LocalSquareClusteringCoefficient.__setstate_cython__";
/* #### Code section: decls ### */
static int __pyx_pf_9networkit_10centrality_10Centrality___init__(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
static void __pyx_pf_9networkit_10centrality_10Centrality_2__dealloc__(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_4scores(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_6score(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_8ranking(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_10maximum(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_12centralization(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_11Betweenness___cinit__(struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized, PyObject *__pyx_v_computeEdgeCentrality); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_2edgeScores(struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_17ApproxBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_delta, PyObject *__pyx_v_universalConstant); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_2numberOfSamples(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_19EstimateBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_nSamples, PyObject *__pyx_v_normalized, PyObject *__pyx_v_parallel); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_19EstimateBetweenness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_19EstimateBetweenness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_18KadabraBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_err, PyObject *__pyx_v_delta, PyObject *__pyx_v_deterministic, PyObject *__pyx_v_k, PyObject *__pyx_v_unionSample, PyObject *__pyx_v_startFactor); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_2ranking(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_4topkNodesList(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_6topkScoresList(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_8scores(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_12getOmega(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_14DynBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_2scores(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_4score(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_6ranking(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_20DynApproxBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_delta, PyObject *__pyx_v_storePredecessors, PyObject *__pyx_v_universalConstant); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_2scores(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_4score(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_6ranking(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode___cinit__(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_node); /* proto */
static void __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_2__dealloc__(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_4getDistance(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_6getSigma(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_10getbcx(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_9Closeness___cinit__(struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized, PyObject *__pyx_v_third); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_9Closeness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_9Closeness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_15ApproxCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_nSamples, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_normalized, enum NetworKit::ApproxCloseness::ClosenessType __pyx_v_type); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates(struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_16DegreeCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_normalized, bool __pyx_v_outDeg, bool __pyx_v_ignoreSelfLoops); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_16DegreeCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_16DegreeCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_17HarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17HarmonicCloseness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17HarmonicCloseness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_12TopCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_first_heu, PyObject *__pyx_v_sec_heu); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_2topkNodesList(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_4topkScoresList(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_nodeList); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_useNBbound); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_nodeList); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_useBFSbound); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_22LocalPartitionCoverage___cinit__(struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_11GroupDegree___cinit__(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_countGroupNodes); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_2groupMaxDegree(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_4getScore(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_6scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_7GedWalk___cinit__(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_alpha, PyObject *__pyx_v_bs, PyObject *__pyx_v_gs, PyObject *__pyx_v_spectralDelta); /* proto */
static void __pyx_pf_9networkit_10centrality_7GedWalk_2__dealloc__(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_4groupMaxGedWalk(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_6getApproximateScore(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_8scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, PyObject *__pyx_v_group, PyObject *__pyx_v_epsilon); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_groupSize, PyObject *__pyx_v_epsilon); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_14GroupCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_H); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_4computeFarness(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, PyObject *__pyx_v_S, PyObject *__pyx_v_H); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_6scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, PyObject *__pyx_v_group); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_extended, PyObject *__pyx_v_insertions); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_maxSwaps); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup(struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_graph, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_inputGroup); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_runGrowShrink, PyObject *__pyx_v_maxIterations); /* proto */
static int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_2__cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_runGrowShrink); /* proto */
static int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_4__cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_15KPathCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_alpha, PyObject *__pyx_v_k); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15KPathCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15KPathCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_14KatzCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, PyObject *__pyx_v_tol); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection___get__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self); /* proto */
static int __pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection_2__set__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, enum NetworKit::EdgeDirection __pyx_v_edgeDirection); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_17DynKatzCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_groupOnly, PyObject *__pyx_v_tolerance); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_2top(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_n); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_4bound(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_6areDistinguished(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient___cinit__(struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_turbo); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient___cinit__(struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_9Sfigality___cinit__(struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_9Sfigality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_9Sfigality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_20PermanenceCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, __pyx_t_9networkit_10structures_node __pyx_v_u); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_4getPermanence(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, __pyx_t_9networkit_10structures_node __pyx_v_u); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_19LaplacianCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_19LaplacianCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_19LaplacianCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_17CoreDecomposition___cinit__(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_normalized, bool __pyx_v_enforceBucketQueueAlgorithm, bool __pyx_v_storeNodeOrder); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_4getCover(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_6getPartition(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_8getNodeOrder(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_21EigenvectorCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_tol); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21EigenvectorCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_21EigenvectorCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_8PageRank___cinit__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_damp, double __pyx_v_tol, bool __pyx_v_normalized, PyObject *__pyx_v_distributeSinks); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_2numberOfIterations(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_4norm___get__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self); /* proto */
static int __pyx_pf_9networkit_10centrality_8PageRank_4norm_2__set__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, enum NetworKit::PageRank::Norm __pyx_v_norm); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_13maxIterations___get__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self); /* proto */
static int __pyx_pf_9networkit_10centrality_8PageRank_13maxIterations_2__set__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, PyObject *__pyx_v_maxIterations); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_tol); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_6scores(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_eps, double __pyx_v_kappa); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, double __pyx_v_tol); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_16ForestCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, __pyx_t_9networkit_10structures_node __pyx_v_root, double __pyx_v_eps, double __pyx_v_kappa); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_2getDiagonal(struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_eps); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_2scores(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_10__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_ranking(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_G, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_2scores(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_G, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_4rankPerNode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ranking); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_6relativeRankErrors(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rx, PyObject *__pyx_v_ry); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_2prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_6run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_8scores(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_10ranking(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_2_length(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, PyObject *__pyx_v_vector); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_6prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_damp, PyObject *__pyx_v_normalized); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_2_length(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, PyObject *__pyx_v_vector); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_6prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15ComplexPathMode___reduce_cython__(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_15ComplexPathMode_2__setstate_cython__(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_9networkit_10centrality_12ComplexPaths___cinit__(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_threshold, PyObject *__pyx_v_mode, PyObject *__pyx_v_start); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_2getPLci(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_4getComplexGraph(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_6getAdopters(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_8normalize(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_9networkit_10centrality_8__pyx_unpickle_ComplexPathMode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_tp_new_9networkit_10centrality_Centrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_Betweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_EstimateBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_KadabraBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DynBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DynApproxBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DynBetweennessOneNode(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_Closeness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DegreeCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_HarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_TopCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_TopHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DynTopHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_LocalPartitionCoverage(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupDegree(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GedWalk(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxGroupBetweenness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessGrowShrink(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSwaps(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSearch(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_KPathCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_KatzCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_DynKatzCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_LocalClusteringCoefficient(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_LocalSquareClusteringCoefficient(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_Sfigality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_PermanenceCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_LaplacianCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_CoreDecomposition(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_EigenvectorCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_PageRank(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_SpanningEdgeCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxElectricalCloseness(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ForestCentrality(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxSpanningEdge(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ComplexPathMode(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality_ComplexPaths(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_9networkit_10centrality___pyx_defaults(PyTypeObject *t, PyObject *a, PyObject *k); /*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;
  #ifdef __Pyx_CyFunction_USED
  PyTypeObject *__pyx_CyFunctionType;
  #endif
  #ifdef __Pyx_FusedFunction_USED
  PyTypeObject *__pyx_FusedFunctionType;
  #endif
  #ifdef __Pyx_Generator_USED
  PyTypeObject *__pyx_GeneratorType;
  #endif
  #ifdef __Pyx_IterableCoroutine_USED
  PyTypeObject *__pyx_IterableCoroutineType;
  #endif
  #ifdef __Pyx_Coroutine_USED
  PyTypeObject *__pyx_CoroutineAwaitType;
  #endif
  #ifdef __Pyx_Coroutine_USED
  PyTypeObject *__pyx_CoroutineType;
  #endif
  PyTypeObject *__pyx_ptype_9networkit_4base__CythonParentClass;
  PyTypeObject *__pyx_ptype_9networkit_4base_Algorithm;
  PyTypeObject *__pyx_ptype_9networkit_10structures_Cover;
  PyTypeObject *__pyx_ptype_9networkit_10structures_Partition;
  PyTypeObject *__pyx_ptype_9networkit_8dynamics_GraphEvent;
  PyTypeObject *__pyx_ptype_9networkit_5graph_Graph;
  PyTypeObject *__pyx_ptype_9networkit_5graph_NodeIntAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_NodeDoubleAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_NodeStringAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_EdgeIntAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_EdgeStringAttribute;
  PyTypeObject *__pyx_ptype_9networkit_5graph_RandomMaximumSpanningForest;
  PyTypeObject *__pyx_ptype_9networkit_5graph_UnionMaximumSpanningForest;
  PyObject *__pyx_type_9networkit_10centrality_Centrality;
  PyObject *__pyx_type_9networkit_10centrality_Betweenness;
  PyObject *__pyx_type_9networkit_10centrality_ApproxBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_EstimateBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_KadabraBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_DynBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_DynApproxBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_DynBetweennessOneNode;
  PyObject *__pyx_type_9networkit_10centrality_Closeness;
  PyObject *__pyx_type_9networkit_10centrality_ApproxCloseness;
  PyObject *__pyx_type_9networkit_10centrality_DegreeCentrality;
  PyObject *__pyx_type_9networkit_10centrality_HarmonicCloseness;
  PyObject *__pyx_type_9networkit_10centrality_TopCloseness;
  PyObject *__pyx_type_9networkit_10centrality_TopHarmonicCloseness;
  PyObject *__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness;
  PyObject *__pyx_type_9networkit_10centrality_LocalPartitionCoverage;
  PyObject *__pyx_type_9networkit_10centrality_GroupDegree;
  PyObject *__pyx_type_9networkit_10centrality_GedWalk;
  PyObject *__pyx_type_9networkit_10centrality_ApproxGroupBetweenness;
  PyObject *__pyx_type_9networkit_10centrality_GroupCloseness;
  PyObject *__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink;
  PyObject *__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps;
  PyObject *__pyx_type_9networkit_10centrality_GroupHarmonicCloseness;
  PyObject *__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch;
  PyObject *__pyx_type_9networkit_10centrality_KPathCentrality;
  PyObject *__pyx_type_9networkit_10centrality_KatzCentrality;
  PyObject *__pyx_type_9networkit_10centrality_DynKatzCentrality;
  PyObject *__pyx_type_9networkit_10centrality_LocalClusteringCoefficient;
  PyObject *__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient;
  PyObject *__pyx_type_9networkit_10centrality_Sfigality;
  PyObject *__pyx_type_9networkit_10centrality_PermanenceCentrality;
  PyObject *__pyx_type_9networkit_10centrality_LaplacianCentrality;
  PyObject *__pyx_type_9networkit_10centrality_CoreDecomposition;
  PyObject *__pyx_type_9networkit_10centrality_EigenvectorCentrality;
  PyObject *__pyx_type_9networkit_10centrality_PageRank;
  PyObject *__pyx_type_9networkit_10centrality_SpanningEdgeCentrality;
  PyObject *__pyx_type_9networkit_10centrality_ApproxElectricalCloseness;
  PyObject *__pyx_type_9networkit_10centrality_ForestCentrality;
  PyObject *__pyx_type_9networkit_10centrality_ApproxSpanningEdge;
  PyObject *__pyx_type_9networkit_10centrality_ComplexPathMode;
  PyObject *__pyx_type_9networkit_10centrality_ComplexPaths;
  PyObject *__pyx_type_9networkit_10centrality___pyx_defaults;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_Centrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_Betweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ApproxBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_EstimateBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_KadabraBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DynBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DynApproxBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_Closeness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ApproxCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DegreeCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_HarmonicCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_TopCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupDegree;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GedWalk;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_KPathCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_KatzCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_DynKatzCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_Sfigality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_PermanenceCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_LaplacianCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_CoreDecomposition;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_EigenvectorCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_PageRank;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ForestCentrality;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ComplexPathMode;
  PyTypeObject *__pyx_ptype_9networkit_10centrality_ComplexPaths;
  PyTypeObject *__pyx_ptype_9networkit_10centrality___pyx_defaults;
  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop;
  enum NetworKit::ApproxCloseness::ClosenessType __pyx_k_;
  PyObject *__pyx_k__2;
  PyObject *__pyx_k__3;
  PyObject *__pyx_k__4;
  PyObject *__pyx_k__5;
  PyObject *__pyx_tuple[21];
  PyObject *__pyx_codeobj_tab[176];
  PyObject *__pyx_string_tab[496];
  PyObject *__pyx_float_0_1;
  PyObject *__pyx_float_0_2;
  PyObject *__pyx_float_0_5;
  PyObject *__pyx_float_1_0;
  PyObject *__pyx_float_0_01;
  PyObject *__pyx_float_0_95;
  PyObject *__pyx_float_1eneg_8;
  PyObject *__pyx_float_1eneg_9;
  PyObject *__pyx_float_neg_1_0;
  PyObject *__pyx_int_0;
  PyObject *__pyx_int_1;
  PyObject *__pyx_int_3;
  PyObject *__pyx_int_100;
  PyObject *__pyx_int_222419149;
  PyObject *__pyx_int_228825662;
  PyObject *__pyx_int_238750788;
/* #### 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

/* 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_n_u_ADAPTIVE_GEOMETRIC __pyx_string_tab[0]
#define __pyx_n_u_ALL_NODES __pyx_string_tab[1]
#define __pyx_n_u_AdaptiveGeometric __pyx_string_tab[2]
#define __pyx_n_u_ApproxBetweenness __pyx_string_tab[3]
#define __pyx_n_u_ApproxBetweenness___reduce_cytho __pyx_string_tab[4]
#define __pyx_n_u_ApproxBetweenness___setstate_cyt __pyx_string_tab[5]
#define __pyx_n_u_ApproxBetweenness_numberOfSample __pyx_string_tab[6]
#define __pyx_n_u_ApproxCloseness __pyx_string_tab[7]
#define __pyx_n_u_ApproxCloseness___reduce_cython __pyx_string_tab[8]
#define __pyx_n_u_ApproxCloseness___setstate_cytho __pyx_string_tab[9]
#define __pyx_n_u_ApproxCloseness_getSquareErrorEs __pyx_string_tab[10]
#define __pyx_n_u_ApproxElectricalCloseness __pyx_string_tab[11]
#define __pyx_n_u_ApproxElectricalCloseness___redu __pyx_string_tab[12]
#define __pyx_n_u_ApproxElectricalCloseness___sets __pyx_string_tab[13]
#define __pyx_n_u_ApproxElectricalCloseness_comput __pyx_string_tab[14]
#define __pyx_n_u_ApproxElectricalCloseness_getDia __pyx_string_tab[15]
#define __pyx_n_u_ApproxGroupBetweenness __pyx_string_tab[16]
#define __pyx_n_u_ApproxGroupBetweenness___reduce __pyx_string_tab[17]
#define __pyx_n_u_ApproxGroupBetweenness___setstat __pyx_string_tab[18]
#define __pyx_n_u_ApproxGroupBetweenness_groupMaxB __pyx_string_tab[19]
#define __pyx_n_u_ApproxGroupBetweenness_scoreOfGr __pyx_string_tab[20]
#define __pyx_n_u_ApproxSpanningEdge __pyx_string_tab[21]
#define __pyx_n_u_ApproxSpanningEdge___reduce_cyth __pyx_string_tab[22]
#define __pyx_n_u_ApproxSpanningEdge___setstate_cy __pyx_string_tab[23]
#define __pyx_n_u_ApproxSpanningEdge_scores __pyx_string_tab[24]
#define __pyx_n_u_Betweenness __pyx_string_tab[25]
#define __pyx_n_u_Betweenness___reduce_cython __pyx_string_tab[26]
#define __pyx_n_u_Betweenness___setstate_cython __pyx_string_tab[27]
#define __pyx_n_u_Betweenness_edgeScores __pyx_string_tab[28]
#define __pyx_n_u_BoundStrategy __pyx_string_tab[29]
#define __pyx_n_u_Centrality __pyx_string_tab[30]
#define __pyx_n_u_Centrality___reduce_cython __pyx_string_tab[31]
#define __pyx_n_u_Centrality___setstate_cython __pyx_string_tab[32]
#define __pyx_n_u_Centrality_centralization __pyx_string_tab[33]
#define __pyx_n_u_Centrality_maximum __pyx_string_tab[34]
#define __pyx_n_u_Centrality_ranking __pyx_string_tab[35]
#define __pyx_n_u_Centrality_score __pyx_string_tab[36]
#define __pyx_n_u_Centrality_scores __pyx_string_tab[37]
#define __pyx_n_u_Closeness __pyx_string_tab[38]
#define __pyx_n_u_ClosenessType __pyx_string_tab[39]
#define __pyx_n_u_ClosenessVariant __pyx_string_tab[40]
#define __pyx_n_u_ClosenessVariant_2 __pyx_string_tab[41]
#define __pyx_n_u_Closeness___reduce_cython __pyx_string_tab[42]
#define __pyx_n_u_Closeness___setstate_cython __pyx_string_tab[43]
#define __pyx_n_u_ComplexPathMode __pyx_string_tab[44]
#define __pyx_n_u_ComplexPathMode___reduce_cython __pyx_string_tab[45]
#define __pyx_n_u_ComplexPathMode___setstate_cytho __pyx_string_tab[46]
#define __pyx_n_u_ComplexPaths __pyx_string_tab[47]
#define __pyx_n_u_ComplexPaths___reduce_cython __pyx_string_tab[48]
#define __pyx_n_u_ComplexPaths___setstate_cython __pyx_string_tab[49]
#define __pyx_n_u_ComplexPaths_getAdopters __pyx_string_tab[50]
#define __pyx_n_u_ComplexPaths_getComplexGraph __pyx_string_tab[51]
#define __pyx_n_u_ComplexPaths_getPLci __pyx_string_tab[52]
#define __pyx_n_u_ComplexPaths_normalize __pyx_string_tab[53]
#define __pyx_n_u_CoreDecomposition __pyx_string_tab[54]
#define __pyx_n_u_CoreDecomposition___reduce_cytho __pyx_string_tab[55]
#define __pyx_n_u_CoreDecomposition___setstate_cyt __pyx_string_tab[56]
#define __pyx_n_u_CoreDecomposition_getCover __pyx_string_tab[57]
#define __pyx_n_u_CoreDecomposition_getNodeOrder __pyx_string_tab[58]
#define __pyx_n_u_CoreDecomposition_getPartition __pyx_string_tab[59]
#define __pyx_n_u_CoreDecomposition_maxCoreNumber __pyx_string_tab[60]
#define __pyx_n_u_DegreeCentrality __pyx_string_tab[61]
#define __pyx_n_u_DegreeCentrality___reduce_cython __pyx_string_tab[62]
#define __pyx_n_u_DegreeCentrality___setstate_cyth __pyx_string_tab[63]
#define __pyx_n_u_DistributeSinks __pyx_string_tab[64]
#define __pyx_n_u_DynAlgorithm __pyx_string_tab[65]
#define __pyx_n_u_DynApproxBetweenness __pyx_string_tab[66]
#define __pyx_n_u_DynApproxBetweenness___reduce_cy __pyx_string_tab[67]
#define __pyx_n_u_DynApproxBetweenness___setstate __pyx_string_tab[68]
#define __pyx_n_u_DynApproxBetweenness_getNumberOf __pyx_string_tab[69]
#define __pyx_n_u_DynApproxBetweenness_ranking __pyx_string_tab[70]
#define __pyx_n_u_DynApproxBetweenness_score __pyx_string_tab[71]
#define __pyx_n_u_DynApproxBetweenness_scores __pyx_string_tab[72]
#define __pyx_n_u_DynBetweenness __pyx_string_tab[73]
#define __pyx_n_u_DynBetweennessOneNode __pyx_string_tab[74]
#define __pyx_n_u_DynBetweennessOneNode___reduce_c __pyx_string_tab[75]
#define __pyx_n_u_DynBetweennessOneNode___setstate __pyx_string_tab[76]
#define __pyx_n_u_DynBetweennessOneNode_getDistanc __pyx_string_tab[77]
#define __pyx_n_u_DynBetweennessOneNode_getSigma __pyx_string_tab[78]
#define __pyx_n_u_DynBetweennessOneNode_getSigmax __pyx_string_tab[79]
#define __pyx_n_u_DynBetweennessOneNode_getbcx __pyx_string_tab[80]
#define __pyx_n_u_DynBetweenness___reduce_cython __pyx_string_tab[81]
#define __pyx_n_u_DynBetweenness___setstate_cython __pyx_string_tab[82]
#define __pyx_n_u_DynBetweenness_ranking __pyx_string_tab[83]
#define __pyx_n_u_DynBetweenness_score __pyx_string_tab[84]
#define __pyx_n_u_DynBetweenness_scores __pyx_string_tab[85]
#define __pyx_n_u_DynKatzCentrality __pyx_string_tab[86]
#define __pyx_n_u_DynKatzCentrality___reduce_cytho __pyx_string_tab[87]
#define __pyx_n_u_DynKatzCentrality___setstate_cyt __pyx_string_tab[88]
#define __pyx_n_u_DynKatzCentrality_areDistinguish __pyx_string_tab[89]
#define __pyx_n_u_DynKatzCentrality_bound __pyx_string_tab[90]
#define __pyx_n_u_DynKatzCentrality_top __pyx_string_tab[91]
#define __pyx_n_u_DynTopHarmonicCloseness __pyx_string_tab[92]
#define __pyx_n_u_DynTopHarmonicCloseness___reduce __pyx_string_tab[93]
#define __pyx_n_u_DynTopHarmonicCloseness___setsta __pyx_string_tab[94]
#define __pyx_n_u_DynTopHarmonicCloseness_ranking __pyx_string_tab[95]
#define __pyx_n_u_DynTopHarmonicCloseness_topkNode __pyx_string_tab[96]
#define __pyx_n_u_DynTopHarmonicCloseness_topkScor __pyx_string_tab[97]
#define __pyx_n_u_EdgeDirection __pyx_string_tab[98]
#define __pyx_n_u_EigenvectorCentrality __pyx_string_tab[99]
#define __pyx_n_u_EigenvectorCentrality___reduce_c __pyx_string_tab[100]
#define __pyx_n_u_EigenvectorCentrality___setstate __pyx_string_tab[101]
#define __pyx_kp_u_Error_group_must_be_a_list_of_no __pyx_string_tab[102]
#define __pyx_kp_u_Error_object_not_properly_initia __pyx_string_tab[103]
#define __pyx_kp_u_Error_the_third_parameter_must_b __pyx_string_tab[104]
#define __pyx_kp_u_Error_you_may_not_use_Centrality __pyx_string_tab[105]
#define __pyx_n_u_EstimateBetweenness __pyx_string_tab[106]
#define __pyx_n_u_EstimateBetweenness___reduce_cyt __pyx_string_tab[107]
#define __pyx_n_u_EstimateBetweenness___setstate_c __pyx_string_tab[108]
#define __pyx_n_u_ForestCentrality __pyx_string_tab[109]
#define __pyx_n_u_ForestCentrality___reduce_cython __pyx_string_tab[110]
#define __pyx_n_u_ForestCentrality___setstate_cyth __pyx_string_tab[111]
#define __pyx_n_u_ForestCentrality_getDiagonal __pyx_string_tab[112]
#define __pyx_n_u_G __pyx_string_tab[113]
#define __pyx_n_u_GENERALIZED __pyx_string_tab[114]
#define __pyx_n_u_GEOMETRIC __pyx_string_tab[115]
#define __pyx_n_u_GedWalk __pyx_string_tab[116]
#define __pyx_n_u_GedWalk___reduce_cython __pyx_string_tab[117]
#define __pyx_n_u_GedWalk___setstate_cython __pyx_string_tab[118]
#define __pyx_n_u_GedWalk_getApproximateScore __pyx_string_tab[119]
#define __pyx_n_u_GedWalk_groupMaxGedWalk __pyx_string_tab[120]
#define __pyx_n_u_GedWalk_scoreOfGroup __pyx_string_tab[121]
#define __pyx_n_u_Generalized __pyx_string_tab[122]
#define __pyx_n_u_Geometric __pyx_string_tab[123]
#define __pyx_n_u_GreedyStrategy __pyx_string_tab[124]
#define __pyx_n_u_GroupCloseness __pyx_string_tab[125]
#define __pyx_n_u_GroupClosenessGrowShrink __pyx_string_tab[126]
#define __pyx_n_u_GroupClosenessGrowShrink___reduc __pyx_string_tab[127]
#define __pyx_n_u_GroupClosenessGrowShrink___setst __pyx_string_tab[128]
#define __pyx_n_u_GroupClosenessGrowShrink_groupMa __pyx_string_tab[129]
#define __pyx_n_u_GroupClosenessGrowShrink_numberO __pyx_string_tab[130]
#define __pyx_n_u_GroupClosenessLocalSearch __pyx_string_tab[131]
#define __pyx_n_u_GroupClosenessLocalSearch___redu __pyx_string_tab[132]
#define __pyx_n_u_GroupClosenessLocalSearch___sets __pyx_string_tab[133]
#define __pyx_n_u_GroupClosenessLocalSearch_groupM __pyx_string_tab[134]
#define __pyx_n_u_GroupClosenessLocalSearch_number __pyx_string_tab[135]
#define __pyx_n_u_GroupClosenessLocalSwaps __pyx_string_tab[136]
#define __pyx_n_u_GroupClosenessLocalSwaps___reduc __pyx_string_tab[137]
#define __pyx_n_u_GroupClosenessLocalSwaps___setst __pyx_string_tab[138]
#define __pyx_n_u_GroupClosenessLocalSwaps_groupMa __pyx_string_tab[139]
#define __pyx_n_u_GroupClosenessLocalSwaps_numberO __pyx_string_tab[140]
#define __pyx_n_u_GroupCloseness___reduce_cython __pyx_string_tab[141]
#define __pyx_n_u_GroupCloseness___setstate_cython __pyx_string_tab[142]
#define __pyx_n_u_GroupCloseness_computeFarness __pyx_string_tab[143]
#define __pyx_n_u_GroupCloseness_groupMaxCloseness __pyx_string_tab[144]
#define __pyx_n_u_GroupCloseness_scoreOfGroup __pyx_string_tab[145]
#define __pyx_n_u_GroupDegree __pyx_string_tab[146]
#define __pyx_n_u_GroupDegree___reduce_cython __pyx_string_tab[147]
#define __pyx_n_u_GroupDegree___setstate_cython __pyx_string_tab[148]
#define __pyx_n_u_GroupDegree_getScore __pyx_string_tab[149]
#define __pyx_n_u_GroupDegree_groupMaxDegree __pyx_string_tab[150]
#define __pyx_n_u_GroupDegree_scoreOfGroup __pyx_string_tab[151]
#define __pyx_n_u_GroupHarmonicCloseness __pyx_string_tab[152]
#define __pyx_n_u_GroupHarmonicCloseness___reduce __pyx_string_tab[153]
#define __pyx_n_u_GroupHarmonicCloseness___setstat __pyx_string_tab[154]
#define __pyx_n_u_GroupHarmonicCloseness_groupMaxH __pyx_string_tab[155]
#define __pyx_n_u_GroupHarmonicCloseness_scoreOfGr __pyx_string_tab[156]
#define __pyx_n_u_H __pyx_string_tab[157]
#define __pyx_n_u_HarmonicCloseness __pyx_string_tab[158]
#define __pyx_n_u_HarmonicCloseness___reduce_cytho __pyx_string_tab[159]
#define __pyx_n_u_HarmonicCloseness___setstate_cyt __pyx_string_tab[160]
#define __pyx_n_u_INBOUND __pyx_string_tab[161]
#define __pyx_n_u_IN_EDGES __pyx_string_tab[162]
#define __pyx_n_u_Inbound __pyx_string_tab[163]
#define __pyx_kp_u_Incompatible_checksums_0x_x_vs_0 __pyx_string_tab[164]
#define __pyx_n_u_IntEnum __pyx_string_tab[165]
#define __pyx_n_u_IntFlag __pyx_string_tab[166]
#define __pyx_n_u_KPathCentrality __pyx_string_tab[167]
#define __pyx_n_u_KPathCentrality___reduce_cython __pyx_string_tab[168]
#define __pyx_n_u_KPathCentrality___setstate_cytho __pyx_string_tab[169]
#define __pyx_n_u_KadabraBetweenness __pyx_string_tab[170]
#define __pyx_n_u_KadabraBetweenness___reduce_cyth __pyx_string_tab[171]
#define __pyx_n_u_KadabraBetweenness___setstate_cy __pyx_string_tab[172]
#define __pyx_n_u_KadabraBetweenness_getNumberOfIt __pyx_string_tab[173]
#define __pyx_n_u_KadabraBetweenness_getOmega __pyx_string_tab[174]
#define __pyx_n_u_KadabraBetweenness_ranking __pyx_string_tab[175]
#define __pyx_n_u_KadabraBetweenness_scores __pyx_string_tab[176]
#define __pyx_n_u_KadabraBetweenness_topkNodesList __pyx_string_tab[177]
#define __pyx_n_u_KadabraBetweenness_topkScoresLis __pyx_string_tab[178]
#define __pyx_n_u_KatzCentrality __pyx_string_tab[179]
#define __pyx_n_u_KatzCentrality___reduce_cython __pyx_string_tab[180]
#define __pyx_n_u_KatzCentrality___setstate_cython __pyx_string_tab[181]
#define __pyx_n_u_L1_NORM __pyx_string_tab[182]
#define __pyx_n_u_L2_NORM __pyx_string_tab[183]
#define __pyx_n_u_LAZY __pyx_string_tab[184]
#define __pyx_n_u_LaplacianCentrality __pyx_string_tab[185]
#define __pyx_n_u_LaplacianCentrality___reduce_cyt __pyx_string_tab[186]
#define __pyx_n_u_LaplacianCentrality___setstate_c __pyx_string_tab[187]
#define __pyx_n_u_Lazy __pyx_string_tab[188]
#define __pyx_n_u_LocalClusteringCoefficient __pyx_string_tab[189]
#define __pyx_n_u_LocalClusteringCoefficient___red __pyx_string_tab[190]
#define __pyx_n_u_LocalClusteringCoefficient___set __pyx_string_tab[191]
#define __pyx_n_u_LocalPartitionCoverage __pyx_string_tab[192]
#define __pyx_n_u_LocalPartitionCoverage___reduce __pyx_string_tab[193]
#define __pyx_n_u_LocalPartitionCoverage___setstat __pyx_string_tab[194]
#define __pyx_n_u_LocalSquareClusteringCoefficient __pyx_string_tab[195]
#define __pyx_n_u_LocalSquareClusteringCoefficient_2 __pyx_string_tab[196]
#define __pyx_n_u_LocalSquareClusteringCoefficient_3 __pyx_string_tab[197]
#define __pyx_kp_u_Max_iterations_cannot_be_a_negat __pyx_string_tab[198]
#define __pyx_n_u_MemoryError __pyx_string_tab[199]
#define __pyx_n_u_NO __pyx_string_tab[200]
#define __pyx_n_u_NO_SINK_HANDLING __pyx_string_tab[201]
#define __pyx_n_u_No __pyx_string_tab[202]
#define __pyx_n_u_NoSinkHandling __pyx_string_tab[203]
#define __pyx_n_u_Norm __pyx_string_tab[204]
#define __pyx_n_u_NotImplemented __pyx_string_tab[205]
#define __pyx_n_u_NotImplementedError __pyx_string_tab[206]
#define __pyx_kp_u_Not_implemented_for_directed_gra __pyx_string_tab[207]
#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[208]
#define __pyx_n_u_OUTBOUND __pyx_string_tab[209]
#define __pyx_n_u_OUT_EDGES __pyx_string_tab[210]
#define __pyx_n_u_Outbound __pyx_string_tab[211]
#define __pyx_n_u_P __pyx_string_tab[212]
#define __pyx_n_u_PageRank __pyx_string_tab[213]
#define __pyx_n_u_PageRankMatrix __pyx_string_tab[214]
#define __pyx_n_u_PageRank___reduce_cython __pyx_string_tab[215]
#define __pyx_n_u_PageRank___setstate_cython __pyx_string_tab[216]
#define __pyx_n_u_PageRank_numberOfIterations __pyx_string_tab[217]
#define __pyx_n_u_PermanenceCentrality __pyx_string_tab[218]
#define __pyx_n_u_PermanenceCentrality___reduce_cy __pyx_string_tab[219]
#define __pyx_n_u_PermanenceCentrality___setstate __pyx_string_tab[220]
#define __pyx_n_u_PermanenceCentrality_getIntraClu __pyx_string_tab[221]
#define __pyx_n_u_PermanenceCentrality_getPermanen __pyx_string_tab[222]
#define __pyx_n_u_PickleError __pyx_string_tab[223]
#define __pyx_n_u_RuntimeError __pyx_string_tab[224]
#define __pyx_n_u_S __pyx_string_tab[225]
#define __pyx_n_u_SINGLE_NODE __pyx_string_tab[226]
#define __pyx_n_u_SPECTRAL __pyx_string_tab[227]
#define __pyx_n_u_STANDARD __pyx_string_tab[228]
#define __pyx_n_u_STOCHASTIC __pyx_string_tab[229]
#define __pyx_n_u_SUM __pyx_string_tab[230]
#define __pyx_n_u_SciPyEVZ __pyx_string_tab[231]
#define __pyx_kp_u_SciPyEVZ_G_normalized_False_Com __pyx_string_tab[232]
#define __pyx_n_u_SciPyEVZ___init __pyx_string_tab[233]
#define __pyx_n_u_SciPyEVZ__length __pyx_string_tab[234]
#define __pyx_n_u_SciPyEVZ_normFactor __pyx_string_tab[235]
#define __pyx_n_u_SciPyEVZ_prepareSpectrum __pyx_string_tab[236]
#define __pyx_n_u_SciPyPageRank __pyx_string_tab[237]
#define __pyx_kp_u_SciPyPageRank_G_damp_0_95_norma __pyx_string_tab[238]
#define __pyx_n_u_SciPyPageRank___init __pyx_string_tab[239]
#define __pyx_n_u_SciPyPageRank__length __pyx_string_tab[240]
#define __pyx_n_u_SciPyPageRank_normFactor __pyx_string_tab[241]
#define __pyx_n_u_SciPyPageRank_prepareSpectrum __pyx_string_tab[242]
#define __pyx_n_u_Sfigality __pyx_string_tab[243]
#define __pyx_n_u_Sfigality___reduce_cython __pyx_string_tab[244]
#define __pyx_n_u_Sfigality___setstate_cython __pyx_string_tab[245]
#define __pyx_n_u_SinkHandling __pyx_string_tab[246]
#define __pyx_n_u_SpanningEdgeCentrality __pyx_string_tab[247]
#define __pyx_n_u_SpanningEdgeCentrality___reduce __pyx_string_tab[248]
#define __pyx_n_u_SpanningEdgeCentrality___setstat __pyx_string_tab[249]
#define __pyx_n_u_SpanningEdgeCentrality_runApprox __pyx_string_tab[250]
#define __pyx_n_u_SpanningEdgeCentrality_runParall __pyx_string_tab[251]
#define __pyx_n_u_SpanningEdgeCentrality_scores __pyx_string_tab[252]
#define __pyx_n_u_Spectral __pyx_string_tab[253]
#define __pyx_n_u_SpectralCentrality __pyx_string_tab[254]
#define __pyx_kp_u_SpectralCentrality_G_normalized __pyx_string_tab[255]
#define __pyx_n_u_SpectralCentrality___init __pyx_string_tab[256]
#define __pyx_n_u_SpectralCentrality_normFactor __pyx_string_tab[257]
#define __pyx_n_u_SpectralCentrality_prepareSpectr __pyx_string_tab[258]
#define __pyx_n_u_SpectralCentrality_ranking __pyx_string_tab[259]
#define __pyx_n_u_SpectralCentrality_ranking_local __pyx_string_tab[260]
#define __pyx_n_u_SpectralCentrality_run __pyx_string_tab[261]
#define __pyx_n_u_SpectralCentrality_scores __pyx_string_tab[262]
#define __pyx_n_u_Standard __pyx_string_tab[263]
#define __pyx_n_u_Stochastic __pyx_string_tab[264]
#define __pyx_n_u_Sum __pyx_string_tab[265]
#define __pyx_n_u_TopCloseness __pyx_string_tab[266]
#define __pyx_n_u_TopCloseness___reduce_cython __pyx_string_tab[267]
#define __pyx_n_u_TopCloseness___setstate_cython __pyx_string_tab[268]
#define __pyx_n_u_TopCloseness_restrictTopKComputa __pyx_string_tab[269]
#define __pyx_n_u_TopCloseness_topkNodesList __pyx_string_tab[270]
#define __pyx_n_u_TopCloseness_topkScoresList __pyx_string_tab[271]
#define __pyx_n_u_TopHarmonicCloseness __pyx_string_tab[272]
#define __pyx_n_u_TopHarmonicCloseness___reduce_cy __pyx_string_tab[273]
#define __pyx_n_u_TopHarmonicCloseness___setstate __pyx_string_tab[274]
#define __pyx_n_u_TopHarmonicCloseness_restrictTop __pyx_string_tab[275]
#define __pyx_n_u_TopHarmonicCloseness_topkNodesLi __pyx_string_tab[276]
#define __pyx_n_u_TopHarmonicCloseness_topkScoresL __pyx_string_tab[277]
#define __pyx_n_u_TypeError __pyx_string_tab[278]
#define __pyx_kp_u__6 __pyx_string_tab[279]
#define __pyx_kp_u__7 __pyx_string_tab[280]
#define __pyx_kp_u_add_note __pyx_string_tab[281]
#define __pyx_n_u_adjacencyEigenvector __pyx_string_tab[282]
#define __pyx_n_u_algorithm __pyx_string_tab[283]
#define __pyx_n_u_allNodes __pyx_string_tab[284]
#define __pyx_n_u_alpha __pyx_string_tab[285]
#define __pyx_n_u_areDistinguished __pyx_string_tab[286]
#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[287]
#define __pyx_n_u_beta __pyx_string_tab[288]
#define __pyx_n_u_bound __pyx_string_tab[289]
#define __pyx_n_u_bs __pyx_string_tab[290]
#define __pyx_n_u_centrality __pyx_string_tab[291]
#define __pyx_n_u_centralization __pyx_string_tab[292]
#define __pyx_n_u_class_getitem __pyx_string_tab[293]
#define __pyx_n_u_cline_in_traceback __pyx_string_tab[294]
#define __pyx_n_u_computeEdgeCentrality __pyx_string_tab[295]
#define __pyx_n_u_computeExactDiagonal __pyx_string_tab[296]
#define __pyx_n_u_computeFarness __pyx_string_tab[297]
#define __pyx_n_u_countGroupNodes __pyx_string_tab[298]
#define __pyx_n_u_cutoff __pyx_string_tab[299]
#define __pyx_n_u_damp __pyx_string_tab[300]
#define __pyx_n_u_delta __pyx_string_tab[301]
#define __pyx_n_u_deterministic __pyx_string_tab[302]
#define __pyx_n_u_dict __pyx_string_tab[303]
#define __pyx_n_u_dict_2 __pyx_string_tab[304]
#define __pyx_n_u_diff __pyx_string_tab[305]
#define __pyx_kp_u_disable __pyx_string_tab[306]
#define __pyx_n_u_distributeSinks __pyx_string_tab[307]
#define __pyx_n_u_doc __pyx_string_tab[308]
#define __pyx_n_u_dynbase __pyx_string_tab[309]
#define __pyx_n_u_edgeScores __pyx_string_tab[310]
#define __pyx_n_u_eigenvalue __pyx_string_tab[311]
#define __pyx_n_u_eigenvector __pyx_string_tab[312]
#define __pyx_kp_u_enable __pyx_string_tab[313]
#define __pyx_n_u_enforceBucketQueueAlgorithm __pyx_string_tab[314]
#define __pyx_n_u_enum __pyx_string_tab[315]
#define __pyx_n_u_enumerate __pyx_string_tab[316]
#define __pyx_n_u_eps __pyx_string_tab[317]
#define __pyx_n_u_epsilon __pyx_string_tab[318]
#define __pyx_n_u_err __pyx_string_tab[319]
#define __pyx_n_u_evz __pyx_string_tab[320]
#define __pyx_n_u_extended __pyx_string_tab[321]
#define __pyx_n_u_first_heu __pyx_string_tab[322]
#define __pyx_n_u_func __pyx_string_tab[323]
#define __pyx_kp_u_gc __pyx_string_tab[324]
#define __pyx_n_u_get __pyx_string_tab[325]
#define __pyx_n_u_getAdopters __pyx_string_tab[326]
#define __pyx_n_u_getApproximateScore __pyx_string_tab[327]
#define __pyx_n_u_getComplexGraph __pyx_string_tab[328]
#define __pyx_n_u_getCover __pyx_string_tab[329]
#define __pyx_n_u_getDiagonal __pyx_string_tab[330]
#define __pyx_n_u_getDistance __pyx_string_tab[331]
#define __pyx_n_u_getIntraClustering __pyx_string_tab[332]
#define __pyx_n_u_getNodeOrder __pyx_string_tab[333]
#define __pyx_n_u_getNumberOfIterations __pyx_string_tab[334]
#define __pyx_n_u_getNumberOfSamples __pyx_string_tab[335]
#define __pyx_n_u_getOmega __pyx_string_tab[336]
#define __pyx_n_u_getPLci __pyx_string_tab[337]
#define __pyx_n_u_getPartition __pyx_string_tab[338]
#define __pyx_n_u_getPermanence __pyx_string_tab[339]
#define __pyx_n_u_getScore __pyx_string_tab[340]
#define __pyx_n_u_getSigma __pyx_string_tab[341]
#define __pyx_n_u_getSigmax __pyx_string_tab[342]
#define __pyx_n_u_getSquareErrorEstimates __pyx_string_tab[343]
#define __pyx_n_u_getbcx __pyx_string_tab[344]
#define __pyx_n_u_getstate __pyx_string_tab[345]
#define __pyx_n_u_graph __pyx_string_tab[346]
#define __pyx_n_u_group __pyx_string_tab[347]
#define __pyx_n_u_groupMaxBetweenness __pyx_string_tab[348]
#define __pyx_n_u_groupMaxCloseness __pyx_string_tab[349]
#define __pyx_n_u_groupMaxDegree __pyx_string_tab[350]
#define __pyx_n_u_groupMaxGedWalk __pyx_string_tab[351]
#define __pyx_n_u_groupMaxHarmonicCloseness __pyx_string_tab[352]
#define __pyx_n_u_groupOnly __pyx_string_tab[353]
#define __pyx_n_u_groupSize __pyx_string_tab[354]
#define __pyx_n_u_groupVec __pyx_string_tab[355]
#define __pyx_n_u_gs __pyx_string_tab[356]
#define __pyx_n_u_i __pyx_string_tab[357]
#define __pyx_n_u_ignoreSelfLoops __pyx_string_tab[358]
#define __pyx_n_u_inEdges __pyx_string_tab[359]
#define __pyx_n_u_includeTrail __pyx_string_tab[360]
#define __pyx_n_u_index __pyx_string_tab[361]
#define __pyx_n_u_init __pyx_string_tab[362]
#define __pyx_n_u_initializing __pyx_string_tab[363]
#define __pyx_n_u_inputGroup __pyx_string_tab[364]
#define __pyx_n_u_insertions __pyx_string_tab[365]
#define __pyx_n_u_isDirected __pyx_string_tab[366]
#define __pyx_n_u_is_coroutine __pyx_string_tab[367]
#define __pyx_kp_u_isenabled __pyx_string_tab[368]
#define __pyx_n_u_items __pyx_string_tab[369]
#define __pyx_n_u_iterNodes __pyx_string_tab[370]
#define __pyx_n_u_k __pyx_string_tab[371]
#define __pyx_n_u_kappa __pyx_string_tab[372]
#define __pyx_n_u_key __pyx_string_tab[373]
#define __pyx_n_u_l1norm __pyx_string_tab[374]
#define __pyx_n_u_l2norm __pyx_string_tab[375]
#define __pyx_n_u_lambda __pyx_string_tab[376]
#define __pyx_n_u_length __pyx_string_tab[377]
#define __pyx_n_u_main __pyx_string_tab[378]
#define __pyx_n_u_math __pyx_string_tab[379]
#define __pyx_n_u_maxCoreNumber __pyx_string_tab[380]
#define __pyx_n_u_maxIterations __pyx_string_tab[381]
#define __pyx_n_u_maxSwaps __pyx_string_tab[382]
#define __pyx_n_u_maximum __pyx_string_tab[383]
#define __pyx_n_u_member_names __pyx_string_tab[384]
#define __pyx_n_u_members __pyx_string_tab[385]
#define __pyx_n_u_metaclass __pyx_string_tab[386]
#define __pyx_n_u_mode __pyx_string_tab[387]
#define __pyx_n_u_module __pyx_string_tab[388]
#define __pyx_n_u_module_2 __pyx_string_tab[389]
#define __pyx_n_u_mro_entries __pyx_string_tab[390]
#define __pyx_n_u_n __pyx_string_tab[391]
#define __pyx_n_u_nSamples __pyx_string_tab[392]
#define __pyx_n_u_n_nodes __pyx_string_tab[393]
#define __pyx_n_u_name __pyx_string_tab[394]
#define __pyx_n_u_networkit_algebraic __pyx_string_tab[395]
#define __pyx_n_u_networkit_centrality __pyx_string_tab[396]
#define __pyx_kp_u_networkit_centrality __pyx_string_tab[397]
#define __pyx_kp_u_networkit_centrality_pyx __pyx_string_tab[398]
#define __pyx_n_u_new __pyx_string_tab[399]
#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[400]
#define __pyx_n_u_node __pyx_string_tab[401]
#define __pyx_n_u_nodeList __pyx_string_tab[402]
#define __pyx_n_u_normFactor __pyx_string_tab[403]
#define __pyx_n_u_normalize __pyx_string_tab[404]
#define __pyx_n_u_normalized __pyx_string_tab[405]
#define __pyx_n_u_numberOfIterations __pyx_string_tab[406]
#define __pyx_n_u_numberOfSamples __pyx_string_tab[407]
#define __pyx_n_u_numberOfSwaps __pyx_string_tab[408]
#define __pyx_n_u_object __pyx_string_tab[409]
#define __pyx_n_u_outDeg __pyx_string_tab[410]
#define __pyx_n_u_outEdges __pyx_string_tab[411]
#define __pyx_n_u_pair __pyx_string_tab[412]
#define __pyx_n_u_parallel __pyx_string_tab[413]
#define __pyx_n_u_pickle __pyx_string_tab[414]
#define __pyx_n_u_pop __pyx_string_tab[415]
#define __pyx_n_u_prMatrix __pyx_string_tab[416]
#define __pyx_n_u_prepare __pyx_string_tab[417]
#define __pyx_n_u_prepareSpectrum __pyx_string_tab[418]
#define __pyx_n_u_prev_node __pyx_string_tab[419]
#define __pyx_n_u_pyx_PickleError __pyx_string_tab[420]
#define __pyx_n_u_pyx_checksum __pyx_string_tab[421]
#define __pyx_n_u_pyx_result __pyx_string_tab[422]
#define __pyx_n_u_pyx_state __pyx_string_tab[423]
#define __pyx_n_u_pyx_type __pyx_string_tab[424]
#define __pyx_n_u_pyx_unpickle_ComplexPathMode __pyx_string_tab[425]
#define __pyx_n_u_pyx_vtable __pyx_string_tab[426]
#define __pyx_n_u_qualname __pyx_string_tab[427]
#define __pyx_n_u_range __pyx_string_tab[428]
#define __pyx_n_u_rankList __pyx_string_tab[429]
#define __pyx_n_u_rankPerNode __pyx_string_tab[430]
#define __pyx_n_u_ranking __pyx_string_tab[431]
#define __pyx_n_u_ranking_id __pyx_string_tab[432]
#define __pyx_n_u_reduce __pyx_string_tab[433]
#define __pyx_n_u_reduce_cython __pyx_string_tab[434]
#define __pyx_n_u_reduce_ex __pyx_string_tab[435]
#define __pyx_n_u_relativeRankErrors __pyx_string_tab[436]
#define __pyx_n_u_restrictTopKComputationToNodes __pyx_string_tab[437]
#define __pyx_n_u_reverse __pyx_string_tab[438]
#define __pyx_n_u_rnode_x __pyx_string_tab[439]
#define __pyx_n_u_rnode_y __pyx_string_tab[440]
#define __pyx_n_u_root __pyx_string_tab[441]
#define __pyx_n_u_run __pyx_string_tab[442]
#define __pyx_n_u_runApproximation __pyx_string_tab[443]
#define __pyx_n_u_runGrowShrink __pyx_string_tab[444]
#define __pyx_n_u_runParallelApproximation __pyx_string_tab[445]
#define __pyx_n_u_rx __pyx_string_tab[446]
#define __pyx_n_u_ry __pyx_string_tab[447]
#define __pyx_n_u_score __pyx_string_tab[448]
#define __pyx_n_u_scoreList __pyx_string_tab[449]
#define __pyx_n_u_scoreOfGroup __pyx_string_tab[450]
#define __pyx_n_u_scores __pyx_string_tab[451]
#define __pyx_n_u_sec_heu __pyx_string_tab[452]
#define __pyx_n_u_self __pyx_string_tab[453]
#define __pyx_kp_u_self__this_cannot_be_converted_t __pyx_string_tab[454]
#define __pyx_n_u_set_name __pyx_string_tab[455]
#define __pyx_n_u_setstate __pyx_string_tab[456]
#define __pyx_n_u_setstate_cython __pyx_string_tab[457]
#define __pyx_n_u_singleNode __pyx_string_tab[458]
#define __pyx_n_u_sorted __pyx_string_tab[459]
#define __pyx_n_u_spec __pyx_string_tab[460]
#define __pyx_n_u_spectralDelta __pyx_string_tab[461]
#define __pyx_n_u_spectrum __pyx_string_tab[462]
#define __pyx_n_u_sqrt __pyx_string_tab[463]
#define __pyx_n_u_square __pyx_string_tab[464]
#define __pyx_n_u_start __pyx_string_tab[465]
#define __pyx_n_u_startFactor __pyx_string_tab[466]
#define __pyx_n_u_state __pyx_string_tab[467]
#define __pyx_n_u_staticmethod __pyx_string_tab[468]
#define __pyx_n_u_storeNodeOrder __pyx_string_tab[469]
#define __pyx_n_u_storePredecessors __pyx_string_tab[470]
#define __pyx_kp_u_stringsource __pyx_string_tab[471]
#define __pyx_n_u_sum __pyx_string_tab[472]
#define __pyx_n_u_super __pyx_string_tab[473]
#define __pyx_n_u_symmetricEigenvectors __pyx_string_tab[474]
#define __pyx_n_u_test __pyx_string_tab[475]
#define __pyx_n_u_third __pyx_string_tab[476]
#define __pyx_n_u_threshold __pyx_string_tab[477]
#define __pyx_n_u_tol __pyx_string_tab[478]
#define __pyx_n_u_tolerance __pyx_string_tab[479]
#define __pyx_n_u_top __pyx_string_tab[480]
#define __pyx_n_u_topkNodesList __pyx_string_tab[481]
#define __pyx_n_u_topkScoresList __pyx_string_tab[482]
#define __pyx_n_u_turbo __pyx_string_tab[483]
#define __pyx_n_u_type __pyx_string_tab[484]
#define __pyx_n_u_u __pyx_string_tab[485]
#define __pyx_n_u_unionSample __pyx_string_tab[486]
#define __pyx_n_u_universalConstant __pyx_string_tab[487]
#define __pyx_n_u_update __pyx_string_tab[488]
#define __pyx_n_u_useBFSbound __pyx_string_tab[489]
#define __pyx_n_u_useNBbound __pyx_string_tab[490]
#define __pyx_n_u_use_setstate __pyx_string_tab[491]
#define __pyx_n_u_v __pyx_string_tab[492]
#define __pyx_n_u_val __pyx_string_tab[493]
#define __pyx_n_u_vector __pyx_string_tab[494]
#define __pyx_n_u_x __pyx_string_tab[495]
/* #### 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);
  #ifdef __Pyx_CyFunction_USED
  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
  #endif
  #ifdef __Pyx_FusedFunction_USED
  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
  #endif
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __Pyx_State_RemoveModule(NULL);
  #endif
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_4base__CythonParentClass);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_4base_Algorithm);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10structures_Cover);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10structures_Partition);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_8dynamics_GraphEvent);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_Graph);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_NodeIntAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_NodeDoubleAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_NodeStringAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_EdgeIntAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_EdgeStringAttribute);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_RandomMaximumSpanningForest);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_5graph_UnionMaximumSpanningForest);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_Centrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_Centrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_Betweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_Betweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ApproxBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ApproxBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_EstimateBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_EstimateBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_KadabraBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_KadabraBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DynBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DynBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DynApproxBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DynBetweennessOneNode);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_Closeness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_Closeness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ApproxCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ApproxCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DegreeCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DegreeCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_HarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_HarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_TopCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_TopCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_TopHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_LocalPartitionCoverage);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupDegree);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupDegree);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GedWalk);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GedWalk);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ApproxGroupBetweenness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupHarmonicCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_KPathCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_KPathCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_KatzCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_KatzCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_DynKatzCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_DynKatzCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_LocalClusteringCoefficient);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_Sfigality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_Sfigality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_PermanenceCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_PermanenceCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_LaplacianCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_LaplacianCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_CoreDecomposition);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_CoreDecomposition);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_EigenvectorCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_PageRank);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_PageRank);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_SpanningEdgeCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ApproxElectricalCloseness);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ForestCentrality);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ForestCentrality);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ApproxSpanningEdge);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ComplexPathMode);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ComplexPathMode);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality_ComplexPaths);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality_ComplexPaths);
  Py_CLEAR(clear_module_state->__pyx_ptype_9networkit_10centrality___pyx_defaults);
  Py_CLEAR(clear_module_state->__pyx_type_9networkit_10centrality___pyx_defaults);
  Py_CLEAR(clear_module_state->__pyx_k__2);
  Py_CLEAR(clear_module_state->__pyx_k__3);
  Py_CLEAR(clear_module_state->__pyx_k__4);
  Py_CLEAR(clear_module_state->__pyx_k__5);
  for (int i=0; i<21; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); }
  for (int i=0; i<176; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); }
  for (int i=0; i<496; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); }
  Py_CLEAR(clear_module_state->__pyx_float_0_1);
  Py_CLEAR(clear_module_state->__pyx_float_0_2);
  Py_CLEAR(clear_module_state->__pyx_float_0_5);
  Py_CLEAR(clear_module_state->__pyx_float_1_0);
  Py_CLEAR(clear_module_state->__pyx_float_0_01);
  Py_CLEAR(clear_module_state->__pyx_float_0_95);
  Py_CLEAR(clear_module_state->__pyx_float_1eneg_8);
  Py_CLEAR(clear_module_state->__pyx_float_1eneg_9);
  Py_CLEAR(clear_module_state->__pyx_float_neg_1_0);
  Py_CLEAR(clear_module_state->__pyx_int_0);
  Py_CLEAR(clear_module_state->__pyx_int_1);
  Py_CLEAR(clear_module_state->__pyx_int_3);
  Py_CLEAR(clear_module_state->__pyx_int_100);
  Py_CLEAR(clear_module_state->__pyx_int_222419149);
  Py_CLEAR(clear_module_state->__pyx_int_228825662);
  Py_CLEAR(clear_module_state->__pyx_int_238750788);
  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);
  #ifdef __Pyx_CyFunction_USED
  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
  #endif
  #ifdef __Pyx_FusedFunction_USED
  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
  #endif
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_4base__CythonParentClass);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_4base_Algorithm);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10structures_Cover);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10structures_Partition);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_8dynamics_GraphEvent);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_Graph);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_NodeIntAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_NodeDoubleAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_NodeStringAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_EdgeIntAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_EdgeStringAttribute);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_RandomMaximumSpanningForest);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_5graph_UnionMaximumSpanningForest);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_Centrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_Centrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_Betweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_Betweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ApproxBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ApproxBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_EstimateBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_EstimateBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_KadabraBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_KadabraBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DynBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DynBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DynApproxBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DynBetweennessOneNode);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_Closeness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_Closeness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ApproxCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ApproxCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DegreeCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DegreeCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_HarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_HarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_TopCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_TopCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_TopHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_LocalPartitionCoverage);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupDegree);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupDegree);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GedWalk);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GedWalk);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ApproxGroupBetweenness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupHarmonicCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_KPathCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_KPathCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_KatzCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_KatzCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_DynKatzCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_DynKatzCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_LocalClusteringCoefficient);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_Sfigality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_Sfigality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_PermanenceCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_PermanenceCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_LaplacianCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_LaplacianCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_CoreDecomposition);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_CoreDecomposition);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_EigenvectorCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_PageRank);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_PageRank);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_SpanningEdgeCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ApproxElectricalCloseness);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ForestCentrality);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ForestCentrality);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ApproxSpanningEdge);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ComplexPathMode);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ComplexPathMode);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality_ComplexPaths);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality_ComplexPaths);
  Py_VISIT(traverse_module_state->__pyx_ptype_9networkit_10centrality___pyx_defaults);
  Py_VISIT(traverse_module_state->__pyx_type_9networkit_10centrality___pyx_defaults);
  Py_VISIT(traverse_module_state->__pyx_k__2);
  Py_VISIT(traverse_module_state->__pyx_k__3);
  Py_VISIT(traverse_module_state->__pyx_k__4);
  Py_VISIT(traverse_module_state->__pyx_k__5);
  for (int i=0; i<21; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); }
  for (int i=0; i<176; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); }
  for (int i=0; i<496; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); }
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_0_1);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_0_2);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_0_5);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_1_0);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_0_01);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_0_95);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_1eneg_8);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_1eneg_9);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_float_neg_1_0);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_100);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_222419149);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_228825662);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_238750788);
  return 0;
}
#endif
/* #### Code section: module_code ### */

/* "EnumTypeToPy":2
 * 
 * @cname("__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py")             # <<<<<<<<<<<<<<
 * cdef __Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(_ClosenessVariant c_val):
 *     cdef object __pyx_enum
*/

static PyObject *__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(enum NetworKit::ClosenessVariant __pyx_v_c_val) {
  PyObject *__pyx_v___pyx_enum = 0;
  int __pyx_v_underlying_c_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py", 0);

  /* "EnumTypeToPy":5
 * cdef __Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(_ClosenessVariant c_val):
 *     cdef object __pyx_enum
 *     __pyx_enum = _ClosenessVariant             # <<<<<<<<<<<<<<
 * 
 *     if 0:
*/
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ClosenessVariant); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v___pyx_enum = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "EnumTypeToPy":9
 *     if 0:
 *         pass
 *     elif c_val == _ClosenessVariant.STANDARD:             # <<<<<<<<<<<<<<
 *         return __pyx_enum.STANDARD
 *     elif c_val == _ClosenessVariant.GENERALIZED:
*/
  __pyx_t_2 = (__pyx_v_c_val == NetworKit::ClosenessVariant::STANDARD);
  if (__pyx_t_2) {

    /* "EnumTypeToPy":10
 *         pass
 *     elif c_val == _ClosenessVariant.STANDARD:
 *         return __pyx_enum.STANDARD             # <<<<<<<<<<<<<<
 *     elif c_val == _ClosenessVariant.GENERALIZED:
 *         return __pyx_enum.GENERALIZED
*/
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_mstate_global->__pyx_n_u_STANDARD); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

    /* "EnumTypeToPy":9
 *     if 0:
 *         pass
 *     elif c_val == _ClosenessVariant.STANDARD:             # <<<<<<<<<<<<<<
 *         return __pyx_enum.STANDARD
 *     elif c_val == _ClosenessVariant.GENERALIZED:
*/
  }

  /* "EnumTypeToPy":11
 *     elif c_val == _ClosenessVariant.STANDARD:
 *         return __pyx_enum.STANDARD
 *     elif c_val == _ClosenessVariant.GENERALIZED:             # <<<<<<<<<<<<<<
 *         return __pyx_enum.GENERALIZED
 *     else:
*/
  __pyx_t_2 = (__pyx_v_c_val == NetworKit::ClosenessVariant::GENERALIZED);
  if (__pyx_t_2) {

    /* "EnumTypeToPy":12
 *         return __pyx_enum.STANDARD
 *     elif c_val == _ClosenessVariant.GENERALIZED:
 *         return __pyx_enum.GENERALIZED             # <<<<<<<<<<<<<<
 *     else:
 *         underlying_c_val = <int>c_val
*/
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_mstate_global->__pyx_n_u_GENERALIZED); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

    /* "EnumTypeToPy":11
 *     elif c_val == _ClosenessVariant.STANDARD:
 *         return __pyx_enum.STANDARD
 *     elif c_val == _ClosenessVariant.GENERALIZED:             # <<<<<<<<<<<<<<
 *         return __pyx_enum.GENERALIZED
 *     else:
*/
  }

  /* "EnumTypeToPy":14
 *         return __pyx_enum.GENERALIZED
 *     else:
 *         underlying_c_val = <int>c_val             # <<<<<<<<<<<<<<
 *         return __pyx_enum(underlying_c_val)
 * 
*/
  /*else*/ {
    __pyx_v_underlying_c_val = ((int)__pyx_v_c_val);

    /* "EnumTypeToPy":15
 *     else:
 *         underlying_c_val = <int>c_val
 *         return __pyx_enum(underlying_c_val)             # <<<<<<<<<<<<<<
 * 
*/
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_v___pyx_enum);
    __pyx_t_4 = __pyx_v___pyx_enum; 
    __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_underlying_c_val); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 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_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

  /* "EnumTypeToPy":2
 * 
 * @cname("__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py")             # <<<<<<<<<<<<<<
 * cdef __Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(_ClosenessVariant c_val):
 *     cdef object __pyx_enum
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("EnumTypeToPy.__Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v___pyx_enum);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_double")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

static PyObject *__pyx_convert_vector_to_py_double(std::vector<double>  const &__pyx_v_v) {
  Py_ssize_t __pyx_v_v_size_signed;
  PyObject *__pyx_v_o = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_item = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0);

  /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_double")
 * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX));
  if (unlikely(__pyx_t_1)) {

    /* "vector.to_py":79
 * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()             # <<<<<<<<<<<<<<
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
*/
    PyErr_NoMemory(); __PYX_ERR(1, 79, __pyx_L1_error)

    /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_double")
 * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  }

  /* "vector.to_py":80
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()             # <<<<<<<<<<<<<<
 * 
 *     o = PyList_New(v_size_signed)
*/
  __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size());

  /* "vector.to_py":82
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
 *     o = PyList_New(v_size_signed)             # <<<<<<<<<<<<<<
 * 
 *     cdef Py_ssize_t i
*/
  __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_o = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "vector.to_py":87
 *     cdef object item
 * 
 *     for i in range(v_size_signed):             # <<<<<<<<<<<<<<
 *         item = v[i]
 *         Py_INCREF(item)
*/
  __pyx_t_3 = __pyx_v_v_size_signed;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "vector.to_py":88
 * 
 *     for i in range(v_size_signed):
 *         item = v[i]             # <<<<<<<<<<<<<<
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)
*/
    __pyx_t_2 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 88, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "vector.to_py":89
 *     for i in range(v_size_signed):
 *         item = v[i]
 *         Py_INCREF(item)             # <<<<<<<<<<<<<<
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
*/
    Py_INCREF(__pyx_v_item);

    /* "vector.to_py":90
 *         item = v[i]
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)             # <<<<<<<<<<<<<<
 * 
 *     return o
*/
    __pyx_t_6 = __Pyx_PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 90, __pyx_L1_error)
  }

  /* "vector.to_py":92
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
 *     return o             # <<<<<<<<<<<<<<
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_o);
  __pyx_r = __pyx_v_o;
  goto __pyx_L0;

  /* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_double")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_o);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "pair.to_py":200
 *         U second
 * 
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double(const pair[X,Y]& p):
 *     return p.first, p.second
*/

static PyObject *__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double(std::pair<__pyx_t_9networkit_10structures_node,double>  const &__pyx_v_p) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double", 0);

  /* "pair.to_py":202
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double")
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double(const pair[X,Y]& p):
 *     return p.first, p.second             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_p.first); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p.second); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 202, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(1, 202, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "pair.to_py":200
 *         U second
 * 
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double(const pair[X,Y]& p):
 *     return p.first, p.second
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("pair.to_py.__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

static PyObject *__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  const &__pyx_v_v) {
  Py_ssize_t __pyx_v_v_size_signed;
  PyObject *__pyx_v_o = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_item = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___", 0);

  /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___")
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX));
  if (unlikely(__pyx_t_1)) {

    /* "vector.to_py":79
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()             # <<<<<<<<<<<<<<
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
*/
    PyErr_NoMemory(); __PYX_ERR(1, 79, __pyx_L1_error)

    /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___")
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  }

  /* "vector.to_py":80
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()             # <<<<<<<<<<<<<<
 * 
 *     o = PyList_New(v_size_signed)
*/
  __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size());

  /* "vector.to_py":82
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
 *     o = PyList_New(v_size_signed)             # <<<<<<<<<<<<<<
 * 
 *     cdef Py_ssize_t i
*/
  __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_o = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "vector.to_py":87
 *     cdef object item
 * 
 *     for i in range(v_size_signed):             # <<<<<<<<<<<<<<
 *         item = v[i]
 *         Py_INCREF(item)
*/
  __pyx_t_3 = __pyx_v_v_size_signed;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "vector.to_py":88
 * 
 *     for i in range(v_size_signed):
 *         item = v[i]             # <<<<<<<<<<<<<<
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)
*/
    __pyx_t_2 = __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node____double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 88, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "vector.to_py":89
 *     for i in range(v_size_signed):
 *         item = v[i]
 *         Py_INCREF(item)             # <<<<<<<<<<<<<<
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
*/
    Py_INCREF(__pyx_v_item);

    /* "vector.to_py":90
 *         item = v[i]
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)             # <<<<<<<<<<<<<<
 * 
 *     return o
*/
    __pyx_t_6 = __Pyx_PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 90, __pyx_L1_error)
  }

  /* "vector.to_py":92
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
 *     return o             # <<<<<<<<<<<<<<
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_o);
  __pyx_r = __pyx_v_o;
  goto __pyx_L0;

  /* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_o);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(std::vector<__pyx_t_9networkit_10structures_node>  const &__pyx_v_v) {
  Py_ssize_t __pyx_v_v_size_signed;
  PyObject *__pyx_v_o = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_item = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node", 0);

  /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node")
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX));
  if (unlikely(__pyx_t_1)) {

    /* "vector.to_py":79
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()             # <<<<<<<<<<<<<<
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
*/
    PyErr_NoMemory(); __PYX_ERR(1, 79, __pyx_L1_error)

    /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node")
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  }

  /* "vector.to_py":80
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()             # <<<<<<<<<<<<<<
 * 
 *     o = PyList_New(v_size_signed)
*/
  __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size());

  /* "vector.to_py":82
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
 *     o = PyList_New(v_size_signed)             # <<<<<<<<<<<<<<
 * 
 *     cdef Py_ssize_t i
*/
  __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_o = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "vector.to_py":87
 *     cdef object item
 * 
 *     for i in range(v_size_signed):             # <<<<<<<<<<<<<<
 *         item = v[i]
 *         Py_INCREF(item)
*/
  __pyx_t_3 = __pyx_v_v_size_signed;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "vector.to_py":88
 * 
 *     for i in range(v_size_signed):
 *         item = v[i]             # <<<<<<<<<<<<<<
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)
*/
    __pyx_t_2 = __Pyx_PyLong_From_uint64_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 88, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "vector.to_py":89
 *     for i in range(v_size_signed):
 *         item = v[i]
 *         Py_INCREF(item)             # <<<<<<<<<<<<<<
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
*/
    Py_INCREF(__pyx_v_item);

    /* "vector.to_py":90
 *         item = v[i]
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)             # <<<<<<<<<<<<<<
 * 
 *     return o
*/
    __pyx_t_6 = __Pyx_PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 90, __pyx_L1_error)
  }

  /* "vector.to_py":92
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
 *     return o             # <<<<<<<<<<<<<<
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_o);
  __pyx_r = __pyx_v_o;
  goto __pyx_L0;

  /* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_o);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(std::vector<__pyx_t_9networkit_10structures_edgeweight>  const &__pyx_v_v) {
  Py_ssize_t __pyx_v_v_size_signed;
  PyObject *__pyx_v_o = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_item = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight", 0);

  /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight")
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX));
  if (unlikely(__pyx_t_1)) {

    /* "vector.to_py":79
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()             # <<<<<<<<<<<<<<
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
*/
    PyErr_NoMemory(); __PYX_ERR(1, 79, __pyx_L1_error)

    /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight")
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  }

  /* "vector.to_py":80
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()             # <<<<<<<<<<<<<<
 * 
 *     o = PyList_New(v_size_signed)
*/
  __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size());

  /* "vector.to_py":82
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
 *     o = PyList_New(v_size_signed)             # <<<<<<<<<<<<<<
 * 
 *     cdef Py_ssize_t i
*/
  __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_o = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "vector.to_py":87
 *     cdef object item
 * 
 *     for i in range(v_size_signed):             # <<<<<<<<<<<<<<
 *         item = v[i]
 *         Py_INCREF(item)
*/
  __pyx_t_3 = __pyx_v_v_size_signed;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "vector.to_py":88
 * 
 *     for i in range(v_size_signed):
 *         item = v[i]             # <<<<<<<<<<<<<<
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)
*/
    __pyx_t_2 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 88, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "vector.to_py":89
 *     for i in range(v_size_signed):
 *         item = v[i]
 *         Py_INCREF(item)             # <<<<<<<<<<<<<<
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
*/
    Py_INCREF(__pyx_v_item);

    /* "vector.to_py":90
 *         item = v[i]
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)             # <<<<<<<<<<<<<<
 * 
 *     return o
*/
    __pyx_t_6 = __Pyx_PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 90, __pyx_L1_error)
  }

  /* "vector.to_py":92
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
 *     return o             # <<<<<<<<<<<<<<
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_o);
  __pyx_r = __pyx_v_o;
  goto __pyx_L0;

  /* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_o);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "pair.to_py":200
 *         U second
 * 
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight(const pair[X,Y]& p):
 *     return p.first, p.second
*/

static PyObject *__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight(std::pair<__pyx_t_9networkit_10structures_node,__pyx_t_9networkit_10structures_edgeweight>  const &__pyx_v_p) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight", 0);

  /* "pair.to_py":202
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight")
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight(const pair[X,Y]& p):
 *     return p.first, p.second             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_uint64_t(__pyx_v_p.first); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p.second); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 202, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(1, 202, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "pair.to_py":200
 *         U second
 * 
 * @cname("__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight(const pair[X,Y]& p):
 *     return p.first, p.second
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("pair.to_py.__pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

static PyObject *__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(std::vector<std::pair<__pyx_t_9networkit_10structures_node,__pyx_t_9networkit_10structures_edgeweight> >  const &__pyx_v_v) {
  Py_ssize_t __pyx_v_v_size_signed;
  PyObject *__pyx_v_o = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_item = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___", 0);

  /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___")
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX));
  if (unlikely(__pyx_t_1)) {

    /* "vector.to_py":79
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()             # <<<<<<<<<<<<<<
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
*/
    PyErr_NoMemory(); __PYX_ERR(1, 79, __pyx_L1_error)

    /* "vector.to_py":78
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___")
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:             # <<<<<<<<<<<<<<
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()
*/
  }

  /* "vector.to_py":80
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
 *         raise MemoryError()
 *     v_size_signed = <Py_ssize_t> v.size()             # <<<<<<<<<<<<<<
 * 
 *     o = PyList_New(v_size_signed)
*/
  __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size());

  /* "vector.to_py":82
 *     v_size_signed = <Py_ssize_t> v.size()
 * 
 *     o = PyList_New(v_size_signed)             # <<<<<<<<<<<<<<
 * 
 *     cdef Py_ssize_t i
*/
  __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_o = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "vector.to_py":87
 *     cdef object item
 * 
 *     for i in range(v_size_signed):             # <<<<<<<<<<<<<<
 *         item = v[i]
 *         Py_INCREF(item)
*/
  __pyx_t_3 = __pyx_v_v_size_signed;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "vector.to_py":88
 * 
 *     for i in range(v_size_signed):
 *         item = v[i]             # <<<<<<<<<<<<<<
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)
*/
    __pyx_t_2 = __pyx_convert_pair_to_py___pyx_t_9networkit_10structures_node______pyx_t_9networkit_10structures_edgeweight((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 88, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "vector.to_py":89
 *     for i in range(v_size_signed):
 *         item = v[i]
 *         Py_INCREF(item)             # <<<<<<<<<<<<<<
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
*/
    Py_INCREF(__pyx_v_item);

    /* "vector.to_py":90
 *         item = v[i]
 *         Py_INCREF(item)
 *         __Pyx_PyList_SET_ITEM(o, i, item)             # <<<<<<<<<<<<<<
 * 
 *     return o
*/
    __pyx_t_6 = __Pyx_PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 90, __pyx_L1_error)
  }

  /* "vector.to_py":92
 *         __Pyx_PyList_SET_ITEM(o, i, item)
 * 
 *     return o             # <<<<<<<<<<<<<<
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_o);
  __pyx_r = __pyx_v_o;
  goto __pyx_L0;

  /* "vector.to_py":76
 *     const Py_ssize_t PY_SSIZE_T_MAX
 * 
 * @cname("__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___")             # <<<<<<<<<<<<<<
 * cdef object __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(const vector[X]& v):
 *     if v.size() > <size_t> PY_SSIZE_T_MAX:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_o);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "vector.from_py":48
 *     cdef Py_ssize_t __Pyx_PyObject_LengthHint(object o, Py_ssize_t defaultval) except -1
 * 
 * @cname("__pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node")             # <<<<<<<<<<<<<<
 * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(object o) except *:
 * 
*/

static std::vector<__pyx_t_9networkit_10structures_node>  __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(PyObject *__pyx_v_o) {
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_v;
  Py_ssize_t __pyx_v_s;
  PyObject *__pyx_v_item = NULL;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *(*__pyx_t_4)(PyObject *);
  PyObject *__pyx_t_5 = NULL;
  __pyx_t_9networkit_10structures_node __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node", 0);

  /* "vector.from_py":52
 * 
 *     cdef vector[X] v
 *     cdef Py_ssize_t s = __Pyx_PyObject_LengthHint(o, 0)             # <<<<<<<<<<<<<<
 * 
 *     if s > 0:
*/
  __pyx_t_1 = __Pyx_PyObject_LengthHint(__pyx_v_o, 0); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 52, __pyx_L1_error)
  __pyx_v_s = __pyx_t_1;

  /* "vector.from_py":54
 *     cdef Py_ssize_t s = __Pyx_PyObject_LengthHint(o, 0)
 * 
 *     if s > 0:             # <<<<<<<<<<<<<<
 *         v.reserve(<size_t> s)
 * 
*/
  __pyx_t_2 = (__pyx_v_s > 0);
  if (__pyx_t_2) {

    /* "vector.from_py":55
 * 
 *     if s > 0:
 *         v.reserve(<size_t> s)             # <<<<<<<<<<<<<<
 * 
 *     for item in o:
*/
    try {
      __pyx_v_v.reserve(((size_t)__pyx_v_s));
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(1, 55, __pyx_L1_error)
    }

    /* "vector.from_py":54
 *     cdef Py_ssize_t s = __Pyx_PyObject_LengthHint(o, 0)
 * 
 *     if s > 0:             # <<<<<<<<<<<<<<
 *         v.reserve(<size_t> s)
 * 
*/
  }

  /* "vector.from_py":57
 *         v.reserve(<size_t> s)
 * 
 *     for item in o:             # <<<<<<<<<<<<<<
 *         v.push_back(<X>item)
 * 
*/
  if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) {
    __pyx_t_3 = __pyx_v_o; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 57, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 57, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_1);
        ++__pyx_t_1;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 57, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1));
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1);
        #endif
        ++__pyx_t_1;
      }
      if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 57, __pyx_L1_error)
    } else {
      __pyx_t_5 = __pyx_t_4(__pyx_t_3);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(1, 57, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_5);
    __pyx_t_5 = 0;

    /* "vector.from_py":58
 * 
 *     for item in o:
 *         v.push_back(<X>item)             # <<<<<<<<<<<<<<
 * 
 *     return v
*/
    __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_item); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 58, __pyx_L1_error)
    try {
      __pyx_v_v.push_back(((__pyx_t_9networkit_10structures_node)__pyx_t_6));
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(1, 58, __pyx_L1_error)
    }

    /* "vector.from_py":57
 *         v.reserve(<size_t> s)
 * 
 *     for item in o:             # <<<<<<<<<<<<<<
 *         v.push_back(<X>item)
 * 
*/
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "vector.from_py":60
 *         v.push_back(<X>item)
 * 
 *     return v             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_r = __pyx_v_v;
  goto __pyx_L0;

  /* "vector.from_py":48
 *     cdef Py_ssize_t __Pyx_PyObject_LengthHint(object o, Py_ssize_t defaultval) except -1
 * 
 * @cname("__pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node")             # <<<<<<<<<<<<<<
 * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(object o) except *:
 * 
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_pretend_to_initialize(&__pyx_r);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":41
 * 	cdef Graph _G
 * 
 * 	def __init__(self, *args, **kwargs):             # <<<<<<<<<<<<<<
 * 		if type(self) == Centrality:
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_10Centrality_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_10Centrality_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return -1;
  if (__pyx_kwds_len > 0) {
    if (unlikely(__Pyx_CheckKeywordStrings("__init__", __pyx_kwds) == -1)) return -1;
  }
  __Pyx_INCREF(__pyx_args);
  __pyx_v_args = __pyx_args;
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality___init__(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);

  /* function exit code */
  __Pyx_DECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kwargs);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_9networkit_10centrality_10Centrality___init__(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__init__", 0);

  /* "networkit/centrality.pyx":42
 * 
 * 	def __init__(self, *args, **kwargs):
 * 		if type(self) == Centrality:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
 * 
*/
  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))), ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_2)) {

    /* "networkit/centrality.pyx":43
 * 	def __init__(self, *args, **kwargs):
 * 		if type(self) == Centrality:
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")             # <<<<<<<<<<<<<<
 * 
 * 	def __dealloc__(self):
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_you_may_not_use_Centrality};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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_1)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 43, __pyx_L1_error)

    /* "networkit/centrality.pyx":42
 * 
 * 	def __init__(self, *args, **kwargs):
 * 		if type(self) == Centrality:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
 * 
*/
  }

  /* "networkit/centrality.pyx":41
 * 	cdef Graph _G
 * 
 * 	def __init__(self, *args, **kwargs):             # <<<<<<<<<<<<<<
 * 		if type(self) == Centrality:
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":45
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
 * 
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		self._G = None # just to be sure the graph is deleted
 * 
*/

/* Python wrapper */
static void __pyx_pw_9networkit_10centrality_10Centrality_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_9networkit_10centrality_10Centrality_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_9networkit_10centrality_10Centrality_2__dealloc__(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_9networkit_10centrality_10Centrality_2__dealloc__(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__", 0);

  /* "networkit/centrality.pyx":46
 * 
 * 	def __dealloc__(self):
 * 		self._G = None # just to be sure the graph is deleted             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None);

  /* "networkit/centrality.pyx":45
 * 			raise RuntimeError("Error, you may not use Centrality directly, use a sub-class instead")
 * 
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		self._G = None # just to be sure the graph is deleted
 * 
*/

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "networkit/centrality.pyx":48
 * 		self._G = None # just to be sure the graph is deleted
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_5scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_10Centrality_4scores, "\n\t\tscores()\n\n\t\tReturns the scores of all nodes for the centrality algorithm.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe list of all scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_5scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_5scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_4scores};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_5scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_4scores(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_4scores(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  std::vector<double>  __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":59
 * 			The list of all scores.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).scores()
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":60
 * 		"""
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")             # <<<<<<<<<<<<<<
 * 		return (<_Centrality*>(self._this)).scores()
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_object_not_properly_initia};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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, 60, __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, 60, __pyx_L1_error)

    /* "networkit/centrality.pyx":59
 * 			The list of all scores.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).scores()
*/
  }

  /* "networkit/centrality.pyx":61
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).scores()             # <<<<<<<<<<<<<<
 * 
 * 	def score(self, v):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_6 = ((NetworKit::Centrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 61, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":48
 * 		self._G = None # just to be sure the graph is deleted
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":63
 * 		return (<_Centrality*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_7score(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_10Centrality_6score, "\n\t\tscore(v)\n\t\t\n\t\tReturns the score of node v for the centrality algorithm.\n\n\t\tParameters\n\t\t----------\n\t\tv : int\n\t\t\tNode index.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe score of node v.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_7score = {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_7score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_6score};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_7score(PyObject *__pyx_v_self, 
#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_v = 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("score (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_v,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, 63, __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, 63, __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, "score", 0) < 0) __PYX_ERR(0, 63, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, i); __PYX_ERR(0, 63, __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, 63, __pyx_L3_error)
    }
    __pyx_v_v = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 63, __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("networkit.centrality.Centrality.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_6score(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_6score(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  __pyx_t_9networkit_10structures_node __pyx_t_6;
  double __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("score", 0);

  /* "networkit/centrality.pyx":79
 * 			The score of node v.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).score(v)
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":80
 * 		"""
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")             # <<<<<<<<<<<<<<
 * 		return (<_Centrality*>(self._this)).score(v)
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_object_not_properly_initia};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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, 80, __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, 80, __pyx_L1_error)

    /* "networkit/centrality.pyx":79
 * 			The score of node v.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).score(v)
*/
  }

  /* "networkit/centrality.pyx":81
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).score(v)             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L1_error)
  try {
    __pyx_t_7 = ((NetworKit::Centrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->score(__pyx_t_6);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 81, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":63
 * 		return (<_Centrality*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":83
 * 		return (<_Centrality*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_9ranking(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_10Centrality_8ranking, "\n\t\tranking()\n\n\t\tReturns the ranking of nodes according to their score.\n\n\t\tReturns\n\t\t-------\n\t\tlist(tuple(int, float))\n\t\t\tA list of pairs sorted into descending order. Each pair contains a node and the corresponding score\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_9ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_9ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_8ranking};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_9ranking(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ranking (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("ranking", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("ranking", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_8ranking(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_8ranking(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":94
 * 			A list of pairs sorted into descending order. Each pair contains a node and the corresponding score
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).ranking()
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":95
 * 		"""
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")             # <<<<<<<<<<<<<<
 * 		return (<_Centrality*>(self._this)).ranking()
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_object_not_properly_initia};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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, 95, __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, 95, __pyx_L1_error)

    /* "networkit/centrality.pyx":94
 * 			A list of pairs sorted into descending order. Each pair contains a node and the corresponding score
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).ranking()
*/
  }

  /* "networkit/centrality.pyx":96
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).ranking()             # <<<<<<<<<<<<<<
 * 
 * 	def maximum(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_6 = ((NetworKit::Centrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->ranking();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 96, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":83
 * 		return (<_Centrality*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":98
 * 		return (<_Centrality*>(self._this)).ranking()
 * 
 * 	def maximum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maximum()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_11maximum(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_10Centrality_10maximum, "\n\t\tmaximum()\n\n\t\tReturn the maximum theoretical centrality score.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe maximum theoretical centrality score for the given graph.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_11maximum = {"maximum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_11maximum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_10maximum};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_11maximum(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("maximum (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("maximum", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("maximum", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_10maximum(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_10maximum(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  double __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("maximum", 0);

  /* "networkit/centrality.pyx":109
 * 			The maximum theoretical centrality score for the given graph.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).maximum()
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":110
 * 		"""
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")             # <<<<<<<<<<<<<<
 * 		return (<_Centrality*>(self._this)).maximum()
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_object_not_properly_initia};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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, 110, __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, 110, __pyx_L1_error)

    /* "networkit/centrality.pyx":109
 * 			The maximum theoretical centrality score for the given graph.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).maximum()
*/
  }

  /* "networkit/centrality.pyx":111
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).maximum()             # <<<<<<<<<<<<<<
 * 
 * 	def centralization(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_6 = ((NetworKit::Centrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->maximum();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 111, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":98
 * 		return (<_Centrality*>(self._this)).ranking()
 * 
 * 	def maximum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maximum()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.maximum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":113
 * 		return (<_Centrality*>(self._this)).maximum()
 * 
 * 	def centralization(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		centralization()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_13centralization(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_10Centrality_12centralization, "\n\t\tcentralization()\n\n\t\tCompute the centralization of a network with respect to some centrality measure.\n\t\tThe centralization of any network is a measure of how central its most central\n\t\tnode is in relation to how central all the other nodes are.\n\t\tCentralization measures then (a) calculate the sum in differences\n\t\tin centrality between the most central node in a network and all other nodes;\n\t\tand (b) divide this quantity by the theoretically largest such sum of\n\t\tdifferences in any network of the same size.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tCentralization value.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_13centralization = {"centralization", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_13centralization, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_12centralization};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_13centralization(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("centralization (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("centralization", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("centralization", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_12centralization(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_12centralization(struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  double __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("centralization", 0);

  /* "networkit/centrality.pyx":130
 * 			Centralization value.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).centralization()
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":131
 * 		"""
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")             # <<<<<<<<<<<<<<
 * 		return (<_Centrality*>(self._this)).centralization()
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_RuntimeError);
    __pyx_t_4 = __pyx_builtin_RuntimeError; 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_object_not_properly_initia};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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, 131, __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, 131, __pyx_L1_error)

    /* "networkit/centrality.pyx":130
 * 			Centralization value.
 * 		"""
 * 		if self._this == NULL:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).centralization()
*/
  }

  /* "networkit/centrality.pyx":132
 * 		if self._this == NULL:
 * 			raise RuntimeError("Error, object not properly initialized")
 * 		return (<_Centrality*>(self._this)).centralization()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/Betweenness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_6 = ((NetworKit::Centrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->centralization();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 132, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":113
 * 		return (<_Centrality*>(self._this)).maximum()
 * 
 * 	def centralization(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		centralization()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.Centrality.centralization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_15__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_15__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_14__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_self__this_cannot_be_converted_t, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Centrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_17__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_10Centrality_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_10Centrality_17__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.Centrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_10Centrality_16__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_Centrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_10Centrality_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Centrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_self__this_cannot_be_converted_t, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Centrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":158
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized=False, computeEdgeCentrality=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _Betweenness(G._this, normalized, computeEdgeCentrality)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_11Betweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_11Betweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  PyObject *__pyx_v_computeEdgeCentrality = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_computeEdgeCentrality,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 158, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 158, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 158, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 158, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 158, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 158, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 158, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 158, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 158, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_normalized = values[1];
    __pyx_v_computeEdgeCentrality = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 158, __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("networkit.centrality.Betweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 158, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_11Betweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_Betweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized, __pyx_v_computeEdgeCentrality);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_11Betweenness___cinit__(struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized, PyObject *__pyx_v_computeEdgeCentrality) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  bool __pyx_t_2;
  NetworKit::Betweenness *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":159
 * 
 * 	def __cinit__(self, Graph G, normalized=False, computeEdgeCentrality=False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _Betweenness(G._this, normalized, computeEdgeCentrality)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":160
 * 	def __cinit__(self, Graph G, normalized=False, computeEdgeCentrality=False):
 * 		self._G = G
 * 		self._this = new _Betweenness(G._this, normalized, computeEdgeCentrality)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalized); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_computeEdgeCentrality); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::Betweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 160, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":158
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized=False, computeEdgeCentrality=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _Betweenness(G._this, normalized, computeEdgeCentrality)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Betweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":163
 * 
 * 
 * 	def edgeScores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		edgeScores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_3edgeScores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_11Betweenness_2edgeScores, "\n\t\tedgeScores()\n\t\t\n\t\tGet a vector containing the betweenness score for each edge in the graph\n\t\tin ascending edge ID order.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe betweenness scores calculated by run().\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_11Betweenness_3edgeScores = {"edgeScores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_3edgeScores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11Betweenness_2edgeScores};
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_3edgeScores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("edgeScores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("edgeScores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("edgeScores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_11Betweenness_2edgeScores(((struct __pyx_obj_9networkit_10centrality_Betweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_2edgeScores(struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("edgeScores", 0);

  /* "networkit/centrality.pyx":175
 * 			The betweenness scores calculated by run().
 * 		"""
 * 		return (<_Betweenness*>(self._this)).edgeScores()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ApproxBetweenness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::Betweenness *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->edgeScores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 175, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":163
 * 
 * 
 * 	def edgeScores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		edgeScores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.Betweenness.edgeScores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_11Betweenness_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_11Betweenness_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_Betweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Betweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_11Betweenness_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_11Betweenness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.Betweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_11Betweenness_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_Betweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11Betweenness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Betweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Betweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":211
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, universalConstant=1.0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_17ApproxBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_17ApproxBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_epsilon = 0;
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_universalConstant = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_epsilon,&__pyx_mstate_global->__pyx_n_u_delta,&__pyx_mstate_global->__pyx_n_u_universalConstant,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 211, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 211, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 211, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1_0));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 211, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 211, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_epsilon = values[1];
    __pyx_v_delta = values[2];
    __pyx_v_universalConstant = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 211, __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("networkit.centrality.ApproxBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 211, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_17ApproxBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_epsilon, __pyx_v_delta, __pyx_v_universalConstant);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_17ApproxBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_delta, PyObject *__pyx_v_universalConstant) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  double __pyx_t_2;
  double __pyx_t_3;
  NetworKit::ApproxBetweenness *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":212
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, universalConstant=1.0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":213
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, universalConstant=1.0):
 * 		self._G = G
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)             # <<<<<<<<<<<<<<
 * 
 * 	def numberOfSamples(self):
*/
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_epsilon); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 213, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_delta); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 213, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_v_universalConstant); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 213, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::ApproxBetweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 213, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":211
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, universalConstant=1.0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":215
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
 * 
 * 	def numberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		return (<_ApproxBetweenness*>(self._this)).numberOfSamples()
 * 
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples(PyObject *__pyx_v_self, 
#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 PyMethodDef __pyx_mdef_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples = {"numberOfSamples", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("numberOfSamples (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("numberOfSamples", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("numberOfSamples", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17ApproxBetweenness_2numberOfSamples(((struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_2numberOfSamples(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("numberOfSamples", 0);

  /* "networkit/centrality.pyx":216
 * 
 * 	def numberOfSamples(self):
 * 		return (<_ApproxBetweenness*>(self._this)).numberOfSamples()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxBetweenness *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->numberOfSamples();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 216, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":215
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
 * 
 * 	def numberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		return (<_ApproxBetweenness*>(self._this)).numberOfSamples()
 * 
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxBetweenness.numberOfSamples", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17ApproxBetweenness_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ApproxBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17ApproxBetweenness_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17ApproxBetweenness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":249
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, nSamples, normalized=False, parallel=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _EstimateBetweenness(G._this, nSamples, normalized, parallel)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_19EstimateBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_19EstimateBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_nSamples = 0;
  PyObject *__pyx_v_normalized = 0;
  PyObject *__pyx_v_parallel = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_nSamples,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_parallel,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 249, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 249, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 249, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 249, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 249, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 249, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, i); __PYX_ERR(0, 249, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 249, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 249, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 249, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 249, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_nSamples = values[1];
    __pyx_v_normalized = values[2];
    __pyx_v_parallel = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 249, __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("networkit.centrality.EstimateBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 249, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_19EstimateBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_nSamples, __pyx_v_normalized, __pyx_v_parallel);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_19EstimateBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_nSamples, PyObject *__pyx_v_normalized, PyObject *__pyx_v_parallel) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  bool __pyx_t_3;
  NetworKit::EstimateBetweenness *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":250
 * 
 * 	def __cinit__(self, Graph G, nSamples, normalized=False, parallel=False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _EstimateBetweenness(G._this, nSamples, normalized, parallel)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":251
 * 	def __cinit__(self, Graph G, nSamples, normalized=False, parallel=False):
 * 		self._G = G
 * 		self._this = new _EstimateBetweenness(G._this, nSamples, normalized, parallel)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/KadabraBetweenness.hpp>":
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_nSamples); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 251, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_normalized); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 251, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_parallel); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 251, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::EstimateBetweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 251, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":249
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, nSamples, normalized=False, parallel=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _EstimateBetweenness(G._this, nSamples, normalized, parallel)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EstimateBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_19EstimateBetweenness_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_19EstimateBetweenness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EstimateBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.EstimateBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_19EstimateBetweenness_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_19EstimateBetweenness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EstimateBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EstimateBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":318
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0,             # <<<<<<<<<<<<<<
 * 				  unionSample = 0, startFactor = 100):
 * 		self._this = new _KadabraBetweenness(G._this, err, delta, deterministic, k, unionSample,
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_18KadabraBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_18KadabraBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_err = 0;
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_deterministic = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_unionSample = 0;
  PyObject *__pyx_v_startFactor = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[7] = {0,0,0,0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_err,&__pyx_mstate_global->__pyx_n_u_delta,&__pyx_mstate_global->__pyx_n_u_deterministic,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_unionSample,&__pyx_mstate_global->__pyx_n_u_startFactor,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 318, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 318, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 318, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_100));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 7, i); __PYX_ERR(0, 318, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 318, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 318, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_100));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_err = values[1];
    __pyx_v_delta = values[2];
    __pyx_v_deterministic = values[3];
    __pyx_v_k = values[4];
    __pyx_v_unionSample = values[5];
    __pyx_v_startFactor = values[6];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 318, __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("networkit.centrality.KadabraBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 318, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_err, __pyx_v_delta, __pyx_v_deterministic, __pyx_v_k, __pyx_v_unionSample, __pyx_v_startFactor);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_18KadabraBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_err, PyObject *__pyx_v_delta, PyObject *__pyx_v_deterministic, PyObject *__pyx_v_k, PyObject *__pyx_v_unionSample, PyObject *__pyx_v_startFactor) {
  int __pyx_r;
  double __pyx_t_1;
  double __pyx_t_2;
  bool __pyx_t_3;
  __pyx_t_9networkit_10structures_count __pyx_t_4;
  __pyx_t_9networkit_10structures_count __pyx_t_5;
  __pyx_t_9networkit_10structures_count __pyx_t_6;
  NetworKit::KadabraBetweenness *__pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* "networkit/centrality.pyx":320
 * 	def __cinit__(self, Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0,
 * 				  unionSample = 0, startFactor = 100):
 * 		self._this = new _KadabraBetweenness(G._this, err, delta, deterministic, k, unionSample,             # <<<<<<<<<<<<<<
 * 										   startFactor)
 * 
*/
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_err); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_delta); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_deterministic); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_4 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_v_unionSample); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error)

  /* "networkit/centrality.pyx":321
 * 				  unionSample = 0, startFactor = 100):
 * 		self._this = new _KadabraBetweenness(G._this, err, delta, deterministic, k, unionSample,
 * 										   startFactor)             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self):
*/
  __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_startFactor); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error)

  /* "networkit/centrality.pyx":320
 * 	def __cinit__(self, Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0,
 * 				  unionSample = 0, startFactor = 100):
 * 		self._this = new _KadabraBetweenness(G._this, err, delta, deterministic, k, unionSample,             # <<<<<<<<<<<<<<
 * 										   startFactor)
 * 
*/
  try {
    __pyx_t_7 = new NetworKit::KadabraBetweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 320, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_7;

  /* "networkit/centrality.pyx":318
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0,             # <<<<<<<<<<<<<<
 * 				  unionSample = 0, startFactor = 100):
 * 		self._this = new _KadabraBetweenness(G._this, err, delta, deterministic, k, unionSample,
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* "networkit/centrality.pyx":323
 * 										   startFactor)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_3ranking(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_2ranking, "\n\t\tranking()\n\n\t\tReturns the ranking of the nodes according to their approximated\n\t\tbetweenness centrality.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int, float)\n\t\t\tA list of pairs (node, betweenness) representing the top-k ranking.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_3ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_3ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_2ranking};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_3ranking(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ranking (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("ranking", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("ranking", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_2ranking(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_2ranking(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":335
 * 			A list of pairs (node, betweenness) representing the top-k ranking.
 * 		"""
 * 		return (<_KadabraBetweenness*>(self._this)).ranking()             # <<<<<<<<<<<<<<
 * 
 * 	def topkNodesList(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->ranking();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 335, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 335, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":323
 * 										   startFactor)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":337
 * 		return (<_KadabraBetweenness*>(self._this)).ranking()
 * 
 * 	def topkNodesList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_5topkNodesList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_4topkNodesList, "\n\t\ttopkNodesList()\n\n\t\tReturns Nodes of the graph sorted by their approximated betweenness\n\t\tcentrality.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tA list with the top-k nodes with highest approximated betweenness\n\t\t\tcentrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_5topkNodesList = {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_5topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_4topkNodesList};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_5topkNodesList(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("topkNodesList (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("topkNodesList", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("topkNodesList", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_4topkNodesList(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_4topkNodesList(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkNodesList", 0);

  /* "networkit/centrality.pyx":350
 * 			centrality.
 * 		"""
 * 		return (<_KadabraBetweenness*>(self._this)).topkNodesList()             # <<<<<<<<<<<<<<
 * 
 * 	def topkScoresList(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkNodesList();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 350, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":337
 * 		return (<_KadabraBetweenness*>(self._this)).ranking()
 * 
 * 	def topkNodesList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":352
 * 		return (<_KadabraBetweenness*>(self._this)).topkNodesList()
 * 
 * 	def topkScoresList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_7topkScoresList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_6topkScoresList, "\n\t\ttopkScoresList()\n\n\t\tReturns the sorted list of approximated betweenness centrality scores.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tA list with the top-k scores of the nodes with highest approximated\n\t\t\tbetweenness centrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_7topkScoresList = {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_7topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_6topkScoresList};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_7topkScoresList(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("topkScoresList (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("topkScoresList", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("topkScoresList", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_6topkScoresList(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_6topkScoresList(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkScoresList", 0);

  /* "networkit/centrality.pyx":364
 * 			betweenness centrality.
 * 		"""
 * 		return (<_KadabraBetweenness*>(self._this)).topkScoresList()             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkScoresList();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 364, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":352
 * 		return (<_KadabraBetweenness*>(self._this)).topkNodesList()
 * 
 * 	def topkScoresList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":366
 * 		return (<_KadabraBetweenness*>(self._this)).topkScoresList()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_9scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_8scores, "\n\t\tscores()\n\n\t\tReturns the approximated betweenness centrality score of all the nodes of\n\t\tthe graph.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tA list with the approximated betweenness centrality score of each node of\n\t\t\tthe graph.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_9scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_9scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_8scores};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_9scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_8scores(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_8scores(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":379
 * 			the graph.
 * 		"""
 * 		return (<_KadabraBetweenness*>(self._this)).scores()             # <<<<<<<<<<<<<<
 * 
 * 	def getNumberOfIterations(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 379, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":366
 * 		return (<_KadabraBetweenness*>(self._this)).topkScoresList()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":381
 * 		return (<_KadabraBetweenness*>(self._this)).scores()
 * 
 * 	def getNumberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfIterations()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations, "\n\t\tgetNumberOfIterations()\n\n\t\tReturns the total number of samples.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe total number of shortest paths sampled by the algorithm.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations = {"getNumberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNumberOfIterations (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getNumberOfIterations", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getNumberOfIterations", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNumberOfIterations", 0);

  /* "networkit/centrality.pyx":392
 * 			The total number of shortest paths sampled by the algorithm.
 * 		"""
 * 		return (<_KadabraBetweenness*>(self._this)).getNumberOfIterations()             # <<<<<<<<<<<<<<
 * 
 * 	def getOmega(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->getNumberOfIterations();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 392, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 392, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":381
 * 		return (<_KadabraBetweenness*>(self._this)).scores()
 * 
 * 	def getNumberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfIterations()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.getNumberOfIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":394
 * 		return (<_KadabraBetweenness*>(self._this)).getNumberOfIterations()
 * 
 * 	def getOmega(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getOmega()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_13getOmega(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18KadabraBetweenness_12getOmega, "\n\t\tgetOmega()\n\n\t\tReturns the upper bound of the required number of samples.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tUpper bound of the number of shortest paths to be sampled.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_13getOmega = {"getOmega", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_13getOmega, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_12getOmega};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_13getOmega(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOmega (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getOmega", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getOmega", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_12getOmega(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_12getOmega(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOmega", 0);

  /* "networkit/centrality.pyx":405
 * 			Upper bound of the number of shortest paths to be sampled.
 * 		"""
 * 		return(<_KadabraBetweenness*>(self._this)).getOmega()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/DynBetweenness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::KadabraBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->getOmega();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 405, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":394
 * 		return (<_KadabraBetweenness*>(self._this)).getNumberOfIterations()
 * 
 * 	def getOmega(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getOmega()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.getOmega", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_14__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.KadabraBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18KadabraBetweenness_16__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18KadabraBetweenness_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KadabraBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KadabraBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":429
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynBetweenness(G._this)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_14DynBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_14DynBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 429, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 429, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 429, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, i); __PYX_ERR(0, 429, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 429, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 429, __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("networkit.centrality.DynBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 429, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self), __pyx_v_G);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_14DynBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::DynBetweenness *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":430
 * 
 * 	def __cinit__(self, Graph G):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DynBetweenness(G._this)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":431
 * 	def __cinit__(self, Graph G):
 * 		self._G = G
 * 		self._this = new _DynBetweenness(G._this)             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  try {
    __pyx_t_1 = new NetworKit::DynBetweenness(__pyx_v_G->_this);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 431, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":429
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynBetweenness(G._this)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":433
 * 		self._this = new _DynBetweenness(G._this)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_3scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14DynBetweenness_2scores, " \n\t\tscores()\n\n\t\tGet a vector containing the betweenness score for each node in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe betweenness scores calculated by run().\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14DynBetweenness_3scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_2scores};
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_3scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness_2scores(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_2scores(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":444
 * 			The betweenness scores calculated by run().
 * 		"""
 * 		return (<_DynBetweenness*>(self._this)).scores()             # <<<<<<<<<<<<<<
 * 
 * 	def score(self, v):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 444, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":433
 * 		self._this = new _DynBetweenness(G._this)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":446
 * 		return (<_DynBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_5score(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14DynBetweenness_4score, " \n\t\tscore(v)\n\n\t\tGet the betweenness score of node `v` calculated by run().\n\n\t\tParameters\n\t\t----------\n\t\tv : int\n\t\t\tA node.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe betweenness score of node `v`.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14DynBetweenness_5score = {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_5score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_4score};
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_5score(PyObject *__pyx_v_self, 
#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_v = 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("score (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_v,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, 446, __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, 446, __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, "score", 0) < 0) __PYX_ERR(0, 446, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, i); __PYX_ERR(0, 446, __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, 446, __pyx_L3_error)
    }
    __pyx_v_v = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 446, __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("networkit.centrality.DynBetweenness.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness_4score(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_4score(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  double __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("score", 0);

  /* "networkit/centrality.pyx":462
 * 			The betweenness score of node `v`.
 * 		"""
 * 		return (<_DynBetweenness*>(self._this)).score(v)             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 462, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->score(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 462, __pyx_L1_error)
  }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 462, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":446
 * 		return (<_DynBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":464
 * 		return (<_DynBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_7ranking(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14DynBetweenness_6ranking, " \n\t\tranking()\n\t\t\n\t\tGet a vector of pairs sorted into descending order. Each pair contains a node and the corresponding score\n\t\tcalculated by run().\n\n\t\tReturns\n\t\t-------\n\t\tlist(tuple(int, float))\n\t\t\tA list of pairs.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14DynBetweenness_7ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_7ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_6ranking};
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_7ranking(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ranking (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("ranking", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("ranking", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness_6ranking(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_6ranking(struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":476
 * 			A list of pairs.
 * 		"""
 * 		return (<_DynBetweenness*>(self._this)).ranking()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/DynApproxBetweenness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->ranking();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 476, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":464
 * 		return (<_DynBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14DynBetweenness_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14DynBetweenness_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14DynBetweenness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DynBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14DynBetweenness_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14DynBetweenness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":516
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, storePredecessors = True, universalConstant=1.0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_20DynApproxBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_20DynApproxBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_epsilon = 0;
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_storePredecessors = 0;
  PyObject *__pyx_v_universalConstant = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[5] = {0,0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_epsilon,&__pyx_mstate_global->__pyx_n_u_delta,&__pyx_mstate_global->__pyx_n_u_storePredecessors,&__pyx_mstate_global->__pyx_n_u_universalConstant,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 516, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 516, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 516, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1_0));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 5, i); __PYX_ERR(0, 516, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 516, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 516, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_01));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_epsilon = values[1];
    __pyx_v_delta = values[2];
    __pyx_v_storePredecessors = values[3];
    __pyx_v_universalConstant = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 5, __pyx_nargs); __PYX_ERR(0, 516, __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("networkit.centrality.DynApproxBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 516, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_epsilon, __pyx_v_delta, __pyx_v_storePredecessors, __pyx_v_universalConstant);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_20DynApproxBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_delta, PyObject *__pyx_v_storePredecessors, PyObject *__pyx_v_universalConstant) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  double __pyx_t_2;
  bool __pyx_t_3;
  double __pyx_t_4;
  NetworKit::DynApproxBetweenness *__pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":517
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, storePredecessors = True, universalConstant=1.0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":518
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, storePredecessors = True, universalConstant=1.0):
 * 		self._G = G
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_epsilon); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_delta); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_storePredecessors); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_v_universalConstant); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error)
  try {
    __pyx_t_5 = new NetworKit::DynApproxBetweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 518, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_5;

  /* "networkit/centrality.pyx":516
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, epsilon=0.01, delta=0.1, storePredecessors = True, universalConstant=1.0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":520
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_3scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20DynApproxBetweenness_2scores, " \n\t\tscores()\n\t\t\n\t\tGet a vector containing the betweenness score for each node in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe betweenness scores calculated by run().\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_3scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_2scores};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_3scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_2scores(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_2scores(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":531
 * 			The betweenness scores calculated by run().
 * 		"""
 * 		return (<_DynApproxBetweenness*>(self._this)).scores()             # <<<<<<<<<<<<<<
 * 
 * 	def score(self, v):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynApproxBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 531, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":520
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":533
 * 		return (<_DynApproxBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_5score(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20DynApproxBetweenness_4score, " \n\t\tscore(v)\n\t\t\n\t\tGet the betweenness score of node `v` calculated by run().\n\n\t\tParameters\n\t\t----------\n\t\tv : int\n\t\t\tA node.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe betweenness score of node `v`.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_5score = {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_5score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_4score};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_5score(PyObject *__pyx_v_self, 
#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_v = 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("score (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_v,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, 533, __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, 533, __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, "score", 0) < 0) __PYX_ERR(0, 533, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, i); __PYX_ERR(0, 533, __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, 533, __pyx_L3_error)
    }
    __pyx_v_v = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("score", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 533, __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("networkit.centrality.DynApproxBetweenness.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_4score(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_4score(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  double __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("score", 0);

  /* "networkit/centrality.pyx":549
 * 			The betweenness score of node `v`.
 * 		"""
 * 		return (<_DynApproxBetweenness*>(self._this)).score(v)             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynApproxBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->score(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 549, __pyx_L1_error)
  }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 549, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":533
 * 		return (<_DynApproxBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.score", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":551
 * 		return (<_DynApproxBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_7ranking(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20DynApproxBetweenness_6ranking, " \n\t\tranking()\n\t\t\n\t\tGet a vector of pairs sorted into descending order. Each pair contains a node and the corresponding score\n\t\tcalculated by run().\n\n\t\tReturns\n\t\t-------\n\t\tlist(tuple(int, float))\n\t\t\tA list of pairs.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_7ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_7ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_6ranking};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_7ranking(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ranking (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("ranking", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("ranking", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_6ranking(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_6ranking(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<std::pair<__pyx_t_9networkit_10structures_node,double> >  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":563
 * 			A list of pairs.
 * 		"""
 * 		return (<_DynApproxBetweenness*>(self._this)).ranking()             # <<<<<<<<<<<<<<
 * 
 * 	def getNumberOfSamples(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynApproxBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->ranking();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 563, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c_double_3e___(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 563, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":551
 * 		return (<_DynApproxBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":565
 * 		return (<_DynApproxBetweenness*>(self._this)).ranking()
 * 
 * 	def getNumberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfSamples()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples, "\n\t\tgetNumberOfSamples()\n\n\t\tGet number of path samples used in last calculation.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tNumber of samples.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples = {"getNumberOfSamples", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNumberOfSamples (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getNumberOfSamples", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getNumberOfSamples", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNumberOfSamples", 0);

  /* "networkit/centrality.pyx":576
 * 			Number of samples.
 * 		"""
 * 		return (<_DynApproxBetweenness*>(self._this)).getNumberOfSamples()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/DynBetweennessOneNode.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynApproxBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->getNumberOfSamples();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 576, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":565
 * 		return (<_DynApproxBetweenness*>(self._this)).ranking()
 * 
 * 	def getNumberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfSamples()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.getNumberOfSamples", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_10__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DynApproxBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20DynApproxBetweenness_12__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20DynApproxBetweenness_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynApproxBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":605
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, node):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynBetweennessOneNode(G._this, node)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_node = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_node,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 605, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 605, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 605, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 605, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, i); __PYX_ERR(0, 605, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 605, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 605, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_node = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 605, __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("networkit.centrality.DynBetweennessOneNode.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 605, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode___cinit__(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self), __pyx_v_G, __pyx_v_node);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode___cinit__(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_node) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  NetworKit::DynBetweennessOneNode *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":606
 * 
 * 	def __cinit__(self, Graph G, node):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DynBetweennessOneNode(G._this, node)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":607
 * 	def __cinit__(self, Graph G, node):
 * 		self._G = G
 * 		self._this = new _DynBetweennessOneNode(G._this, node)             # <<<<<<<<<<<<<<
 * 
 * 	# this is necessary so that the C++ object gets properly garbage collected
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_node); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::DynBetweennessOneNode(__pyx_v_G->_this, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 607, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":605
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, node):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynBetweennessOneNode(G._this, node)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":610
 * 
 * 	# this is necessary so that the C++ object gets properly garbage collected
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		del self._this
 * 
*/

/* Python wrapper */
static void __pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_2__dealloc__(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_2__dealloc__(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self) {

  /* "networkit/centrality.pyx":611
 * 	# this is necessary so that the C++ object gets properly garbage collected
 * 	def __dealloc__(self):
 * 		del self._this             # <<<<<<<<<<<<<<
 * 
 * 	def getDistance(self, u, v):
*/
  delete __pyx_v_self->__pyx_base.__pyx_base._this;

  /* "networkit/centrality.pyx":610
 * 
 * 	# this is necessary so that the C++ object gets properly garbage collected
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		del self._this
 * 
*/

  /* function exit code */
}

/* "networkit/centrality.pyx":613
 * 		del self._this
 * 
 * 	def getDistance(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDistance(u, v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_5getDistance(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_21DynBetweennessOneNode_4getDistance, " \n\t\tgetDistance(u, v)\n\n\t\tReturns the distance between node u and node v.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tDistance between u and v.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_5getDistance = {"getDistance", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_5getDistance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_4getDistance};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_5getDistance(PyObject *__pyx_v_self, 
#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_u = 0;
  PyObject *__pyx_v_v = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDistance (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_u,&__pyx_mstate_global->__pyx_n_u_v,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, 613, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 613, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 613, __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, "getDistance", 0) < 0) __PYX_ERR(0, 613, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("getDistance", 1, 2, 2, i); __PYX_ERR(0, 613, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 613, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 613, __pyx_L3_error)
    }
    __pyx_v_u = values[0];
    __pyx_v_v = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getDistance", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 613, __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("networkit.centrality.DynBetweennessOneNode.getDistance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_4getDistance(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self), __pyx_v_u, __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_4getDistance(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  __pyx_t_9networkit_10structures_node __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDistance", 0);

  /* "networkit/centrality.pyx":624
 * 			Distance between u and v.
 * 		"""
 * 		return (<_DynBetweennessOneNode*>(self._this)).getDistance(u, v)             # <<<<<<<<<<<<<<
 * 
 * 	def getSigma(self, u, v):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_u); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error)
  try {
    __pyx_t_3 = ((NetworKit::DynBetweennessOneNode *)__pyx_v_self->__pyx_base.__pyx_base._this)->getDistance(__pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 624, __pyx_L1_error)
  }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":613
 * 		del self._this
 * 
 * 	def getDistance(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDistance(u, v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.getDistance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":626
 * 		return (<_DynBetweennessOneNode*>(self._this)).getDistance(u, v)
 * 
 * 	def getSigma(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigma(u, v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_7getSigma(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_21DynBetweennessOneNode_6getSigma, "\n\t\tgetSigma(u, v)\n\t\t\n\t\tReturns the number of shortest paths between node u and node v.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tNumber of shortest paths between u and v.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_7getSigma = {"getSigma", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_7getSigma, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_6getSigma};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_7getSigma(PyObject *__pyx_v_self, 
#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_u = 0;
  PyObject *__pyx_v_v = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSigma (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_u,&__pyx_mstate_global->__pyx_n_u_v,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, 626, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 626, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 626, __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, "getSigma", 0) < 0) __PYX_ERR(0, 626, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("getSigma", 1, 2, 2, i); __PYX_ERR(0, 626, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 626, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 626, __pyx_L3_error)
    }
    __pyx_v_u = values[0];
    __pyx_v_v = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getSigma", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 626, __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("networkit.centrality.DynBetweennessOneNode.getSigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_6getSigma(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self), __pyx_v_u, __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_6getSigma(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  __pyx_t_9networkit_10structures_node __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSigma", 0);

  /* "networkit/centrality.pyx":637
 * 			Number of shortest paths between u and v.
 * 		"""
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigma(u, v)             # <<<<<<<<<<<<<<
 * 
 * 	def getSigmax(self, u, v):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_u); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error)
  try {
    __pyx_t_3 = ((NetworKit::DynBetweennessOneNode *)__pyx_v_self->__pyx_base.__pyx_base._this)->getSigma(__pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 637, __pyx_L1_error)
  }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":626
 * 		return (<_DynBetweennessOneNode*>(self._this)).getDistance(u, v)
 * 
 * 	def getSigma(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigma(u, v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.getSigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":639
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigma(u, v)
 * 
 * 	def getSigmax(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigmax(u, v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax, " \n\t\tgetSigmax(u, v)\n\t\t\n\t\tReturns the number of shortest paths between node u and node v that go through x.\n\t\t\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tNumber of shortest paths between u and v that go through x.\n\t\t\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax = {"getSigmax", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax(PyObject *__pyx_v_self, 
#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_u = 0;
  PyObject *__pyx_v_v = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSigmax (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_u,&__pyx_mstate_global->__pyx_n_u_v,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, 639, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 639, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 639, __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, "getSigmax", 0) < 0) __PYX_ERR(0, 639, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("getSigmax", 1, 2, 2, i); __PYX_ERR(0, 639, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 639, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 639, __pyx_L3_error)
    }
    __pyx_v_u = values[0];
    __pyx_v_v = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getSigmax", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 639, __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("networkit.centrality.DynBetweennessOneNode.getSigmax", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self), __pyx_v_u, __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  __pyx_t_9networkit_10structures_node __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSigmax", 0);

  /* "networkit/centrality.pyx":651
 * 
 * 		"""
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigmax(u, v)             # <<<<<<<<<<<<<<
 * 
 * 	def getbcx(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_u); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error)
  try {
    __pyx_t_3 = ((NetworKit::DynBetweennessOneNode *)__pyx_v_self->__pyx_base.__pyx_base._this)->getSigmax(__pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 651, __pyx_L1_error)
  }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 651, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":639
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigma(u, v)
 * 
 * 	def getSigmax(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigmax(u, v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.getSigmax", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":653
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigmax(u, v)
 * 
 * 	def getbcx(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getbcx()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_11getbcx(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_21DynBetweennessOneNode_10getbcx, " \n\t\tgetbcx()\n\t\t\n\t\tReturns the betweenness centrality score of node x.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tBetweenness centrality score of x.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_11getbcx = {"getbcx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_11getbcx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_10getbcx};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_11getbcx(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getbcx (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getbcx", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getbcx", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_10getbcx(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_10getbcx(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getbcx", 0);

  /* "networkit/centrality.pyx":664
 * 			Betweenness centrality score of x.
 * 		"""
 * 		return (<_DynBetweennessOneNode*>(self._this)).getbcx()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/Closeness.hpp>" namespace "NetworKit::ClosenessVariant":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::DynBetweennessOneNode *)__pyx_v_self->__pyx_base.__pyx_base._this)->getbcx();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 664, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":653
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigmax(u, v)
 * 
 * 	def getbcx(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getbcx()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.getbcx", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_12__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DynBetweennessOneNode.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_14__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21DynBetweennessOneNode_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynBetweennessOneNode.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":718
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized, third):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		if isinstance(third, int):
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_9Closeness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_9Closeness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  PyObject *__pyx_v_third = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_third,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 718, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 718, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 718, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 718, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 718, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, i); __PYX_ERR(0, 718, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 718, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 718, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 718, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_normalized = values[1];
    __pyx_v_third = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 718, __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("networkit.centrality.Closeness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 718, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_9Closeness___cinit__(((struct __pyx_obj_9networkit_10centrality_Closeness *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized, __pyx_v_third);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_9Closeness___cinit__(struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized, PyObject *__pyx_v_third) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  enum NetworKit::ClosenessVariant __pyx_t_2;
  NetworKit::Closeness *__pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  bool __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  size_t __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":719
 * 
 * 	def __cinit__(self, Graph G, normalized, third):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		if isinstance(third, int):
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":720
 * 	def __cinit__(self, Graph G, normalized, third):
 * 		self._G = G
 * 		if isinstance(third, int):             # <<<<<<<<<<<<<<
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
 * 		elif isinstance(third, bool):
*/
  __pyx_t_1 = PyLong_Check(__pyx_v_third); 
  if (__pyx_t_1) {

    /* "networkit/centrality.pyx":721
 * 		self._G = G
 * 		if isinstance(third, int):
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)             # <<<<<<<<<<<<<<
 * 		elif isinstance(third, bool):
 * 			self._this = new _Closeness(G._this, normalized, <bool_t> third)
*/
    __pyx_t_2 = ((enum NetworKit::ClosenessVariant)__Pyx_PyLong_As_enum__NetworKit_3a__3a_ClosenessVariant(__pyx_v_third)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 721, __pyx_L1_error)
    try {
      __pyx_t_3 = new NetworKit::Closeness(__pyx_v_G->_this, __pyx_v_normalized, ((enum NetworKit::ClosenessVariant)__pyx_t_2));
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 721, __pyx_L1_error)
    }
    __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_3;

    /* "networkit/centrality.pyx":720
 * 	def __cinit__(self, Graph G, normalized, third):
 * 		self._G = G
 * 		if isinstance(third, int):             # <<<<<<<<<<<<<<
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
 * 		elif isinstance(third, bool):
*/
    goto __pyx_L3;
  }

  /* "networkit/centrality.pyx":722
 * 		if isinstance(third, int):
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
 * 		elif isinstance(third, bool):             # <<<<<<<<<<<<<<
 * 			self._this = new _Closeness(G._this, normalized, <bool_t> third)
 * 		else:
*/
  __pyx_t_4 = ((PyObject*)&PyBool_Type);
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_1 = PyObject_IsInstance(__pyx_v_third, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (likely(__pyx_t_1)) {

    /* "networkit/centrality.pyx":723
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
 * 		elif isinstance(third, bool):
 * 			self._this = new _Closeness(G._this, normalized, <bool_t> third)             # <<<<<<<<<<<<<<
 * 		else:
 * 			raise Exception("Error: the third parameter must be either a bool or a ClosenessVariant")
*/
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_third); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 723, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyBool_FromLong(((bool)__pyx_t_5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 723, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    try {
      __pyx_t_3 = new NetworKit::Closeness(__pyx_v_G->_this, __pyx_v_normalized, __pyx_t_4);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 723, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_3;

    /* "networkit/centrality.pyx":722
 * 		if isinstance(third, int):
 * 			self._this = new _Closeness(G._this, normalized, <_ClosenessVariant> third)
 * 		elif isinstance(third, bool):             # <<<<<<<<<<<<<<
 * 			self._this = new _Closeness(G._this, normalized, <bool_t> third)
 * 		else:
*/
    goto __pyx_L3;
  }

  /* "networkit/centrality.pyx":725
 * 			self._this = new _Closeness(G._this, normalized, <bool_t> third)
 * 		else:
 * 			raise Exception("Error: the third parameter must be either a bool or a ClosenessVariant")             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ApproxCloseness.hpp>" namespace "NetworKit::ApproxCloseness":
*/
  /*else*/ {
    __pyx_t_6 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_7 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Error_the_third_parameter_must_b};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 725, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __PYX_ERR(0, 725, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "networkit/centrality.pyx":718
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized, third):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		if isinstance(third, int):
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("networkit.centrality.Closeness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_9Closeness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_9Closeness_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Closeness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_9Closeness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_9Closeness_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_Closeness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_9Closeness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Closeness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_9Closeness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_9Closeness_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Closeness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_9Closeness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.Closeness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_9Closeness_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_Closeness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_9Closeness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Closeness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Closeness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":782
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, nSamples, epsilon=0.1, normalized=False, _ClosenessType type=ClosenessType.OUTBOUND):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_15ApproxCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_15ApproxCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_nSamples = 0;
  PyObject *__pyx_v_epsilon = 0;
  PyObject *__pyx_v_normalized = 0;
  enum NetworKit::ApproxCloseness::ClosenessType __pyx_v_type;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[5] = {0,0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_nSamples,&__pyx_mstate_global->__pyx_n_u_epsilon,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_type,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 782, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 782, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 782, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, i); __PYX_ERR(0, 782, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 782, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 782, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 782, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_nSamples = values[1];
    __pyx_v_epsilon = values[2];
    __pyx_v_normalized = values[3];
    if (values[4]) {
      __pyx_v_type = ((enum NetworKit::ApproxCloseness::ClosenessType)__Pyx_PyLong_As_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(values[4])); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 782, __pyx_L3_error)
    } else {
      __pyx_v_type = __pyx_mstate_global->__pyx_k_;
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, __pyx_nargs); __PYX_ERR(0, 782, __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("networkit.centrality.ApproxCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 782, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_15ApproxCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_ApproxCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_nSamples, __pyx_v_epsilon, __pyx_v_normalized, __pyx_v_type);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_15ApproxCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_nSamples, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_normalized, enum NetworKit::ApproxCloseness::ClosenessType __pyx_v_type) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  float __pyx_t_2;
  bool __pyx_t_3;
  NetworKit::ApproxCloseness *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":783
 * 
 * 	def __cinit__(self, Graph G, nSamples, epsilon=0.1, normalized=False, _ClosenessType type=ClosenessType.OUTBOUND):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":784
 * 	def __cinit__(self, Graph G, nSamples, epsilon=0.1, normalized=False, _ClosenessType type=ClosenessType.OUTBOUND):
 * 		self._G = G
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)             # <<<<<<<<<<<<<<
 * 
 * 	def getSquareErrorEstimates(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_nSamples); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 784, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsFloat(__pyx_v_epsilon); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 784, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_normalized); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 784, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::ApproxCloseness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_v_type);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 784, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":782
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, nSamples, epsilon=0.1, normalized=False, _ClosenessType type=ClosenessType.OUTBOUND):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":786
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
 * 
 * 	def getSquareErrorEstimates(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSquareErrorEstimates()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates, " \n\t\tgetSquareErrorEstimates()\n\t\t\n\t\tReturn a list containing the square error estimates for all nodes.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tA list of square error estimate values.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates = {"getSquareErrorEstimates", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates};
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSquareErrorEstimates (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getSquareErrorEstimates", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getSquareErrorEstimates", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates(((struct __pyx_obj_9networkit_10centrality_ApproxCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates(struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSquareErrorEstimates", 0);

  /* "networkit/centrality.pyx":797
 * 			A list of square error estimate values.
 * 		"""
 * 		return (<_ApproxCloseness*>(self._this)).getSquareErrorEstimates()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/DegreeCentrality.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxCloseness *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getSquareErrorEstimates();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 797, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 797, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":786
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
 * 
 * 	def getSquareErrorEstimates(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSquareErrorEstimates()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxCloseness.getSquareErrorEstimates", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_15ApproxCloseness_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ApproxCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_15ApproxCloseness_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15ApproxCloseness_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":827
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t outDeg = True, bool_t ignoreSelfLoops=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DegreeCentrality(G._this, normalized, outDeg, ignoreSelfLoops)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_16DegreeCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_16DegreeCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  bool __pyx_v_normalized;
  bool __pyx_v_outDeg;
  bool __pyx_v_ignoreSelfLoops;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_outDeg,&__pyx_mstate_global->__pyx_n_u_ignoreSelfLoops,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 827, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 827, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 827, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 827, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 827, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 827, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_normalized = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_normalized == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 827, __pyx_L3_error)
    } else {
      __pyx_v_normalized = ((bool)0);
    }
    if (values[2]) {
      __pyx_v_outDeg = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_outDeg == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 827, __pyx_L3_error)
    } else {
      __pyx_v_outDeg = ((bool)1);
    }
    if (values[3]) {
      __pyx_v_ignoreSelfLoops = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_ignoreSelfLoops == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 827, __pyx_L3_error)
    } else {
      __pyx_v_ignoreSelfLoops = ((bool)1);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 827, __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("networkit.centrality.DegreeCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 827, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_16DegreeCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_DegreeCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized, __pyx_v_outDeg, __pyx_v_ignoreSelfLoops);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_16DegreeCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_normalized, bool __pyx_v_outDeg, bool __pyx_v_ignoreSelfLoops) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::DegreeCentrality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":828
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t outDeg = True, bool_t ignoreSelfLoops=True):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DegreeCentrality(G._this, normalized, outDeg, ignoreSelfLoops)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":829
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t outDeg = True, bool_t ignoreSelfLoops=True):
 * 		self._G = G
 * 		self._this = new _DegreeCentrality(G._this, normalized, outDeg, ignoreSelfLoops)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/HarmonicCloseness.hpp>":
*/
  try {
    __pyx_t_1 = new NetworKit::DegreeCentrality(__pyx_v_G->_this, __pyx_v_normalized, __pyx_v_outDeg, __pyx_v_ignoreSelfLoops);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 829, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":827
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t outDeg = True, bool_t ignoreSelfLoops=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DegreeCentrality(G._this, normalized, outDeg, ignoreSelfLoops)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DegreeCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_16DegreeCentrality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DegreeCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_16DegreeCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DegreeCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DegreeCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_16DegreeCentrality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DegreeCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_16DegreeCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DegreeCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DegreeCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":855
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _HarmonicCloseness(G._this, normalized)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_17HarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_17HarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 855, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 855, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 855, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 855, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_True));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 855, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 855, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 855, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_True));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_normalized = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 855, __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("networkit.centrality.HarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 855, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_17HarmonicCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_17HarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  NetworKit::HarmonicCloseness *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":856
 * 
 * 	def __cinit__(self, Graph G, normalized=True):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _HarmonicCloseness(G._this, normalized)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":857
 * 	def __cinit__(self, Graph G, normalized=True):
 * 		self._G = G
 * 		self._this = new _HarmonicCloseness(G._this, normalized)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/TopCloseness.hpp>":
*/
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalized); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 857, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::HarmonicCloseness(__pyx_v_G->_this, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 857, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":855
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _HarmonicCloseness(G._this, normalized)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.HarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17HarmonicCloseness_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17HarmonicCloseness_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.HarmonicCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.HarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17HarmonicCloseness_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17HarmonicCloseness_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_HarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.HarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":902
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, first_heu=True, sec_heu=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_12TopCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_12TopCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_first_heu = 0;
  PyObject *__pyx_v_sec_heu = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_first_heu,&__pyx_mstate_global->__pyx_n_u_sec_heu,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 902, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 902, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 902, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_True));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 902, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 902, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 902, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_True));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_first_heu = values[2];
    __pyx_v_sec_heu = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 902, __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("networkit.centrality.TopCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 902, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_first_heu, __pyx_v_sec_heu);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_12TopCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_first_heu, PyObject *__pyx_v_sec_heu) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  bool __pyx_t_3;
  NetworKit::TopCloseness *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":903
 * 
 * 	def __cinit__(self,  Graph G, k=1, first_heu=True, sec_heu=True):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":904
 * 	def __cinit__(self,  Graph G, k=1, first_heu=True, sec_heu=True):
 * 		self._G = G
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)             # <<<<<<<<<<<<<<
 * 
 * 	def topkNodesList(self, includeTrail=False):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 904, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_first_heu); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 904, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_sec_heu); if (unlikely((__pyx_t_3 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 904, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::TopCloseness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 904, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":902
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, first_heu=True, sec_heu=True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":906
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_3topkNodesList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12TopCloseness_2topkNodesList, " \n\t\ttopkNodesList(includeTrail=False)\n\t\t\n\t\tReturns: a list with the k nodes with highest closeness.\n\t\tWARNING: closeness centrality of some nodes below the top-k could be equal\n\t  \tto the k-th closeness, we call them trail. Set the parameter includeTrail\n\t  \tto true to also include those nodes but consider that the resulting vector\n\t  \tcould be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail nodes. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k nodes with highest closeness.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12TopCloseness_3topkNodesList = {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_3topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_2topkNodesList};
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_3topkNodesList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkNodesList (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_includeTrail,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, 906, __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, 906, __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, "topkNodesList", 0) < 0) __PYX_ERR(0, 906, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkNodesList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 906, __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("networkit.centrality.TopCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness_2topkNodesList(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_2topkNodesList(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkNodesList", 0);

  /* "networkit/centrality.pyx":926
 * 			The k nodes with highest closeness.
 * 		"""
 * 		return (<_TopCloseness*>(self._this)).topkNodesList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def topkScoresList(self, includeTrail=False):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 926, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::TopCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkNodesList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 926, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":906
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":928
 * 		return (<_TopCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_5topkScoresList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12TopCloseness_4topkScoresList, " \n\t\ttopkScoresList(includeTrail=False)\n\t\t\n\t\tReturns: a list with the scores of the k nodes with highest closeness.\n\t\tWARNING: closeness centrality of some nodes below the top-k could be equal\n  \t\tto the k-th closeness, we call them trail. Set the parameter includeTrail\n\t  \tto true to also include those centrality values but consider that the\n\t  \tresulting vector could be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail centrality value. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k highest closeness scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12TopCloseness_5topkScoresList = {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_5topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_4topkScoresList};
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_5topkScoresList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkScoresList (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_includeTrail,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, 928, __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, 928, __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, "topkScoresList", 0) < 0) __PYX_ERR(0, 928, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 928, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkScoresList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 928, __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("networkit.centrality.TopCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness_4topkScoresList(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_4topkScoresList(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_edgeweight>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkScoresList", 0);

  /* "networkit/centrality.pyx":948
 * 			The k highest closeness scores.
 * 		"""
 * 		return (<_TopCloseness*>(self._this)).topkScoresList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 948, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::TopCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkScoresList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 948, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 948, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":928
 * 		return (<_TopCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":950
 * 		return (<_TopCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		restrictTopKComputationToNodes(nodeList)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes, "\n\t\trestrictTopKComputationToNodes(nodeList)\n\n\t\tRestricts the top-k closeness computation to a subset of nodes.\n\t\tIf the given list is empty, all nodes in the graph will be considered.\n\t\tNote: Actual existence of included nodes in the graph is not checked.\n\n\t\tParameters\n\t\t----------\n\t\tnodeList : list()\n\t\t\tList containing a subset of nodes from the graph.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes = {"restrictTopKComputationToNodes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes};
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes(PyObject *__pyx_v_self, 
#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_nodeList = 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("restrictTopKComputationToNodes (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_nodeList,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, 950, __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, 950, __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, "restrictTopKComputationToNodes", 0) < 0) __PYX_ERR(0, 950, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("restrictTopKComputationToNodes", 1, 1, 1, i); __PYX_ERR(0, 950, __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, 950, __pyx_L3_error)
    }
    __pyx_v_nodeList = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restrictTopKComputationToNodes", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 950, __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("networkit.centrality.TopCloseness.restrictTopKComputationToNodes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self), __pyx_v_nodeList);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes(struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, PyObject *__pyx_v_nodeList) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restrictTopKComputationToNodes", 0);

  /* "networkit/centrality.pyx":963
 * 			List containing a subset of nodes from the graph.
 * 		"""
 * 		return (<_TopCloseness*>(self._this)).restrictTopKComputationToNodes(nodeList)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/TopHarmonicCloseness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_nodeList); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 963, __pyx_L1_error)
  try {
    ((NetworKit::TopCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->restrictTopKComputationToNodes(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 963, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 963, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":950
 * 		return (<_TopCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		restrictTopKComputationToNodes(nodeList)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.restrictTopKComputationToNodes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_12TopCloseness_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_12TopCloseness_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_12TopCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.TopCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_12TopCloseness_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_TopCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12TopCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1006
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, useNBbound=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_useNBbound = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_useNBbound,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1006, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1006, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1006, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 1006, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1006, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_useNBbound = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1006, __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("networkit.centrality.TopHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1006, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_useNBbound);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_useNBbound) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  NetworKit::TopHarmonicCloseness *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1007
 * 
 * 	def __cinit__(self,  Graph G, k=1, useNBbound=False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1008
 * 	def __cinit__(self,  Graph G, k=1, useNBbound=False):
 * 		self._G = G
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)             # <<<<<<<<<<<<<<
 * 
 * 	def topkNodesList(self, includeTrail=False):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1008, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_useNBbound); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1008, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::TopHarmonicCloseness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1008, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1006
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, useNBbound=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1010
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList, "\n\t\ttopkNodesList(includeTrail=False)\n\n\t\tReturns a list with the k nodes with highest harmonic closeness.\n\t\tWARNING: closeness centrality of some nodes below the top-k could be equal\n\t\tto the k-th closeness, we call them trail. Set the parameter includeTrail\n\t\tto true to also include those nodes but consider that the resulting vector\n\t\tcould be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail nodes. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k nodes with highest harmonic closeness.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList = {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList};
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkNodesList (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_includeTrail,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, 1010, __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, 1010, __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, "topkNodesList", 0) < 0) __PYX_ERR(0, 1010, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1010, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkNodesList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1010, __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("networkit.centrality.TopHarmonicCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkNodesList", 0);

  /* "networkit/centrality.pyx":1030
 * 			The k nodes with highest harmonic closeness.
 * 		"""
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def topkScoresList(self, includeTrail=False):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1030, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::TopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkNodesList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1030, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1030, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1010
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1032
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList, "\n\t\ttopkScoresList(includeTrail=False)\n\n\t\tReturns a list with the scores of the k nodes with highest harmonic\n\t\tcloseness. WARNING: closeness centrality of some nodes below the top-k\n\t\tcould be equal to the k-th closeness, we call them trail. Set the\n\t\tparameter includeTrail to true to also include those centrality values\n\t\tbut consider that the resulting vector could be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail centrality value. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k highest closeness harmonic scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList = {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList};
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkScoresList (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_includeTrail,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, 1032, __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, 1032, __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, "topkScoresList", 0) < 0) __PYX_ERR(0, 1032, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1032, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkScoresList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1032, __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("networkit.centrality.TopHarmonicCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_edgeweight>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkScoresList", 0);

  /* "networkit/centrality.pyx":1052
 * 			The k highest closeness harmonic scores.
 * 		"""
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkScoresList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1052, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::TopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkScoresList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1052, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1032
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1054
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(nodeList)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes, "\n\t\ttopkScoresList(nodeList)\n\n\t\tRestricts the top-k closeness computation to a subset of nodes.\n\t\tIf the given list is empty, all nodes in the graph will be considered.\n\t\tNote: Actual existence of included nodes in the graph is not checked.\n\n\t\tParameters\n\t\t----------\n\t\tnodeList : list()\n\t\t\tList containing a subset of nodes from the graph.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes = {"restrictTopKComputationToNodes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes};
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes(PyObject *__pyx_v_self, 
#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_nodeList = 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("restrictTopKComputationToNodes (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_nodeList,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, 1054, __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, 1054, __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, "restrictTopKComputationToNodes", 0) < 0) __PYX_ERR(0, 1054, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("restrictTopKComputationToNodes", 1, 1, 1, i); __PYX_ERR(0, 1054, __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, 1054, __pyx_L3_error)
    }
    __pyx_v_nodeList = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restrictTopKComputationToNodes", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1054, __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("networkit.centrality.TopHarmonicCloseness.restrictTopKComputationToNodes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self), __pyx_v_nodeList);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_nodeList) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restrictTopKComputationToNodes", 0);

  /* "networkit/centrality.pyx":1067
 * 			List containing a subset of nodes from the graph.
 * 		"""
 * 		return (<_TopHarmonicCloseness*>(self._this)).restrictTopKComputationToNodes(nodeList)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_nodeList); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1067, __pyx_L1_error)
  try {
    ((NetworKit::TopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->restrictTopKComputationToNodes(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1067, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1054
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(nodeList)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.restrictTopKComputationToNodes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.TopHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20TopHarmonicCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.TopHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1107
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, useBFSbound=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_useBFSbound = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_useBFSbound,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1107, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1107, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1107, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 1107, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1107, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_useBFSbound = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1107, __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("networkit.centrality.DynTopHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1107, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_useBFSbound);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_useBFSbound) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  NetworKit::DynTopHarmonicCloseness *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1108
 * 
 * 	def __cinit__(self,  Graph G, k=1, useBFSbound=False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1109
 * 	def __cinit__(self,  Graph G, k=1, useBFSbound=False):
 * 		self._G = G
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self, includeTrail = False):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1109, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_useBFSbound); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1109, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::DynTopHarmonicCloseness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1109, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1107
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, useBFSbound=False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1111
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
 * 
 * 	def ranking(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking(includeTrail = False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking, " \n\t\tranking(includeTrail = False)\n\t\t\n\t\tReturns: the ranking of the k most central nodes in the graph.\n\t\tWARNING: closeness centrality of some nodes below the top-k could be equal\n\t\tto the k-th closeness, we call them trail. Set the parameter includeTrail\n\t\tto true to also include those nodes but consider that the resulting vector\n\t\tcould be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail nodes. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe ranking.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking};
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking(PyObject *__pyx_v_self, 
#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_includeTrail = 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("ranking (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_includeTrail,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, 1111, __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, 1111, __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, "ranking", 0) < 0) __PYX_ERR(0, 1111, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1111, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ranking", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1111, __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("networkit.centrality.DynTopHarmonicCloseness.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<std::pair<__pyx_t_9networkit_10structures_node,__pyx_t_9networkit_10structures_edgeweight> >  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":1131
 * 			The ranking.
 * 		"""
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).ranking(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def topkNodesList(self, includeTrail = False):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1131, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynTopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->ranking(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1131, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_pair_3c___pyx_t_9networkit_10structures_node_2c___pyx_t_9networkit_10structures_edgeweight_3e___(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1111
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
 * 
 * 	def ranking(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking(includeTrail = False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1133
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).ranking(includeTrail)
 * 
 * 	def topkNodesList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail = False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList, " \n\t\ttopkNodesList(includeTrail = False)\n\t\t\n\t\tReturns: a list with the k nodes with highest harmonic closeness.\n\t\tWARNING: closeness centrality of some nodes below the top-k could be equal\n\t\tto the k-th closeness, we call them trail. Set the parameter includeTrail\n\t\tto true to also include those nodes but consider that the resulting vector\n\t\tcould be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail nodes. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k nodes with highest harmonic closeness.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList = {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList};
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkNodesList (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_includeTrail,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, 1133, __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, 1133, __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, "topkNodesList", 0) < 0) __PYX_ERR(0, 1133, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1133, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkNodesList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1133, __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("networkit.centrality.DynTopHarmonicCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkNodesList", 0);

  /* "networkit/centrality.pyx":1153
 * 			The k nodes with highest harmonic closeness.
 * 		"""
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 	def topkScoresList(self, includeTrail = False):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1153, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynTopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkNodesList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1153, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1133
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).ranking(includeTrail)
 * 
 * 	def topkNodesList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail = False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.topkNodesList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1155
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail = False)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList, " \n\t\ttopkScoresList(includeTrail = False)\n\t\t\n\t\tReturns: a list with the scores of the k nodes with highest harmonic closeness.\n\t\tWARNING: closeness centrality of some nodes below the top-k could\n\t\tbe equal to the k-th closeness, we call them trail. Set the parameter\n\t\tincludeTrail to true to also include those centrality values but consider\n\t\tthat the resulting vector could be longer than k.\n\n\t\tParameters\n\t\t----------\n\t\tincludeTrail : bool, optional\n\t\t\tWhether or not to include trail centrality value. Default: False\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe k highest closeness harmonic scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList = {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList};
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList(PyObject *__pyx_v_self, 
#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_includeTrail = 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("topkScoresList (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_includeTrail,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, 1155, __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, 1155, __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, "topkScoresList", 0) < 0) __PYX_ERR(0, 1155, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1155, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_includeTrail = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("topkScoresList", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1155, __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("networkit.centrality.DynTopHarmonicCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self), __pyx_v_includeTrail);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, PyObject *__pyx_v_includeTrail) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  std::vector<__pyx_t_9networkit_10structures_edgeweight>  __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("topkScoresList", 0);

  /* "networkit/centrality.pyx":1175
 * 			The k highest closeness harmonic scores.
 * 		"""
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).topkScoresList(includeTrail)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_includeTrail); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1175, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynTopHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->topkScoresList(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1175, __pyx_L1_error)
  }
  __pyx_t_3 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1155
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail = False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.topkScoresList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DynTopHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_23DynTopHarmonicCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynTopHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1200
 * 	cdef Partition _P
 * 
 * 	def __cinit__(self, Graph G not None, Partition P not None):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._P = P
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_P,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1200, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1200, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1200, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1200, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, i); __PYX_ERR(0, 1200, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1200, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1200, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_P = ((struct __pyx_obj_9networkit_10structures_Partition *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1200, __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("networkit.centrality.LocalPartitionCoverage.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 0, "G", 0))) __PYX_ERR(0, 1200, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_P), __pyx_mstate_global->__pyx_ptype_9networkit_10structures_Partition, 0, "P", 0))) __PYX_ERR(0, 1200, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_22LocalPartitionCoverage___cinit__(((struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)__pyx_v_self), __pyx_v_G, __pyx_v_P);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_22LocalPartitionCoverage___cinit__(struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::LocalPartitionCoverage *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1201
 * 
 * 	def __cinit__(self, Graph G not None, Partition P not None):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._P = P
 * 		self._this = new _LocalPartitionCoverage(G._this, P._this)
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":1202
 * 	def __cinit__(self, Graph G not None, Partition P not None):
 * 		self._G = G
 * 		self._P = P             # <<<<<<<<<<<<<<
 * 		self._this = new _LocalPartitionCoverage(G._this, P._this)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_P);
  __Pyx_GIVEREF((PyObject *)__pyx_v_P);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_P);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_P);
  __pyx_v_self->_P = __pyx_v_P;

  /* "networkit/centrality.pyx":1203
 * 		self._G = G
 * 		self._P = P
 * 		self._this = new _LocalPartitionCoverage(G._this, P._this)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/GroupDegree.hpp>":
*/
  try {
    __pyx_t_1 = new NetworKit::LocalPartitionCoverage(__pyx_v_G->_this, __pyx_v_P->_this);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1203, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":1200
 * 	cdef Partition _P
 * 
 * 	def __cinit__(self, Graph G not None, Partition P not None):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._P = P
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalPartitionCoverage.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalPartitionCoverage.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.LocalPartitionCoverage.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22LocalPartitionCoverage_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalPartitionCoverage.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1238
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1, countGroupNodes = True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_11GroupDegree_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_11GroupDegree_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_countGroupNodes = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_countGroupNodes,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1238, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1238, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1238, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_True));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 1238, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1238, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_True));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_countGroupNodes = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1238, __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("networkit.centrality.GroupDegree.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1238, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_countGroupNodes);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_11GroupDegree___cinit__(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_countGroupNodes) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  NetworKit::GroupDegree *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1239
 * 
 * 	def __cinit__(self, Graph G, k = 1, countGroupNodes = True):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1240
 * 	def __cinit__(self, Graph G, k = 1, countGroupNodes = True):
 * 		self._G = G
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxDegree(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1240, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_countGroupNodes); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1240, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::GroupDegree(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1240, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1238
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1, countGroupNodes = True):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1242
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
 * 
 * 	def groupMaxDegree(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxDegree()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_3groupMaxDegree(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_11GroupDegree_2groupMaxDegree, "\n\t\tgroupMaxDegree()\n\n\t\tReturns the group with maximum degree centrality.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe group of k nodes with highest degree centrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_11GroupDegree_3groupMaxDegree = {"groupMaxDegree", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_3groupMaxDegree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_2groupMaxDegree};
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_3groupMaxDegree(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxDegree (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxDegree", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxDegree", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree_2groupMaxDegree(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_2groupMaxDegree(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxDegree", 0);

  /* "networkit/centrality.pyx":1253
 * 			The group of k nodes with highest degree centrality.
 * 		"""
 * 		return (<_GroupDegree*>(self._this)).groupMaxDegree()             # <<<<<<<<<<<<<<
 * 
 * 	def getScore(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupDegree *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxDegree();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1253, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1242
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
 * 
 * 	def groupMaxDegree(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxDegree()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.groupMaxDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1255
 * 		return (<_GroupDegree*>(self._this)).groupMaxDegree()
 * 
 * 	def getScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getScore()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_5getScore(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_11GroupDegree_4getScore, "\n\t\tgetScore()\n\n\t\tReturns the score of the group with maximum degree centrality (i.e. the\n\t\tnumber of nodes outside the group that can be reached in one hop from at\n\t\tleast one node in the group).\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe number of nodes outside the group that can be reached in one hop\n\t\t\tfrom at least one node in the group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_11GroupDegree_5getScore = {"getScore", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_5getScore, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_4getScore};
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_5getScore(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getScore (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getScore", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getScore", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree_4getScore(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_4getScore(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getScore", 0);

  /* "networkit/centrality.pyx":1269
 * 			from at least one node in the group.
 * 		"""
 * 		return (<_GroupDegree*>(self._this)).getScore()             # <<<<<<<<<<<<<<
 * 
 * 	def scoreOfGroup(self, vector[node] group):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupDegree *)__pyx_v_self->__pyx_base.__pyx_base._this)->getScore();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1269, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1255
 * 		return (<_GroupDegree*>(self._this)).groupMaxDegree()
 * 
 * 	def getScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getScore()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.getScore", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1271
 * 		return (<_GroupDegree*>(self._this)).getScore()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(vector[node] group)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_7scoreOfGroup(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_11GroupDegree_6scoreOfGroup, "\n\t\tscoreOfGroup(vector[node] group)\n\t\t\n\t\tReturns the score of the given group.\n\n\t\tParameters\n\t\t-----------\n\t\tgroup : list(int)\n\t\t\tList of nodes.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe score of the given group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_11GroupDegree_7scoreOfGroup = {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_7scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_6scoreOfGroup};
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_7scoreOfGroup(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group;
  #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("scoreOfGroup (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_group,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, 1271, __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, 1271, __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, "scoreOfGroup", 0) < 0) __PYX_ERR(0, 1271, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, i); __PYX_ERR(0, 1271, __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, 1271, __pyx_L3_error)
    }
    __pyx_v_group = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1271, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1271, __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("networkit.centrality.GroupDegree.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree_6scoreOfGroup(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self), __PYX_STD_MOVE_IF_SUPPORTED(__pyx_v_group));

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_6scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scoreOfGroup", 0);

  /* "networkit/centrality.pyx":1287
 * 			The score of the given group.
 * 		"""
 * 		return (<_GroupDegree*>(self._this)).scoreOfGroup(group)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/GedWalk.hpp>" namespace "NetworKit::GedWalk":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupDegree *)__pyx_v_self->__pyx_base.__pyx_base._this)->scoreOfGroup(__pyx_v_group);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1287, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1271
 * 		return (<_GroupDegree*>(self._this)).getScore()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(vector[node] group)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_11GroupDegree_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_11GroupDegree_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_11GroupDegree_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupDegree.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_11GroupDegree_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupDegree *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_11GroupDegree_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupDegree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupDegree.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1369
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = BoundStrategy.GEOMETRIC,             # <<<<<<<<<<<<<<
 * 			gs = GreedyStrategy.LAZY, spectralDelta = 0.5):
 * 
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_7GedWalk_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_7GedWalk_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_epsilon = 0;
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_bs = 0;
  PyObject *__pyx_v_gs = 0;
  PyObject *__pyx_v_spectralDelta = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[7] = {0,0,0,0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_epsilon,&__pyx_mstate_global->__pyx_n_u_alpha,&__pyx_mstate_global->__pyx_n_u_bs,&__pyx_mstate_global->__pyx_n_u_gs,&__pyx_mstate_global->__pyx_n_u_spectralDelta,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1369, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1369, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1369, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_neg_1_0));
      if (!values[4]) values[4] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2);
      if (!values[5]) values[5] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__3);
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_5));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 7, i); __PYX_ERR(0, 1369, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1369, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1369, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_neg_1_0));
      if (!values[4]) values[4] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2);
      if (!values[5]) values[5] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__3);
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_5));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_epsilon = values[2];
    __pyx_v_alpha = values[3];
    __pyx_v_bs = values[4];
    __pyx_v_gs = values[5];
    __pyx_v_spectralDelta = values[6];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 1369, __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("networkit.centrality.GedWalk.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1369, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk___cinit__(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_epsilon, __pyx_v_alpha, __pyx_v_bs, __pyx_v_gs, __pyx_v_spectralDelta);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_7GedWalk___cinit__(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_epsilon, PyObject *__pyx_v_alpha, PyObject *__pyx_v_bs, PyObject *__pyx_v_gs, PyObject *__pyx_v_spectralDelta) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  double __pyx_t_2;
  double __pyx_t_3;
  enum NetworKit::GedWalk::BoundStrategy __pyx_t_4;
  enum NetworKit::GedWalk::GreedyStrategy __pyx_t_5;
  double __pyx_t_6;
  NetworKit::GedWalk *__pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1372
 * 			gs = GreedyStrategy.LAZY, spectralDelta = 0.5):
 * 
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GedWalk(G._this, k, epsilon, alpha, bs, gs, spectralDelta)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1373
 * 
 * 		self._G = G
 * 		self._this = new _GedWalk(G._this, k, epsilon, alpha, bs, gs, spectralDelta)             # <<<<<<<<<<<<<<
 * 
 * 	def __dealloc__(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_epsilon); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_v_alpha); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  __pyx_t_4 = ((enum NetworKit::GedWalk::BoundStrategy)__Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(__pyx_v_bs)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  __pyx_t_5 = ((enum NetworKit::GedWalk::GreedyStrategy)__Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(__pyx_v_gs)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_v_spectralDelta); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1373, __pyx_L1_error)
  try {
    __pyx_t_7 = new NetworKit::GedWalk(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1373, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_7;

  /* "networkit/centrality.pyx":1369
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = BoundStrategy.GEOMETRIC,             # <<<<<<<<<<<<<<
 * 			gs = GreedyStrategy.LAZY, spectralDelta = 0.5):
 * 
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GedWalk.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1375
 * 		self._this = new _GedWalk(G._this, k, epsilon, alpha, bs, gs, spectralDelta)
 * 
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		if self._this is not NULL:
 * 			del self._this
*/

/* Python wrapper */
static void __pyx_pw_9networkit_10centrality_7GedWalk_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_9networkit_10centrality_7GedWalk_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_9networkit_10centrality_7GedWalk_2__dealloc__(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_9networkit_10centrality_7GedWalk_2__dealloc__(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self) {
  int __pyx_t_1;

  /* "networkit/centrality.pyx":1376
 * 
 * 	def __dealloc__(self):
 * 		if self._this is not NULL:             # <<<<<<<<<<<<<<
 * 			del self._this
 * 			self._this = NULL
*/
  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._this != NULL);
  if (__pyx_t_1) {

    /* "networkit/centrality.pyx":1377
 * 	def __dealloc__(self):
 * 		if self._this is not NULL:
 * 			del self._this             # <<<<<<<<<<<<<<
 * 			self._this = NULL
 * 
*/
    delete __pyx_v_self->__pyx_base.__pyx_base._this;

    /* "networkit/centrality.pyx":1378
 * 		if self._this is not NULL:
 * 			del self._this
 * 			self._this = NULL             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxGedWalk(self):
*/
    __pyx_v_self->__pyx_base.__pyx_base._this = NULL;

    /* "networkit/centrality.pyx":1376
 * 
 * 	def __dealloc__(self):
 * 		if self._this is not NULL:             # <<<<<<<<<<<<<<
 * 			del self._this
 * 			self._this = NULL
*/
  }

  /* "networkit/centrality.pyx":1375
 * 		self._this = new _GedWalk(G._this, k, epsilon, alpha, bs, gs, spectralDelta)
 * 
 * 	def __dealloc__(self):             # <<<<<<<<<<<<<<
 * 		if self._this is not NULL:
 * 			del self._this
*/

  /* function exit code */
}

/* "networkit/centrality.pyx":1380
 * 			self._this = NULL
 * 
 * 	def groupMaxGedWalk(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxGedWalk()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_5groupMaxGedWalk(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_7GedWalk_4groupMaxGedWalk, "\n\t\tgroupMaxGedWalk()\n\n\t\tReturns the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_7GedWalk_5groupMaxGedWalk = {"groupMaxGedWalk", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_5groupMaxGedWalk, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_4groupMaxGedWalk};
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_5groupMaxGedWalk(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxGedWalk (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxGedWalk", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxGedWalk", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk_4groupMaxGedWalk(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_4groupMaxGedWalk(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxGedWalk", 0);

  /* "networkit/centrality.pyx":1391
 * 			The computed group.
 * 		"""
 * 		return (<_GedWalk*>(self._this)).groupMaxGedWalk()             # <<<<<<<<<<<<<<
 * 
 * 	def getApproximateScore(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GedWalk *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxGedWalk();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1391, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1380
 * 			self._this = NULL
 * 
 * 	def groupMaxGedWalk(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxGedWalk()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GedWalk.groupMaxGedWalk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1393
 * 		return (<_GedWalk*>(self._this)).groupMaxGedWalk()
 * 
 * 	def getApproximateScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getApproximateScore()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_7getApproximateScore(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_7GedWalk_6getApproximateScore, "\n\t\tgetApproximateScore()\n\n\t\tReturns the GedWalk score of the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe GedWalk score of the computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_7GedWalk_7getApproximateScore = {"getApproximateScore", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_7getApproximateScore, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_6getApproximateScore};
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_7getApproximateScore(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getApproximateScore (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getApproximateScore", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getApproximateScore", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk_6getApproximateScore(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_6getApproximateScore(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getApproximateScore", 0);

  /* "networkit/centrality.pyx":1404
 * 			The GedWalk score of the computed group.
 * 		"""
 * 		return (<_GedWalk*>(self._this)).getApproximateScore()             # <<<<<<<<<<<<<<
 * 
 * 	def scoreOfGroup(self, group, epsilon = 0.1):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GedWalk *)__pyx_v_self->__pyx_base.__pyx_base._this)->getApproximateScore();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1404, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1404, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1393
 * 		return (<_GedWalk*>(self._this)).groupMaxGedWalk()
 * 
 * 	def getApproximateScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getApproximateScore()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GedWalk.getApproximateScore", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1406
 * 		return (<_GedWalk*>(self._this)).getApproximateScore()
 * 
 * 	def scoreOfGroup(self, group, epsilon = 0.1):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group, epsilon = 0.1)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_9scoreOfGroup(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_7GedWalk_8scoreOfGroup, "\n\t\tscoreOfGroup(group, epsilon = 0.1)\n\t\t\n\t\tReturns the GedWalk score of the input group.\n\n\t\tParameters\n\t\t----------\n\t\tgroup : list(int)\n\t\t\tThe input group.\n\t\tepsilon : float, optional\n\t\t\tThe precision of the score to be computed. Default: 0.1\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tAn epsilon-approximation of the GedWalk score of the input group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_7GedWalk_9scoreOfGroup = {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_9scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_8scoreOfGroup};
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_9scoreOfGroup(PyObject *__pyx_v_self, 
#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_group = 0;
  PyObject *__pyx_v_epsilon = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scoreOfGroup (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_group,&__pyx_mstate_global->__pyx_n_u_epsilon,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, 1406, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1406, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1406, __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, "scoreOfGroup", 0) < 0) __PYX_ERR(0, 1406, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 0, 1, 2, i); __PYX_ERR(0, 1406, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1406, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1406, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
    }
    __pyx_v_group = values[0];
    __pyx_v_epsilon = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1406, __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("networkit.centrality.GedWalk.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk_8scoreOfGroup(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self), __pyx_v_group, __pyx_v_epsilon);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_8scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, PyObject *__pyx_v_group, PyObject *__pyx_v_epsilon) {
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_groupVec;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_4;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  size_t __pyx_t_12;
  double __pyx_t_13;
  double __pyx_t_14;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scoreOfGroup", 0);

  /* "networkit/centrality.pyx":1426
 * 		cdef vector[node] groupVec
 * 
 * 		try:             # <<<<<<<<<<<<<<
 * 			groupVec = <vector[node]?>group
 * 		except TypeError:
*/
  {
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
    __Pyx_XGOTREF(__pyx_t_1);
    __Pyx_XGOTREF(__pyx_t_2);
    __Pyx_XGOTREF(__pyx_t_3);
    /*try:*/ {

      /* "networkit/centrality.pyx":1427
 * 
 * 		try:
 * 			groupVec = <vector[node]?>group             # <<<<<<<<<<<<<<
 * 		except TypeError:
 * 			raise RuntimeError("Error, group must be a list of nodes.")
*/
      __pyx_t_4 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1427, __pyx_L3_error)
      __pyx_v_groupVec = ((std::vector<__pyx_t_9networkit_10structures_node> )__pyx_t_4);

      /* "networkit/centrality.pyx":1426
 * 		cdef vector[node] groupVec
 * 
 * 		try:             # <<<<<<<<<<<<<<
 * 			groupVec = <vector[node]?>group
 * 		except TypeError:
*/
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;

    /* "networkit/centrality.pyx":1428
 * 		try:
 * 			groupVec = <vector[node]?>group
 * 		except TypeError:             # <<<<<<<<<<<<<<
 * 			raise RuntimeError("Error, group must be a list of nodes.")
 * 		return (<_GedWalk*>(self._this)).scoreOfGroup[vector[node].iterator](groupVec.begin(), groupVec.end(), epsilon)
*/
    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
    if (__pyx_t_5) {
      __Pyx_AddTraceback("networkit.centrality.GedWalk.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 1428, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);

      /* "networkit/centrality.pyx":1429
 * 			groupVec = <vector[node]?>group
 * 		except TypeError:
 * 			raise RuntimeError("Error, group must be a list of nodes.")             # <<<<<<<<<<<<<<
 * 		return (<_GedWalk*>(self._this)).scoreOfGroup[vector[node].iterator](groupVec.begin(), groupVec.end(), epsilon)
 * 
*/
      __pyx_t_10 = NULL;
      __Pyx_INCREF(__pyx_builtin_RuntimeError);
      __pyx_t_11 = __pyx_builtin_RuntimeError; 
      __pyx_t_12 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_Error_group_must_be_a_list_of_no};
        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_12, (2-__pyx_t_12) | (__pyx_t_12*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1429, __pyx_L5_except_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __PYX_ERR(0, 1429, __pyx_L5_except_error)
    }
    goto __pyx_L5_except_error;

    /* "networkit/centrality.pyx":1426
 * 		cdef vector[node] groupVec
 * 
 * 		try:             # <<<<<<<<<<<<<<
 * 			groupVec = <vector[node]?>group
 * 		except TypeError:
*/
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L8_try_end:;
  }

  /* "networkit/centrality.pyx":1430
 * 		except TypeError:
 * 			raise RuntimeError("Error, group must be a list of nodes.")
 * 		return (<_GedWalk*>(self._this)).scoreOfGroup[vector[node].iterator](groupVec.begin(), groupVec.end(), epsilon)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_epsilon); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1430, __pyx_L1_error)
  try {
    __pyx_t_14 = ((NetworKit::GedWalk *)__pyx_v_self->__pyx_base.__pyx_base._this)->scoreOfGroup<std::vector<__pyx_t_9networkit_10structures_node> ::iterator>(__pyx_v_groupVec.begin(), __pyx_v_groupVec.end(), __pyx_t_13);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1430, __pyx_L1_error)
  }
  __pyx_t_8 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1430, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1406
 * 		return (<_GedWalk*>(self._this)).getApproximateScore()
 * 
 * 	def scoreOfGroup(self, group, epsilon = 0.1):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group, epsilon = 0.1)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("networkit.centrality.GedWalk.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_7GedWalk_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk_10__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GedWalk.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_7GedWalk_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_7GedWalk_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GedWalk.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_7GedWalk_12__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GedWalk *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_7GedWalk_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GedWalk *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GedWalk.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1458
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, groupSize, epsilon):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_groupSize = 0;
  PyObject *__pyx_v_epsilon = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_groupSize,&__pyx_mstate_global->__pyx_n_u_epsilon,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1458, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1458, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1458, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1458, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1458, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, i); __PYX_ERR(0, 1458, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1458, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1458, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1458, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_groupSize = values[1];
    __pyx_v_epsilon = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1458, __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("networkit.centrality.ApproxGroupBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1458, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness___cinit__(((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)__pyx_v_self), __pyx_v_G, __pyx_v_groupSize, __pyx_v_epsilon);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_groupSize, PyObject *__pyx_v_epsilon) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  double __pyx_t_2;
  NetworKit::ApproxGroupBetweenness *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1459
 * 
 * 	def __cinit__(self, Graph G, groupSize, epsilon):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1460
 * 	def __cinit__(self, Graph G, groupSize, epsilon):
 * 		self._G = G
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxBetweenness(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_groupSize); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1460, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_epsilon); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1460, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::ApproxGroupBetweenness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1460, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1458
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, groupSize, epsilon):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxGroupBetweenness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1462
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
 * 
 * 	def groupMaxBetweenness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxBetweenness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness, "\n\t\tgroupMaxBetweenness()\n\t\t\n\t\tGet a vector of nodes containing the set of nodes with apporoximated\n\t\tmaximum group betweenness.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe group of nodes with highest approximated group betweenness.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness = {"groupMaxBetweenness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness};
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxBetweenness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxBetweenness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxBetweenness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness(((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxBetweenness", 0);

  /* "networkit/centrality.pyx":1474
 * 			The group of nodes with highest approximated group betweenness.
 * 		"""
 * 		return (<_ApproxGroupBetweenness*>(self._this)).groupMaxBetweenness()             # <<<<<<<<<<<<<<
 * 
 * 	def scoreOfGroup(self, vector[node] group):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxGroupBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxBetweenness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1474, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1474, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1462
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
 * 
 * 	def groupMaxBetweenness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxBetweenness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxGroupBetweenness.groupMaxBetweenness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1476
 * 		return (<_ApproxGroupBetweenness*>(self._this)).groupMaxBetweenness()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup, "\n\t\tscoreOfGroup(group)\n\t\t\n\t\tReturns the score of the given group.\n\n\t\tParameters\n\t\t----------\n\t\tgroup : list(int)\n\t\t\tSet of nodes.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe score of the given group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup = {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup};
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group;
  #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("scoreOfGroup (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_group,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, 1476, __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, 1476, __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, "scoreOfGroup", 0) < 0) __PYX_ERR(0, 1476, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, i); __PYX_ERR(0, 1476, __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, 1476, __pyx_L3_error)
    }
    __pyx_v_group = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1476, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1476, __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("networkit.centrality.ApproxGroupBetweenness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup(((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)__pyx_v_self), __PYX_STD_MOVE_IF_SUPPORTED(__pyx_v_group));

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_group) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scoreOfGroup", 0);

  /* "networkit/centrality.pyx":1492
 * 			The score of the given group.
 * 		"""
 * 		return (<_ApproxGroupBetweenness*>(self._this)).scoreOfGroup(group)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/GroupCloseness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxGroupBetweenness *)__pyx_v_self->__pyx_base.__pyx_base._this)->scoreOfGroup(__pyx_v_group);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1492, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1492, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1476
 * 		return (<_ApproxGroupBetweenness*>(self._this)).groupMaxBetweenness()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxGroupBetweenness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxGroupBetweenness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ApproxGroupBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22ApproxGroupBetweenness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxGroupBetweenness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1522
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, H=0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupCloseness(G._this, k, H)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_14GroupCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_14GroupCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_H = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_H,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1522, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1522, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1522, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1522, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1522, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 1522, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1522, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1522, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1522, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_H = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1522, __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("networkit.centrality.GroupCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1522, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_H);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_14GroupCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_H) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  __pyx_t_9networkit_10structures_count __pyx_t_2;
  NetworKit::GroupCloseness *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1523
 * 
 * 	def __cinit__(self,  Graph G, k=1, H=0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupCloseness(G._this, k, H)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1524
 * 	def __cinit__(self,  Graph G, k=1, H=0):
 * 		self._G = G
 * 		self._this = new _GroupCloseness(G._this, k, H)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxCloseness(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1524, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_H); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1524, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::GroupCloseness(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1524, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1522
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self,  Graph G, k=1, H=0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupCloseness(G._this, k, H)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1526
 * 		self._this = new _GroupCloseness(G._this, k, H)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness, "\n\t\tgroupMaxCloseness()\n\t\t\n\t\tReturns the group with maximum closeness centrality.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe group of k nodes with maximum closeness centrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness = {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness};
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxCloseness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxCloseness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxCloseness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxCloseness", 0);

  /* "networkit/centrality.pyx":1537
 * 			The group of k nodes with maximum closeness centrality.
 * 		"""
 * 		return (<_GroupCloseness*>(self._this)).groupMaxCloseness()             # <<<<<<<<<<<<<<
 * 
 * 	def computeFarness(self, S, H=0):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxCloseness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1537, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1537, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1526
 * 		self._this = new _GroupCloseness(G._this, k, H)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.groupMaxCloseness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1539
 * 		return (<_GroupCloseness*>(self._this)).groupMaxCloseness()
 * 
 * 	def computeFarness(self, S, H=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeFarness(S, H=0)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_5computeFarness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14GroupCloseness_4computeFarness, " \n\t\tcomputeFarness(S, H=0)\n\t\t\n\t\tComputes farness (i.e., inverse of the closeness) for a given group (stopping after H iterations if H > 0).\n\n\t\tParameters\n\t\t----------\n\t\tS : list(int)\n\t\t\tGroup to compute farness on.\n\t\tH : int, optional\n\t\t\tIf equal 0, simply runs the algorithm proposed in Bergamini et al.. \n\t\t\tIf > 0, interrupts after H iterations (suggested for very large networks). Default: 0\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tFarness value for node group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14GroupCloseness_5computeFarness = {"computeFarness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_5computeFarness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_4computeFarness};
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_5computeFarness(PyObject *__pyx_v_self, 
#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_S = 0;
  PyObject *__pyx_v_H = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeFarness (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_S,&__pyx_mstate_global->__pyx_n_u_H,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, 1539, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1539, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1539, __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, "computeFarness", 0) < 0) __PYX_ERR(0, 1539, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("computeFarness", 0, 1, 2, i); __PYX_ERR(0, 1539, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1539, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1539, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_S = values[0];
    __pyx_v_H = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeFarness", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1539, __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("networkit.centrality.GroupCloseness.computeFarness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness_4computeFarness(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self), __pyx_v_S, __pyx_v_H);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_4computeFarness(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, PyObject *__pyx_v_S, PyObject *__pyx_v_H) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  __pyx_t_9networkit_10structures_count __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeFarness", 0);

  /* "networkit/centrality.pyx":1558
 * 			Farness value for node group.
 * 		"""
 * 		return (<_GroupCloseness*>(self._this)).computeFarness(S, H)             # <<<<<<<<<<<<<<
 * 
 * 	def scoreOfGroup(self, group):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_S); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1558, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_H); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1558, __pyx_L1_error)
  try {
    __pyx_t_3 = ((NetworKit::GroupCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->computeFarness(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1), __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1558, __pyx_L1_error)
  }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1558, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1539
 * 		return (<_GroupCloseness*>(self._this)).groupMaxCloseness()
 * 
 * 	def computeFarness(self, S, H=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeFarness(S, H=0)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.computeFarness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1560
 * 		return (<_GroupCloseness*>(self._this)).computeFarness(S, H)
 * 
 * 	def scoreOfGroup(self, group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_7scoreOfGroup(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_14GroupCloseness_6scoreOfGroup, "\n\t\tscoreOfGroup(group)\n\t\t\n\t\tComputes the group closeness score of the given group.\n\n\t\tParameters\n\t\t----------\n\t\tgroup : list(int)\n\t\t\tList of nodes.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe group closeness score of the given group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_14GroupCloseness_7scoreOfGroup = {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_7scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_6scoreOfGroup};
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_7scoreOfGroup(PyObject *__pyx_v_self, 
#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_group = 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("scoreOfGroup (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_group,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, 1560, __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, 1560, __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, "scoreOfGroup", 0) < 0) __PYX_ERR(0, 1560, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, i); __PYX_ERR(0, 1560, __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, 1560, __pyx_L3_error)
    }
    __pyx_v_group = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1560, __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("networkit.centrality.GroupCloseness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness_6scoreOfGroup(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self), __pyx_v_group);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_6scoreOfGroup(struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, PyObject *__pyx_v_group) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  double __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scoreOfGroup", 0);

  /* "networkit/centrality.pyx":1576
 * 			The group closeness score of the given group.
 * 		"""
 * 		return (<_GroupCloseness*>(self._this)).scoreOfGroup(group)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1576, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::GroupCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->scoreOfGroup(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1));
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1576, __pyx_L1_error)
  }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1560
 * 		return (<_GroupCloseness*>(self._this)).computeFarness(S, H)
 * 
 * 	def scoreOfGroup(self, group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14GroupCloseness_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14GroupCloseness_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14GroupCloseness_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14GroupCloseness_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14GroupCloseness_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1611
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, group, extended = False, insertions = 0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_group = 0;
  PyObject *__pyx_v_extended = 0;
  PyObject *__pyx_v_insertions = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_group,&__pyx_mstate_global->__pyx_n_u_extended,&__pyx_mstate_global->__pyx_n_u_insertions,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1611, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1611, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1611, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1611, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1611, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1611, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, i); __PYX_ERR(0, 1611, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1611, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1611, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1611, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1611, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_group = values[1];
    __pyx_v_extended = values[2];
    __pyx_v_insertions = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 1611, __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("networkit.centrality.GroupClosenessGrowShrink.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1611, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)__pyx_v_self), __pyx_v_G, __pyx_v_group, __pyx_v_extended, __pyx_v_insertions);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_extended, PyObject *__pyx_v_insertions) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  bool __pyx_t_2;
  __pyx_t_9networkit_10structures_count __pyx_t_3;
  NetworKit::GroupClosenessGrowShrink *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1612
 * 
 * 	def __cinit__(self, Graph G, group, extended = False, insertions = 0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1613
 * 	def __cinit__(self, Graph G, group, extended = False, insertions = 0):
 * 		self._G = G
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxCloseness(self):
*/
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1613, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_extended); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1613, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_insertions); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1613, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::GroupClosenessGrowShrink(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1613, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":1611
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, group, extended = False, insertions = 0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessGrowShrink.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1615
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness, "\n\t\tgroupMaxCloseness()\n\n\t\tReturns the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness = {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxCloseness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxCloseness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxCloseness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness(((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxCloseness", 0);

  /* "networkit/centrality.pyx":1626
 * 			The computed group.
 * 		"""
 * 		return (<_GroupClosenessGrowShrink*>(self._this)).groupMaxCloseness()             # <<<<<<<<<<<<<<
 * 
 * 	def numberOfIterations(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessGrowShrink *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxCloseness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1626, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1615
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessGrowShrink.groupMaxCloseness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1628
 * 		return (<_GroupClosenessGrowShrink*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		Return the total number of iterations performed by the algorithm.
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations, "\n\t\tReturn the total number of iterations performed by the algorithm.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tTotal number of iterations performed by the algorithm.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations = {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("numberOfIterations (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("numberOfIterations", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("numberOfIterations", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations(((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("numberOfIterations", 0);

  /* "networkit/centrality.pyx":1637
 * 			Total number of iterations performed by the algorithm.
 * 		"""
 * 		return (<_GroupClosenessGrowShrink*>(self._this)).numberOfIterations()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessGrowShrink *)__pyx_v_self->__pyx_base.__pyx_base._this)->numberOfIterations();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1637, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1628
 * 		return (<_GroupClosenessGrowShrink*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		Return the total number of iterations performed by the algorithm.
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessGrowShrink.numberOfIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessGrowShrink.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupClosenessGrowShrink.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessGrowShrink_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessGrowShrink.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1668
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, group, maxSwaps = 0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_group = 0;
  PyObject *__pyx_v_maxSwaps = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_group,&__pyx_mstate_global->__pyx_n_u_maxSwaps,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1668, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1668, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1668, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1668, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1668, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, i); __PYX_ERR(0, 1668, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1668, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1668, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1668, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_group = values[1];
    __pyx_v_maxSwaps = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1668, __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("networkit.centrality.GroupClosenessLocalSwaps.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1668, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)__pyx_v_self), __pyx_v_G, __pyx_v_group, __pyx_v_maxSwaps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_maxSwaps) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  __pyx_t_9networkit_10structures_count __pyx_t_2;
  NetworKit::GroupClosenessLocalSwaps *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1669
 * 
 * 	def __cinit__(self, Graph G, group, maxSwaps = 0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1670
 * 	def __cinit__(self, Graph G, group, maxSwaps = 0):
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxCloseness(self):
*/
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1670, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_maxSwaps); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1670, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::GroupClosenessLocalSwaps(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1670, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1668
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, group, maxSwaps = 0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSwaps.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1672
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness, "\n\t\tgroupMaxCloseness()\n\n\t\tReturns the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness = {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxCloseness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxCloseness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxCloseness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxCloseness", 0);

  /* "networkit/centrality.pyx":1683
 * 			The computed group.
 * 		"""
 * 		return (<_GroupClosenessLocalSwaps*>(self._this)).groupMaxCloseness()             # <<<<<<<<<<<<<<
 * 
 * 	def numberOfSwaps(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessLocalSwaps *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxCloseness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1683, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1683, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1672
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSwaps.groupMaxCloseness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1685
 * 		return (<_GroupClosenessLocalSwaps*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfSwaps(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfSwaps()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps, "\n\t\tnumberOfSwaps()\n\n\t\tReturn the total number of vertex exchanges performed by the algorithm.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tTotal number of vertex exchanges performed by the algorithm.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps = {"numberOfSwaps", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("numberOfSwaps (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("numberOfSwaps", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("numberOfSwaps", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("numberOfSwaps", 0);

  /* "networkit/centrality.pyx":1696
 * 			Total number of vertex exchanges performed by the algorithm.
 * 		"""
 * 		return (<_GroupClosenessLocalSwaps*>(self._this)).numberOfSwaps()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessLocalSwaps *)__pyx_v_self->__pyx_base.__pyx_base._this)->numberOfSwaps();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1696, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1696, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1685
 * 		return (<_GroupClosenessLocalSwaps*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfSwaps(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfSwaps()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSwaps.numberOfSwaps", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSwaps.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupClosenessLocalSwaps.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_24GroupClosenessLocalSwaps_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSwaps.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1731
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1731, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1731, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1731, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1731, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 1731, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1731, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1731, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_1));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1731, __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("networkit.centrality.GroupHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1731, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_k);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  NetworKit::GroupHarmonicCloseness *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1732
 * 
 * 	def __cinit__(self, Graph G, k = 1):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1733
 * 	def __cinit__(self, Graph G, k = 1):
 * 		self._G = G
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxHarmonicCloseness(self):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1733, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::GroupHarmonicCloseness(__pyx_v_G->_this, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1733, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":1731
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupHarmonicCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1735
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
 * 
 * 	def groupMaxHarmonicCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxHarmonicCloseness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness, "\n\t\tgroupMaxHarmonicCloseness()\n\n\t\tReturns the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness = {"groupMaxHarmonicCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness};
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxHarmonicCloseness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxHarmonicCloseness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxHarmonicCloseness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness(((struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxHarmonicCloseness", 0);

  /* "networkit/centrality.pyx":1746
 * 			The computed group.
 * 		"""
 * 		return (<_GroupHarmonicCloseness*>(self._this)).groupMaxHarmonicCloseness()             # <<<<<<<<<<<<<<
 * 
 * 	@staticmethod
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupHarmonicCloseness *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxHarmonicCloseness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1746, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1735
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
 * 
 * 	def groupMaxHarmonicCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxHarmonicCloseness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupHarmonicCloseness.groupMaxHarmonicCloseness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1748
 * 		return (<_GroupHarmonicCloseness*>(self._this)).groupMaxHarmonicCloseness()
 * 
 * 	@staticmethod             # <<<<<<<<<<<<<<
 * 	def scoreOfGroup(Graph graph, vector[node] inputGroup):
 * 		"""
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup(CYTHON_UNUSED 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_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup, "\n\t\tscoreOfGroup(Graph graph, vector[node] inputGroup)\n\t\t\n\t\tComputes the group-harmonic score of the input group.\n\n\t\tParameters\n\t\t----------\n\t\tgraph : networkit.Graph\n\t\t\tThe input graph.\n\t\tinputGroup : list(int)\n\t\t\tThe input group of nodes.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tThe group-harmonic score of the input group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup = {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup};
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup(CYTHON_UNUSED 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
) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_graph = 0;
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_inputGroup;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scoreOfGroup (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_graph,&__pyx_mstate_global->__pyx_n_u_inputGroup,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, 1748, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1748, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1748, __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, "scoreOfGroup", 0) < 0) __PYX_ERR(0, 1748, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 2, 2, i); __PYX_ERR(0, 1748, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 1748, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1748, __pyx_L3_error)
    }
    __pyx_v_graph = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_inputGroup = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1749, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scoreOfGroup", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1748, __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("networkit.centrality.GroupHarmonicCloseness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_graph), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "graph", 0))) __PYX_ERR(0, 1749, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup(__pyx_v_graph, __PYX_STD_MOVE_IF_SUPPORTED(__pyx_v_inputGroup));

  /* 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_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup(struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_graph, std::vector<__pyx_t_9networkit_10structures_node>  __pyx_v_inputGroup) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scoreOfGroup", 0);

  /* "networkit/centrality.pyx":1767
 * 			The group-harmonic score of the input group.
 * 		"""
 * 		return _GroupHarmonicCloseness.scoreOfGroup[vector[node].iterator](             # <<<<<<<<<<<<<<
 * 				graph._this, inputGroup.begin(), inputGroup.end())
 * 
*/
  __Pyx_XDECREF(__pyx_r);

  /* "networkit/centrality.pyx":1768
 * 		"""
 * 		return _GroupHarmonicCloseness.scoreOfGroup[vector[node].iterator](
 * 				graph._this, inputGroup.begin(), inputGroup.end())             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/GroupClosenessLocalSearch.hpp>":
*/
  try {
    __pyx_t_1 = NetworKit::GroupHarmonicCloseness::scoreOfGroup<std::vector<__pyx_t_9networkit_10structures_node> ::iterator>(__pyx_v_graph->_this, __pyx_v_inputGroup.begin(), __pyx_v_inputGroup.end());
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1767, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":1767
 * 			The group-harmonic score of the input group.
 * 		"""
 * 		return _GroupHarmonicCloseness.scoreOfGroup[vector[node].iterator](             # <<<<<<<<<<<<<<
 * 				graph._this, inputGroup.begin(), inputGroup.end())
 * 
*/
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1767, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1748
 * 		return (<_GroupHarmonicCloseness*>(self._this)).groupMaxHarmonicCloseness()
 * 
 * 	@staticmethod             # <<<<<<<<<<<<<<
 * 	def scoreOfGroup(Graph graph, vector[node] inputGroup):
 * 		"""
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupHarmonicCloseness.scoreOfGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupHarmonicCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22GroupHarmonicCloseness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupHarmonicCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1808
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink, maxIterations):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_group = 0;
  PyObject *__pyx_v_runGrowShrink = 0;
  PyObject *__pyx_v_maxIterations = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_group,&__pyx_mstate_global->__pyx_n_u_runGrowShrink,&__pyx_mstate_global->__pyx_n_u_maxIterations,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1808, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1808, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1808, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 4, 4, i); __PYX_ERR(0, 1808, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1808, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1808, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1808, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1808, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_group = values[1];
    __pyx_v_runGrowShrink = values[2];
    __pyx_v_maxIterations = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 1808, __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("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 0, "G", 0))) __PYX_ERR(0, 1808, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch___cinit__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self), __pyx_v_G, __pyx_v_group, __pyx_v_runGrowShrink, __pyx_v_maxIterations);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch___cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_runGrowShrink, PyObject *__pyx_v_maxIterations) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  bool __pyx_t_2;
  __pyx_t_9networkit_10structures_count __pyx_t_3;
  NetworKit::GroupClosenessLocalSearch *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1809
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink, maxIterations):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1810
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink, maxIterations):
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)             # <<<<<<<<<<<<<<
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink):
*/
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1810, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_runGrowShrink); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1810, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_maxIterations); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1810, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::GroupClosenessLocalSearch(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1810, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":1808
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink, maxIterations):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1812
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_group = 0;
  PyObject *__pyx_v_runGrowShrink = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_group,&__pyx_mstate_global->__pyx_n_u_runGrowShrink,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1812, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1812, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1812, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1812, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1812, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, i); __PYX_ERR(0, 1812, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1812, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1812, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1812, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_group = values[1];
    __pyx_v_runGrowShrink = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1812, __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("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 0, "G", 0))) __PYX_ERR(0, 1812, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_2__cinit__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self), __pyx_v_G, __pyx_v_group, __pyx_v_runGrowShrink);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_2__cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group, PyObject *__pyx_v_runGrowShrink) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  bool __pyx_t_2;
  NetworKit::GroupClosenessLocalSearch *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1813
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1814
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink):
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)             # <<<<<<<<<<<<<<
 * 
 * 	def __cinit__(self, Graph G not None, group):
*/
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1814, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_runGrowShrink); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1814, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::GroupClosenessLocalSearch(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1814, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1812
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink, maxIterations)
 * 
 * 	def __cinit__(self, Graph G not None, group, runGrowShrink):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1816
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)
 * 
 * 	def __cinit__(self, Graph G not None, group):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_5__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_5__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_group = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_group,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1816, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1816, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1816, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1816, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, i); __PYX_ERR(0, 1816, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1816, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1816, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_group = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1816, __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("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 0, "G", 0))) __PYX_ERR(0, 1816, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_4__cinit__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self), __pyx_v_G, __pyx_v_group);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_4__cinit__(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_group) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  NetworKit::GroupClosenessLocalSearch *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1817
 * 
 * 	def __cinit__(self, Graph G not None, group):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":1818
 * 	def __cinit__(self, Graph G not None, group):
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)             # <<<<<<<<<<<<<<
 * 
 * 	def groupMaxCloseness(self):
*/
  __pyx_t_1 = __pyx_convert_vector_from_py___pyx_t_9networkit_10structures_node(__pyx_v_group); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1818, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::GroupClosenessLocalSearch(__pyx_v_G->_this, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1818, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":1816
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group, runGrowShrink)
 * 
 * 	def __cinit__(self, Graph G not None, group):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1820
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness, "\n\t\tgroupMaxCloseness()\n\n\t\tReturns the computed group.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe computed group.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness = {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness};
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("groupMaxCloseness (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("groupMaxCloseness", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("groupMaxCloseness", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("groupMaxCloseness", 0);

  /* "networkit/centrality.pyx":1831
 * 			The computed group.
 * 		"""
 * 		return (<_GroupClosenessLocalSearch*>(self._this)).groupMaxCloseness()             # <<<<<<<<<<<<<<
 * 
 * 	def numberOfIterations(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessLocalSearch *)__pyx_v_self->__pyx_base.__pyx_base._this)->groupMaxCloseness();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1831, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1820
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.groupMaxCloseness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1833
 * 		return (<_GroupClosenessLocalSearch*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations, "\n\t\tnumberOfIterations()\n\n\t\tReturn the total number of iterations performed by the algorithm.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tTotal number of iterations performed by the algorithm.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations = {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations};
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("numberOfIterations (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("numberOfIterations", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("numberOfIterations", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("numberOfIterations", 0);

  /* "networkit/centrality.pyx":1844
 * 			Total number of iterations performed by the algorithm.
 * 		"""
 * 		return (<_GroupClosenessLocalSearch*>(self._this)).numberOfIterations()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::GroupClosenessLocalSearch *)__pyx_v_self->__pyx_base.__pyx_base._this)->numberOfIterations();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1844, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1833
 * 		return (<_GroupClosenessLocalSearch*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.numberOfIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_10__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.GroupClosenessLocalSearch.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_12__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25GroupClosenessLocalSearch_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.GroupClosenessLocalSearch.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1869
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, alpha=0.2, k=0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _KPathCentrality(G._this, alpha, k)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_15KPathCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_15KPathCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_k = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_alpha,&__pyx_mstate_global->__pyx_n_u_k,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1869, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1869, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1869, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1869, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1869, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_2));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 1869, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1869, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1869, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1869, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_2));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_alpha = values[1];
    __pyx_v_k = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1869, __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("networkit.centrality.KPathCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1869, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_15KPathCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_KPathCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_alpha, __pyx_v_k);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_15KPathCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_alpha, PyObject *__pyx_v_k) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  __pyx_t_9networkit_10structures_count __pyx_t_2;
  NetworKit::KPathCentrality *__pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1870
 * 
 * 	def __cinit__(self, Graph G, alpha=0.2, k=0):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _KPathCentrality(G._this, alpha, k)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":1871
 * 	def __cinit__(self, Graph G, alpha=0.2, k=0):
 * 		self._G = G
 * 		self._this = new _KPathCentrality(G._this, alpha, k)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/KatzCentrality.hpp>" namespace "NetworKit":
*/
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_alpha); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1871, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1871, __pyx_L1_error)
  try {
    __pyx_t_3 = new NetworKit::KPathCentrality(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1871, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_3;

  /* "networkit/centrality.pyx":1869
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, alpha=0.2, k=0):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _KPathCentrality(G._this, alpha, k)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KPathCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15KPathCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15KPathCentrality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15KPathCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15KPathCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_15KPathCentrality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_KPathCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15KPathCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KPathCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15KPathCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15KPathCentrality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15KPathCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15KPathCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.KPathCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_15KPathCentrality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_KPathCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15KPathCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KPathCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KPathCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1913
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, alpha=0, beta=0.1, tol=1e-8):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _KatzCentrality(G._this, alpha, beta, tol)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_14KatzCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_14KatzCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  PyObject *__pyx_v_tol = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_alpha,&__pyx_mstate_global->__pyx_n_u_beta,&__pyx_mstate_global->__pyx_n_u_tol,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1913, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1913, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1913, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1eneg_8));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 1913, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1913, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1913, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_0_1));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1eneg_8));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_alpha = values[1];
    __pyx_v_beta = values[2];
    __pyx_v_tol = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 1913, __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("networkit.centrality.KatzCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1913, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_14KatzCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_KatzCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_alpha, __pyx_v_beta, __pyx_v_tol);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_14KatzCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, PyObject *__pyx_v_tol) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  double __pyx_t_2;
  double __pyx_t_3;
  NetworKit::KatzCentrality *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1914
 * 
 * 	def __cinit__(self, Graph G, alpha=0, beta=0.1, tol=1e-8):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _KatzCentrality(G._this, alpha, beta, tol)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":1915
 * 	def __cinit__(self, Graph G, alpha=0, beta=0.1, tol=1e-8):
 * 		self._G = G
 * 		self._this = new _KatzCentrality(G._this, alpha, beta, tol)             # <<<<<<<<<<<<<<
 * 
 * 	property edgeDirection:
*/
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_alpha); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1915, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_beta); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1915, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_v_tol); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1915, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::KatzCentrality(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1915, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":1913
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, alpha=0, beta=0.1, tol=1e-8):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _KatzCentrality(G._this, alpha, beta, tol)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KatzCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1926
 * 		Default: networkit.centrality.EdgeDirection.IN_EDGES
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the used edge direction. """
 * 			return (<_KatzCentrality*>(self._this)).edgeDirection
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection___get__(((struct __pyx_obj_9networkit_10centrality_KatzCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection___get__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "networkit/centrality.pyx":1928
 * 		def __get__(self):
 * 			""" Get the used edge direction. """
 * 			return (<_KatzCentrality*>(self._this)).edgeDirection             # <<<<<<<<<<<<<<
 * 		def __set__(self, _EdgeDirection edgeDirection):
 * 			""" Use a different edge direction. """
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_EdgeDirection(((NetworKit::KatzCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->edgeDirection); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1926
 * 		Default: networkit.centrality.EdgeDirection.IN_EDGES
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the used edge direction. """
 * 			return (<_KatzCentrality*>(self._this)).edgeDirection
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.KatzCentrality.edgeDirection.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1929
 * 			""" Get the used edge direction. """
 * 			return (<_KatzCentrality*>(self._this)).edgeDirection
 * 		def __set__(self, _EdgeDirection edgeDirection):             # <<<<<<<<<<<<<<
 * 			""" Use a different edge direction. """
 * 			(<_KatzCentrality*>(self._this)).edgeDirection = edgeDirection
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_edgeDirection); /*proto*/
static int __pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_edgeDirection) {
  enum NetworKit::EdgeDirection __pyx_v_edgeDirection;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  assert(__pyx_arg_edgeDirection); {
    __pyx_v_edgeDirection = ((enum NetworKit::EdgeDirection)__Pyx_PyLong_As_enum__NetworKit_3a__3a_EdgeDirection(__pyx_arg_edgeDirection)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1929, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  __Pyx_AddTraceback("networkit.centrality.KatzCentrality.edgeDirection.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection_2__set__(((struct __pyx_obj_9networkit_10centrality_KatzCentrality *)__pyx_v_self), ((enum NetworKit::EdgeDirection)__pyx_v_edgeDirection));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_9networkit_10centrality_14KatzCentrality_13edgeDirection_2__set__(struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, enum NetworKit::EdgeDirection __pyx_v_edgeDirection) {
  int __pyx_r;

  /* "networkit/centrality.pyx":1931
 * 		def __set__(self, _EdgeDirection edgeDirection):
 * 			""" Use a different edge direction. """
 * 			(<_KatzCentrality*>(self._this)).edgeDirection = edgeDirection             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/DynKatzCentrality.hpp>":
*/
  ((NetworKit::KatzCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->edgeDirection = __pyx_v_edgeDirection;

  /* "networkit/centrality.pyx":1929
 * 			""" Get the used edge direction. """
 * 			return (<_KatzCentrality*>(self._this)).edgeDirection
 * 		def __set__(self, _EdgeDirection edgeDirection):             # <<<<<<<<<<<<<<
 * 			""" Use a different edge direction. """
 * 			(<_KatzCentrality*>(self._this)).edgeDirection = edgeDirection
*/

  /* function exit code */
  __pyx_r = 0;
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14KatzCentrality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14KatzCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_14KatzCentrality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_KatzCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KatzCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_14KatzCentrality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14KatzCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_14KatzCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.KatzCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_14KatzCentrality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_KatzCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_14KatzCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_KatzCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.KatzCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1959
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, k, groupOnly=False, tolerance=1e-9):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_17DynKatzCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_17DynKatzCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_k = 0;
  PyObject *__pyx_v_groupOnly = 0;
  PyObject *__pyx_v_tolerance = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_groupOnly,&__pyx_mstate_global->__pyx_n_u_tolerance,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1959, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1959, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1959, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1959, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1959, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 1959, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1eneg_9));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, i); __PYX_ERR(0, 1959, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1959, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1959, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1959, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1959, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_False));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_float_1eneg_9));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_k = values[1];
    __pyx_v_groupOnly = values[2];
    __pyx_v_tolerance = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 1959, __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("networkit.centrality.DynKatzCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 1959, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_k, __pyx_v_groupOnly, __pyx_v_tolerance);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_17DynKatzCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_k, PyObject *__pyx_v_groupOnly, PyObject *__pyx_v_tolerance) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  bool __pyx_t_2;
  double __pyx_t_3;
  NetworKit::DynKatzCentrality *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":1960
 * 
 * 	def __cinit__(self, Graph G, k, groupOnly=False, tolerance=1e-9):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":1961
 * 	def __cinit__(self, Graph G, k, groupOnly=False, tolerance=1e-9):
 * 		self._G = G
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)             # <<<<<<<<<<<<<<
 * 
 * 	def top(self, n=0):
*/
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_k); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1961, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_groupOnly); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1961, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_v_tolerance); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1961, __pyx_L1_error)
  try {
    __pyx_t_4 = new NetworKit::DynKatzCentrality(__pyx_v_G->_this, __pyx_t_1, __pyx_t_2, __pyx_t_3);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1961, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_4;

  /* "networkit/centrality.pyx":1959
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, k, groupOnly=False, tolerance=1e-9):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1963
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
 * 
 * 	def top(self, n=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		top(n=0)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_3top(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17DynKatzCentrality_2top, " \n\t\ttop(n=0)\n\t\t\n\t\tReturns the top n nodes.\n\n\t\tParameters\n\t\t----------\n\t\tn : int, optional\n\t\t\tIf set, retrieve n top-nodes. If not set, all nodes are retrieved. Default: 0\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tList of nodes with top-n centrality-scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17DynKatzCentrality_3top = {"top", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_3top, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_2top};
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_3top(PyObject *__pyx_v_self, 
#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_n = 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("top (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_n,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, 1963, __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, 1963, __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, "top", 0) < 0) __PYX_ERR(0, 1963, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1963, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_0));
    }
    __pyx_v_n = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("top", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1963, __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("networkit.centrality.DynKatzCentrality.top", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality_2top(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self), __pyx_v_n);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_2top(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  __pyx_t_9networkit_10structures_node __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("top", 0);

  /* "networkit/centrality.pyx":1979
 * 			List of nodes with top-n centrality-scores.
 * 		"""
 * 		return (<_DynKatzCentrality*>(self._this)).top(n)             # <<<<<<<<<<<<<<
 * 
 * 	def bound(self, v):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_n); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1979, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynKatzCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->top(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1979, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyLong_From_uint64_t(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1979, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1963
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
 * 
 * 	def top(self, n=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		top(n=0)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.top", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1981
 * 		return (<_DynKatzCentrality*>(self._this)).top(n)
 * 
 * 	def bound(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		bound(v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_5bound(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17DynKatzCentrality_4bound, " \n\t\tbound(v)\n\t\t\n\t\tReturns the (upper) bound of the centrality of node `v`.\n\n\t\tParameters\n\t\t----------\n\t\tv : int\n\t\t\tNode in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tUpper bound of node `v`.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17DynKatzCentrality_5bound = {"bound", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_5bound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_4bound};
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_5bound(PyObject *__pyx_v_self, 
#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_v = 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("bound (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_v,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, 1981, __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, 1981, __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, "bound", 0) < 0) __PYX_ERR(0, 1981, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bound", 1, 1, 1, i); __PYX_ERR(0, 1981, __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, 1981, __pyx_L3_error)
    }
    __pyx_v_v = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("bound", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1981, __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("networkit.centrality.DynKatzCentrality.bound", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality_4bound(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_4bound(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  double __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("bound", 0);

  /* "networkit/centrality.pyx":1997
 * 			Upper bound of node `v`.
 * 		"""
 * 		return (<_DynKatzCentrality*>(self._this)).bound(v)             # <<<<<<<<<<<<<<
 * 
 * 	def areDistinguished(self, u, v):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1997, __pyx_L1_error)
  try {
    __pyx_t_2 = ((NetworKit::DynKatzCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->bound(__pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 1997, __pyx_L1_error)
  }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1997, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1981
 * 		return (<_DynKatzCentrality*>(self._this)).top(n)
 * 
 * 	def bound(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		bound(v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.bound", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":1999
 * 		return (<_DynKatzCentrality*>(self._this)).bound(v)
 * 
 * 	def areDistinguished(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		areDistinguished(u, v)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_7areDistinguished(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17DynKatzCentrality_6areDistinguished, " \n\t\tareDistinguished(u, v)\n\t\t\n\t\tReturns true if the bounds are sharp enough to rank two nodes against each other.\n\n\t\tParameters\n\t\t----------\n\t\tu : int\n\t\t\tNode in the graph.\n\t\tv : int\n\t\t\tNode in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tbool\n\t\t\tTrue if the bounds are sharp enough to rank two nodes against each other.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17DynKatzCentrality_7areDistinguished = {"areDistinguished", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_7areDistinguished, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_6areDistinguished};
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_7areDistinguished(PyObject *__pyx_v_self, 
#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_u = 0;
  PyObject *__pyx_v_v = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("areDistinguished (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_u,&__pyx_mstate_global->__pyx_n_u_v,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, 1999, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1999, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1999, __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, "areDistinguished", 0) < 0) __PYX_ERR(0, 1999, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("areDistinguished", 1, 2, 2, i); __PYX_ERR(0, 1999, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 1999, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1999, __pyx_L3_error)
    }
    __pyx_v_u = values[0];
    __pyx_v_v = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("areDistinguished", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1999, __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("networkit.centrality.DynKatzCentrality.areDistinguished", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality_6areDistinguished(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self), __pyx_v_u, __pyx_v_v);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_6areDistinguished(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, PyObject *__pyx_v_u, PyObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_node __pyx_t_1;
  __pyx_t_9networkit_10structures_node __pyx_t_2;
  bool __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("areDistinguished", 0);

  /* "networkit/centrality.pyx":2017
 * 			True if the bounds are sharp enough to rank two nodes against each other.
 * 		"""
 * 		return (<_DynKatzCentrality*>(self._this)).areDistinguished(u, v)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/LocalClusteringCoefficient.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_As_uint64_t(__pyx_v_u); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2017, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyLong_As_uint64_t(__pyx_v_v); if (unlikely((__pyx_t_2 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2017, __pyx_L1_error)
  try {
    __pyx_t_3 = ((NetworKit::DynKatzCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->areDistinguished(__pyx_t_1, __pyx_t_2);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2017, __pyx_L1_error)
  }
  __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":1999
 * 		return (<_DynKatzCentrality*>(self._this)).bound(v)
 * 
 * 	def areDistinguished(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		areDistinguished(u, v)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.areDistinguished", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.DynKatzCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17DynKatzCentrality_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17DynKatzCentrality_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_DynKatzCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.DynKatzCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2046
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t turbo = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LocalClusteringCoefficient(G._this, turbo)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  bool __pyx_v_turbo;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_turbo,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2046, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2046, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2046, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2046, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 2046, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2046, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2046, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_turbo = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_turbo == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2046, __pyx_L3_error)
    } else {
      __pyx_v_turbo = ((bool)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2046, __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("networkit.centrality.LocalClusteringCoefficient.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2046, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient___cinit__(((struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *)__pyx_v_self), __pyx_v_G, __pyx_v_turbo);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient___cinit__(struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_turbo) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::LocalClusteringCoefficient *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2047
 * 
 * 	def __cinit__(self, Graph G, bool_t turbo = False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _LocalClusteringCoefficient(G._this, turbo)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2048
 * 	def __cinit__(self, Graph G, bool_t turbo = False):
 * 		self._G = G
 * 		self._this = new _LocalClusteringCoefficient(G._this, turbo)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/LocalSquareClusteringCoefficient.hpp>":
*/
  try {
    __pyx_t_1 = new NetworKit::LocalClusteringCoefficient(__pyx_v_G->_this, __pyx_v_turbo);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2048, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2046
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t turbo = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LocalClusteringCoefficient(G._this, turbo)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalClusteringCoefficient.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalClusteringCoefficient.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.LocalClusteringCoefficient.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_26LocalClusteringCoefficient_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalClusteringCoefficient.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2068
 * 	"""
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LocalSquareClusteringCoefficient(G._this)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2068, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2068, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2068, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, i); __PYX_ERR(0, 2068, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2068, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2068, __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("networkit.centrality.LocalSquareClusteringCoefficient.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2068, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient___cinit__(((struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *)__pyx_v_self), __pyx_v_G);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient___cinit__(struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::LocalSquareClusteringCoefficient *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2069
 * 
 * 	def __cinit__(self, Graph G):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _LocalSquareClusteringCoefficient(G._this)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2070
 * 	def __cinit__(self, Graph G):
 * 		self._G = G
 * 		self._this = new _LocalSquareClusteringCoefficient(G._this)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  try {
    __pyx_t_1 = new NetworKit::LocalSquareClusteringCoefficient(__pyx_v_G->_this);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2070, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2068
 * 	"""
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LocalSquareClusteringCoefficient(G._this)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalSquareClusteringCoefficient.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalSquareClusteringCoefficient.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.LocalSquareClusteringCoefficient.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_32LocalSquareClusteringCoefficient_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LocalSquareClusteringCoefficient.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2091
 * 	"""
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _Sfigality(G._this)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_9Sfigality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_9Sfigality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2091, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2091, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2091, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, i); __PYX_ERR(0, 2091, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2091, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2091, __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("networkit.centrality.Sfigality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2091, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_9Sfigality___cinit__(((struct __pyx_obj_9networkit_10centrality_Sfigality *)__pyx_v_self), __pyx_v_G);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_9Sfigality___cinit__(struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::Sfigality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2092
 * 
 * 	def __cinit__(self, Graph G):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _Sfigality(G._this)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2093
 * 	def __cinit__(self, Graph G):
 * 		self._G = G
 * 		self._this = new _Sfigality(G._this)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/PermanenceCentrality.hpp>":
*/
  try {
    __pyx_t_1 = new NetworKit::Sfigality(__pyx_v_G->_this);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2093, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2091
 * 	"""
 * 
 * 	def __cinit__(self, Graph G):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _Sfigality(G._this)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Sfigality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_9Sfigality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_9Sfigality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Sfigality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_9Sfigality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_9Sfigality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_Sfigality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_9Sfigality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Sfigality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_9Sfigality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_9Sfigality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Sfigality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_9Sfigality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.Sfigality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_9Sfigality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_Sfigality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_9Sfigality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_Sfigality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.Sfigality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2121
 * 	cdef Partition _P
 * 
 * 	def __cinit__(self, Graph G, Partition P):             # <<<<<<<<<<<<<<
 * 		self._this = new _PermanenceCentrality(G._this, P._this)
 * 		self._G = G
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_20PermanenceCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_20PermanenceCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_P,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2121, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2121, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2121, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2121, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, i); __PYX_ERR(0, 2121, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2121, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2121, __pyx_L3_error)
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_P = ((struct __pyx_obj_9networkit_10structures_Partition *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2121, __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("networkit.centrality.PermanenceCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2121, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_P), __pyx_mstate_global->__pyx_ptype_9networkit_10structures_Partition, 1, "P", 0))) __PYX_ERR(0, 2121, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_20PermanenceCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_P);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_20PermanenceCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, struct __pyx_obj_9networkit_10structures_Partition *__pyx_v_P) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::PermanenceCentrality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2122
 * 
 * 	def __cinit__(self, Graph G, Partition P):
 * 		self._this = new _PermanenceCentrality(G._this, P._this)             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._P = P
*/
  try {
    __pyx_t_1 = new NetworKit::PermanenceCentrality(__pyx_v_G->_this, __pyx_v_P->_this);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2122, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2123
 * 	def __cinit__(self, Graph G, Partition P):
 * 		self._this = new _PermanenceCentrality(G._this, P._this)
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._P = P
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":2124
 * 		self._this = new _PermanenceCentrality(G._this, P._this)
 * 		self._G = G
 * 		self._P = P             # <<<<<<<<<<<<<<
 * 
 * 	def getIntraClustering(self, node u):
*/
  __Pyx_INCREF((PyObject *)__pyx_v_P);
  __Pyx_GIVEREF((PyObject *)__pyx_v_P);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_P);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_P);
  __pyx_v_self->_P = __pyx_v_P;

  /* "networkit/centrality.pyx":2121
 * 	cdef Partition _P
 * 
 * 	def __cinit__(self, Graph G, Partition P):             # <<<<<<<<<<<<<<
 * 		self._this = new _PermanenceCentrality(G._this, P._this)
 * 		self._G = G
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PermanenceCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2126
 * 		self._P = P
 * 
 * 	def getIntraClustering(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getIntraClustering(u)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering, " \n\t\tgetIntraClustering(u)\n\t\t\n\t\tReturns intra clustering for node u.\n\n\t\tParameters\n\t\t----------\n\t\tu : int\n\t\t\tNode in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tIntra clustering value for node u.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering = {"getIntraClustering", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering};
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __pyx_t_9networkit_10structures_node __pyx_v_u;
  #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("getIntraClustering (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_u,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, 2126, __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, 2126, __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, "getIntraClustering", 0) < 0) __PYX_ERR(0, 2126, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("getIntraClustering", 1, 1, 1, i); __PYX_ERR(0, 2126, __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, 2126, __pyx_L3_error)
    }
    __pyx_v_u = __Pyx_PyLong_As_uint64_t(values[0]); if (unlikely((__pyx_v_u == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2126, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getIntraClustering", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2126, __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("networkit.centrality.PermanenceCentrality.getIntraClustering", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering(((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)__pyx_v_self), __pyx_v_u);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, __pyx_t_9networkit_10structures_node __pyx_v_u) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIntraClustering", 0);

  /* "networkit/centrality.pyx":2142
 * 			Intra clustering value for node u.
 * 		"""
 * 		return (<_PermanenceCentrality*>(self._this)).getIntraClustering(u)             # <<<<<<<<<<<<<<
 * 
 * 	def getPermanence(self, node u):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::PermanenceCentrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->getIntraClustering(__pyx_v_u);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2142, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2126
 * 		self._P = P
 * 
 * 	def getIntraClustering(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getIntraClustering(u)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.PermanenceCentrality.getIntraClustering", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2144
 * 		return (<_PermanenceCentrality*>(self._this)).getIntraClustering(u)
 * 
 * 	def getPermanence(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPermanence(u)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_5getPermanence(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_20PermanenceCentrality_4getPermanence, " \n\t\tgetPermanence(u)\n\t\t\n\t\tReturns permanence centrality for node u.\n\n\t\tParameters\n\t\t----------\n\t\tu : int\n\t\t\tNode in the graph.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tPermanence centrality value for node u.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_20PermanenceCentrality_5getPermanence = {"getPermanence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_5getPermanence, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20PermanenceCentrality_4getPermanence};
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_5getPermanence(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __pyx_t_9networkit_10structures_node __pyx_v_u;
  #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("getPermanence (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_u,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, 2144, __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, 2144, __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, "getPermanence", 0) < 0) __PYX_ERR(0, 2144, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("getPermanence", 1, 1, 1, i); __PYX_ERR(0, 2144, __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, 2144, __pyx_L3_error)
    }
    __pyx_v_u = __Pyx_PyLong_As_uint64_t(values[0]); if (unlikely((__pyx_v_u == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2144, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getPermanence", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2144, __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("networkit.centrality.PermanenceCentrality.getPermanence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20PermanenceCentrality_4getPermanence(((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)__pyx_v_self), __pyx_v_u);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_4getPermanence(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, __pyx_t_9networkit_10structures_node __pyx_v_u) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  double __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPermanence", 0);

  /* "networkit/centrality.pyx":2160
 * 			Permanence centrality value for node u.
 * 		"""
 * 		return (<_PermanenceCentrality*>(self._this)).getPermanence(u)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::PermanenceCentrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->getPermanence(__pyx_v_u);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2160, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2144
 * 		return (<_PermanenceCentrality*>(self._this)).getIntraClustering(u)
 * 
 * 	def getPermanence(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPermanence(u)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.PermanenceCentrality.getPermanence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_20PermanenceCentrality_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PermanenceCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.PermanenceCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_20PermanenceCentrality_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_20PermanenceCentrality_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PermanenceCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2189
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LaplacianCentrality(G._this, normalized)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_19LaplacianCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_19LaplacianCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2189, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2189, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2189, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2189, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 2189, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2189, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2189, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_False));
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_normalized = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2189, __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("networkit.centrality.LaplacianCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2189, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_19LaplacianCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_19LaplacianCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_normalized) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  NetworKit::LaplacianCentrality *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2190
 * 
 * 	def __cinit__(self, Graph G, normalized = False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _LaplacianCentrality(G._this, normalized)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2191
 * 	def __cinit__(self, Graph G, normalized = False):
 * 		self._G = G
 * 		self._this = new _LaplacianCentrality(G._this, normalized)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/CoreDecomposition.hpp>":
*/
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalized); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2191, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::LaplacianCentrality(__pyx_v_G->_this, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2191, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":2189
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, normalized = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _LaplacianCentrality(G._this, normalized)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LaplacianCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_19LaplacianCentrality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_19LaplacianCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LaplacianCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.LaplacianCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_19LaplacianCentrality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_19LaplacianCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_LaplacianCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.LaplacianCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2222
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t enforceBucketQueueAlgorithm=False, bool_t storeNodeOrder = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_17CoreDecomposition_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_17CoreDecomposition_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  bool __pyx_v_normalized;
  bool __pyx_v_enforceBucketQueueAlgorithm;
  bool __pyx_v_storeNodeOrder;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_enforceBucketQueueAlgorithm,&__pyx_mstate_global->__pyx_n_u_storeNodeOrder,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2222, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2222, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2222, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 2222, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2222, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2222, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_normalized = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_normalized == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2222, __pyx_L3_error)
    } else {
      __pyx_v_normalized = ((bool)0);
    }
    if (values[2]) {
      __pyx_v_enforceBucketQueueAlgorithm = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_enforceBucketQueueAlgorithm == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2222, __pyx_L3_error)
    } else {
      __pyx_v_enforceBucketQueueAlgorithm = ((bool)0);
    }
    if (values[3]) {
      __pyx_v_storeNodeOrder = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_storeNodeOrder == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2222, __pyx_L3_error)
    } else {
      __pyx_v_storeNodeOrder = ((bool)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 2222, __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("networkit.centrality.CoreDecomposition.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2222, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition___cinit__(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self), __pyx_v_G, __pyx_v_normalized, __pyx_v_enforceBucketQueueAlgorithm, __pyx_v_storeNodeOrder);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_17CoreDecomposition___cinit__(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, bool __pyx_v_normalized, bool __pyx_v_enforceBucketQueueAlgorithm, bool __pyx_v_storeNodeOrder) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::CoreDecomposition *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2223
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t enforceBucketQueueAlgorithm=False, bool_t storeNodeOrder = False):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2224
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t enforceBucketQueueAlgorithm=False, bool_t storeNodeOrder = False):
 * 		self._G = G
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)             # <<<<<<<<<<<<<<
 * 
 * 	def maxCoreNumber(self):
*/
  try {
    __pyx_t_1 = new NetworKit::CoreDecomposition(__pyx_v_G->_this, __pyx_v_normalized, __pyx_v_enforceBucketQueueAlgorithm, __pyx_v_storeNodeOrder);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2224, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2222
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, bool_t normalized=False, bool_t enforceBucketQueueAlgorithm=False, bool_t storeNodeOrder = False):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2226
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
 * 
 * 	def maxCoreNumber(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maxCoreNumber()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber, " \n\t\tmaxCoreNumber()\n\n\t\tGet maximum core number.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tThe maximum core number.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber = {"maxCoreNumber", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("maxCoreNumber (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("maxCoreNumber", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("maxCoreNumber", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_index __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("maxCoreNumber", 0);

  /* "networkit/centrality.pyx":2237
 * 			The maximum core number.
 * 		"""
 * 		return (<_CoreDecomposition*>(self._this)).maxCoreNumber()             # <<<<<<<<<<<<<<
 * 
 * 	def getCover(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::CoreDecomposition *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->maxCoreNumber();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2237, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2226
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
 * 
 * 	def maxCoreNumber(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maxCoreNumber()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.maxCoreNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2239
 * 		return (<_CoreDecomposition*>(self._this)).maxCoreNumber()
 * 
 * 	def getCover(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getCover()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_5getCover(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17CoreDecomposition_4getCover, " \n\t\tgetCover()\n\t\t\n\t\tGet the k-cores as cover.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe k-cores as sets of nodes, indexed by k.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_5getCover = {"getCover", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_5getCover, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_4getCover};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_5getCover(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCover (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getCover", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getCover", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_4getCover(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_4getCover(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  NetworKit::Cover __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCover", 0);

  /* "networkit/centrality.pyx":2250
 * 			The k-cores as sets of nodes, indexed by k.
 * 		"""
 * 		return Cover().setThis((<_CoreDecomposition*>(self._this)).getCover())             # <<<<<<<<<<<<<<
 * 
 * 	def getPartition(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10structures_Cover);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10structures_Cover); 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2250, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  try {
    __pyx_t_5 = ((NetworKit::CoreDecomposition *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getCover();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2250, __pyx_L1_error)
  }
  __pyx_t_3 = ((struct __pyx_vtabstruct_9networkit_10structures_Cover *)((struct __pyx_obj_9networkit_10structures_Cover *)__pyx_t_1)->__pyx_vtab)->setThis(((struct __pyx_obj_9networkit_10structures_Cover *)__pyx_t_1), __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2239
 * 		return (<_CoreDecomposition*>(self._this)).maxCoreNumber()
 * 
 * 	def getCover(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getCover()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.getCover", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2252
 * 		return Cover().setThis((<_CoreDecomposition*>(self._this)).getCover())
 * 
 * 	def getPartition(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPartition()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_7getPartition(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17CoreDecomposition_6getPartition, " \n\t\tgetPartition()\n\t\t\n\t\tGet the k-shells as a partition object.\n\n\t\tReturns\n\t\t-------\n\t\tnetworkit.Partition\n\t\t\tThe k-shells.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_7getPartition = {"getPartition", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_7getPartition, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_6getPartition};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_7getPartition(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPartition (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getPartition", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getPartition", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_6getPartition(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_6getPartition(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  NetworKit::Partition __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPartition", 0);

  /* "networkit/centrality.pyx":2263
 * 			The k-shells.
 * 		"""
 * 		return Partition().setThis((<_CoreDecomposition*>(self._this)).getPartition())             # <<<<<<<<<<<<<<
 * 
 * 	def getNodeOrder(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10structures_Partition);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10structures_Partition); 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2263, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  try {
    __pyx_t_5 = ((NetworKit::CoreDecomposition *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getPartition();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2263, __pyx_L1_error)
  }
  __pyx_t_3 = ((struct __pyx_vtabstruct_9networkit_10structures_Partition *)((struct __pyx_obj_9networkit_10structures_Partition *)__pyx_t_1)->__pyx_vtab)->setThis(((struct __pyx_obj_9networkit_10structures_Partition *)__pyx_t_1), __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2263, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2252
 * 		return Cover().setThis((<_CoreDecomposition*>(self._this)).getCover())
 * 
 * 	def getPartition(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPartition()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.getPartition", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2265
 * 		return Partition().setThis((<_CoreDecomposition*>(self._this)).getPartition())
 * 
 * 	def getNodeOrder(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNodeOrder()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_9getNodeOrder(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_17CoreDecomposition_8getNodeOrder, "\n\t\tgetNodeOrder()\n\n\t\tGet the node order. This is only possible when storeNodeOrder was set.\n\n\t\tReturns\n\t\t-------\n\t\tlist(int)\n\t\t\tThe nodes sorted by increasing core number.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_9getNodeOrder = {"getNodeOrder", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_9getNodeOrder, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_8getNodeOrder};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_9getNodeOrder(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNodeOrder (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getNodeOrder", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getNodeOrder", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_8getNodeOrder(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_8getNodeOrder(struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNodeOrder", 0);

  /* "networkit/centrality.pyx":2276
 * 			The nodes sorted by increasing core number.
 * 		"""
 * 		return (<_CoreDecomposition*>(self._this)).getNodeOrder()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/EigenvectorCentrality.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::CoreDecomposition *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getNodeOrder();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2276, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2265
 * 		return Partition().setThis((<_CoreDecomposition*>(self._this)).getPartition())
 * 
 * 	def getNodeOrder(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNodeOrder()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.getNodeOrder", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_10__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.CoreDecomposition.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_17CoreDecomposition_12__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_CoreDecomposition *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_17CoreDecomposition_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_CoreDecomposition *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.CoreDecomposition.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2300
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double tol=1e-9):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _EigenvectorCentrality(G._this, tol)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_21EigenvectorCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_21EigenvectorCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  double __pyx_v_tol;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_tol,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2300, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2300, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2300, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 2300, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2300, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_tol = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_tol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2300, __pyx_L3_error)
    } else {
      __pyx_v_tol = ((double)1e-9);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2300, __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("networkit.centrality.EigenvectorCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2300, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_21EigenvectorCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_tol);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_21EigenvectorCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_tol) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::EigenvectorCentrality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2301
 * 
 * 	def __cinit__(self, Graph G, double tol=1e-9):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _EigenvectorCentrality(G._this, tol)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2302
 * 	def __cinit__(self, Graph G, double tol=1e-9):
 * 		self._G = G
 * 		self._this = new _EigenvectorCentrality(G._this, tol)             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/PageRank.hpp>" namespace "NetworKit::PageRank":
*/
  try {
    __pyx_t_1 = new NetworKit::EigenvectorCentrality(__pyx_v_G->_this, __pyx_v_tol);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2302, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2300
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double tol=1e-9):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _EigenvectorCentrality(G._this, tol)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EigenvectorCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_21EigenvectorCentrality_2__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21EigenvectorCentrality_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EigenvectorCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.EigenvectorCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_21EigenvectorCentrality_4__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_21EigenvectorCentrality_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.EigenvectorCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2370
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double damp=0.85, double tol=1e-8, bool_t normalized=False, distributeSinks=SinkHandling.NO_SINK_HANDLING):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_8PageRank_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_8PageRank_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  double __pyx_v_damp;
  double __pyx_v_tol;
  bool __pyx_v_normalized;
  PyObject *__pyx_v_distributeSinks = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[5] = {0,0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_damp,&__pyx_mstate_global->__pyx_n_u_tol,&__pyx_mstate_global->__pyx_n_u_normalized,&__pyx_mstate_global->__pyx_n_u_distributeSinks,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2370, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2370, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2370, __pyx_L3_error)
      if (!values[4]) values[4] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__4);
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 5, i); __PYX_ERR(0, 2370, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2370, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2370, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[4]) values[4] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__4);
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_damp = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_damp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error)
    } else {
      __pyx_v_damp = ((double)0.85);
    }
    if (values[2]) {
      __pyx_v_tol = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_tol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error)
    } else {
      __pyx_v_tol = ((double)1e-8);
    }
    if (values[3]) {
      __pyx_v_normalized = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_normalized == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error)
    } else {
      __pyx_v_normalized = ((bool)0);
    }
    __pyx_v_distributeSinks = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 5, __pyx_nargs); __PYX_ERR(0, 2370, __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("networkit.centrality.PageRank.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2370, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank___cinit__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self), __pyx_v_G, __pyx_v_damp, __pyx_v_tol, __pyx_v_normalized, __pyx_v_distributeSinks);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_8PageRank___cinit__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_damp, double __pyx_v_tol, bool __pyx_v_normalized, PyObject *__pyx_v_distributeSinks) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  enum NetworKit::PageRank::SinkHandling __pyx_t_1;
  NetworKit::PageRank *__pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2371
 * 
 * 	def __cinit__(self, Graph G, double damp=0.85, double tol=1e-8, bool_t normalized=False, distributeSinks=SinkHandling.NO_SINK_HANDLING):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2372
 * 	def __cinit__(self, Graph G, double damp=0.85, double tol=1e-8, bool_t normalized=False, distributeSinks=SinkHandling.NO_SINK_HANDLING):
 * 		self._G = G
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)             # <<<<<<<<<<<<<<
 * 
 * 	def numberOfIterations(self):
*/
  __pyx_t_1 = ((enum NetworKit::PageRank::SinkHandling)__Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(__pyx_v_distributeSinks)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2372, __pyx_L1_error)
  try {
    __pyx_t_2 = new NetworKit::PageRank(__pyx_v_G->_this, __pyx_v_damp, __pyx_v_tol, __pyx_v_normalized, __pyx_t_1);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2372, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_2;

  /* "networkit/centrality.pyx":2370
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double damp=0.85, double tol=1e-8, bool_t normalized=False, distributeSinks=SinkHandling.NO_SINK_HANDLING):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PageRank.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2374
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_3numberOfIterations(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_8PageRank_2numberOfIterations, "\n\t\tnumberOfIterations()\n\n\t\tReturns the number of iterations performed by the algorithm.\n\n\t\tReturns\n\t\t-------\n\t\tint\n\t\t\tNumber of iterations performed by the algorithm. Default: unlimited\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_8PageRank_3numberOfIterations = {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_3numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_8PageRank_2numberOfIterations};
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_3numberOfIterations(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("numberOfIterations (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("numberOfIterations", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("numberOfIterations", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_2numberOfIterations(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_2numberOfIterations(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __pyx_t_9networkit_10structures_count __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("numberOfIterations", 0);

  /* "networkit/centrality.pyx":2385
 * 			Number of iterations performed by the algorithm. Default: unlimited
 * 		"""
 * 		return (<_PageRank*>(self._this)).numberOfIterations()             # <<<<<<<<<<<<<<
 * 
 * 	property norm:
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::PageRank *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->numberOfIterations();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2385, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyLong_From_uint64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2385, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2374
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.PageRank.numberOfIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2397
 * 		Default: networkit.centrality.Norm.L2_NORM
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the norm used as stopping criterion. """
 * 			return (<_PageRank*>(self._this)).norm
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_4norm_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_4norm_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_4norm___get__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_4norm___get__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "networkit/centrality.pyx":2399
 * 		def __get__(self):
 * 			""" Get the norm used as stopping criterion. """
 * 			return (<_PageRank*>(self._this)).norm             # <<<<<<<<<<<<<<
 * 		def __set__(self, _Norm norm):
 * 			""" Set the norm used as stopping criterion. """
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(((NetworKit::PageRank *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->norm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2397
 * 		Default: networkit.centrality.Norm.L2_NORM
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the norm used as stopping criterion. """
 * 			return (<_PageRank*>(self._this)).norm
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.PageRank.norm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2400
 * 			""" Get the norm used as stopping criterion. """
 * 			return (<_PageRank*>(self._this)).norm
 * 		def __set__(self, _Norm norm):             # <<<<<<<<<<<<<<
 * 			""" Set the norm used as stopping criterion. """
 * 			(<_PageRank*>(self._this)).norm = norm
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_8PageRank_4norm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_norm); /*proto*/
static int __pyx_pw_9networkit_10centrality_8PageRank_4norm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_norm) {
  enum NetworKit::PageRank::Norm __pyx_v_norm;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  assert(__pyx_arg_norm); {
    __pyx_v_norm = ((enum NetworKit::PageRank::Norm)__Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(__pyx_arg_norm)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2400, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  __Pyx_AddTraceback("networkit.centrality.PageRank.norm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_4norm_2__set__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self), ((enum NetworKit::PageRank::Norm)__pyx_v_norm));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_9networkit_10centrality_8PageRank_4norm_2__set__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, enum NetworKit::PageRank::Norm __pyx_v_norm) {
  int __pyx_r;

  /* "networkit/centrality.pyx":2402
 * 		def __set__(self, _Norm norm):
 * 			""" Set the norm used as stopping criterion. """
 * 			(<_PageRank*>(self._this)).norm = norm             # <<<<<<<<<<<<<<
 * 
 * 	property maxIterations:
*/
  ((NetworKit::PageRank *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->norm = __pyx_v_norm;

  /* "networkit/centrality.pyx":2400
 * 			""" Get the norm used as stopping criterion. """
 * 			return (<_PageRank*>(self._this)).norm
 * 		def __set__(self, _Norm norm):             # <<<<<<<<<<<<<<
 * 			""" Set the norm used as stopping criterion. """
 * 			(<_PageRank*>(self._this)).norm = norm
*/

  /* function exit code */
  __pyx_r = 0;
  return __pyx_r;
}

/* "networkit/centrality.pyx":2409
 * 		of runs. Default: unlimited
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the maximum number of iterations. """
 * 			return (<_PageRank*>(self._this)).maxIterations
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_13maxIterations___get__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_13maxIterations___get__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "networkit/centrality.pyx":2411
 * 		def __get__(self):
 * 			""" Get the maximum number of iterations. """
 * 			return (<_PageRank*>(self._this)).maxIterations             # <<<<<<<<<<<<<<
 * 		def __set__(self, maxIterations):
 * 			""" Set the maximum number of iterations. """
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_uint64_t(((NetworKit::PageRank *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->maxIterations); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2409
 * 		of runs. Default: unlimited
 * 		"""
 * 		def __get__(self):             # <<<<<<<<<<<<<<
 * 			""" Get the maximum number of iterations. """
 * 			return (<_PageRank*>(self._this)).maxIterations
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.PageRank.maxIterations.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2412
 * 			""" Get the maximum number of iterations. """
 * 			return (<_PageRank*>(self._this)).maxIterations
 * 		def __set__(self, maxIterations):             # <<<<<<<<<<<<<<
 * 			""" Set the maximum number of iterations. """
 * 			if maxIterations < 0:
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_maxIterations); /*proto*/
static int __pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_maxIterations) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_13maxIterations_2__set__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self), ((PyObject *)__pyx_v_maxIterations));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_9networkit_10centrality_8PageRank_13maxIterations_2__set__(struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, PyObject *__pyx_v_maxIterations) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  __pyx_t_9networkit_10structures_count __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "networkit/centrality.pyx":2414
 * 		def __set__(self, maxIterations):
 * 			""" Set the maximum number of iterations. """
 * 			if maxIterations < 0:             # <<<<<<<<<<<<<<
 * 				raise Exception("Max iterations cannot be a negative number.")
 * 			(<_PageRank*>(self._this)).maxIterations = maxIterations
*/
  __pyx_t_1 = PyObject_RichCompare(__pyx_v_maxIterations, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2414, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_2)) {

    /* "networkit/centrality.pyx":2415
 * 			""" Set the maximum number of iterations. """
 * 			if maxIterations < 0:
 * 				raise Exception("Max iterations cannot be a negative number.")             # <<<<<<<<<<<<<<
 * 			(<_PageRank*>(self._this)).maxIterations = maxIterations
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Max_iterations_cannot_be_a_negat};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__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_1)) __PYX_ERR(0, 2415, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 2415, __pyx_L1_error)

    /* "networkit/centrality.pyx":2414
 * 		def __set__(self, maxIterations):
 * 			""" Set the maximum number of iterations. """
 * 			if maxIterations < 0:             # <<<<<<<<<<<<<<
 * 				raise Exception("Max iterations cannot be a negative number.")
 * 			(<_PageRank*>(self._this)).maxIterations = maxIterations
*/
  }

  /* "networkit/centrality.pyx":2416
 * 			if maxIterations < 0:
 * 				raise Exception("Max iterations cannot be a negative number.")
 * 			(<_PageRank*>(self._this)).maxIterations = maxIterations             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_t_6 = __Pyx_PyLong_As_uint64_t(__pyx_v_maxIterations); if (unlikely((__pyx_t_6 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2416, __pyx_L1_error)
  ((NetworKit::PageRank *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->maxIterations = __pyx_t_6;

  /* "networkit/centrality.pyx":2412
 * 			""" Get the maximum number of iterations. """
 * 			return (<_PageRank*>(self._this)).maxIterations
 * 		def __set__(self, maxIterations):             # <<<<<<<<<<<<<<
 * 			""" Set the maximum number of iterations. """
 * 			if maxIterations < 0:
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.PageRank.maxIterations.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_8PageRank_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PageRank.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_8PageRank_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_8PageRank_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.PageRank.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8PageRank_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_PageRank *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8PageRank_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_PageRank *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.PageRank.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2443
 * 
 * 	cdef Graph _G
 * 	def __cinit__(self,  Graph G, double tol = 0.1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  double __pyx_v_tol;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_tol,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2443, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2443, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2443, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2443, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 2443, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2443, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2443, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_tol = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_tol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2443, __pyx_L3_error)
    } else {
      __pyx_v_tol = ((double)0.1);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2443, __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("networkit.centrality.SpanningEdgeCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2443, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_tol);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_tol) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::SpanningEdgeCentrality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2444
 * 	cdef Graph _G
 * 	def __cinit__(self,  Graph G, double tol = 0.1):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":2445
 * 	def __cinit__(self,  Graph G, double tol = 0.1):
 * 		self._G = G
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)             # <<<<<<<<<<<<<<
 * 
 * 	def runApproximation(self):
*/
  try {
    __pyx_t_1 = new NetworKit::SpanningEdgeCentrality(__pyx_v_G->_this, __pyx_v_tol);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2445, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2443
 * 
 * 	cdef Graph _G
 * 	def __cinit__(self,  Graph G, double tol = 0.1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2447
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
 * 
 * 	def runApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runApproximation()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation, " \n\t\trunApproximation()\n\n\t\tComputes approximation of the Spanning Edge Centrality. This solves k linear systems, \n\t\twhere `k` is :math:`log(n)/(tol^2)`. The empirical running time is :math:`O(km)`, where n is the number of nodes\n \t\tand m is the number of edges.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation = {"runApproximation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation};
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("runApproximation (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("runApproximation", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("runApproximation", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("runApproximation", 0);

  /* "networkit/centrality.pyx":2455
 *  		and m is the number of edges.
 * 		"""
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runApproximation()             # <<<<<<<<<<<<<<
 * 
 * 	def runParallelApproximation(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    ((NetworKit::SpanningEdgeCentrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->runApproximation();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2455, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2447
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
 * 
 * 	def runApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runApproximation()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.runApproximation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2457
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runApproximation()
 * 
 * 	def runParallelApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runParallelApproximation()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation, " \n\t\trunParallelApproximation()\n\t\t\n\t\tComputes approximation (in parallel) of the Spanning Edge Centrality. This solves k linear systems, \n\t\twhere `k` is :math:`log(n)/(tol^2)`. The empirical running time is :math:`O(km)`, where n is the number of nodes\n \t \tand m is the number of edges.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation = {"runParallelApproximation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation};
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("runParallelApproximation (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("runParallelApproximation", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("runParallelApproximation", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("runParallelApproximation", 0);

  /* "networkit/centrality.pyx":2465
 *  	 	and m is the number of edges.
 * 		"""
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runParallelApproximation()             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    ((NetworKit::SpanningEdgeCentrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->runParallelApproximation();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2465, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2465, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2457
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runApproximation()
 * 
 * 	def runParallelApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runParallelApproximation()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.runParallelApproximation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2467
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runParallelApproximation()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_7scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_22SpanningEdgeCentrality_6scores, " \n\t\tscores()\n\t\t\n\t\tGet a vector containing the SEC score for each edge in the graph\n\t\tin ascending edge ID order.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe SEC scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_7scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_7scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_6scores};
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_7scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_6scores(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_6scores(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":2479
 * 			The SEC scores.
 * 		"""
 * 		return (<_SpanningEdgeCentrality*>(self._this)).scores()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ApproxElectricalCloseness.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::SpanningEdgeCentrality *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2479, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2479, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2467
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runParallelApproximation()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_8__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.SpanningEdgeCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_10__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_22SpanningEdgeCentrality_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.SpanningEdgeCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2511
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1, double kappa = 0.3):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  double __pyx_v_eps;
  double __pyx_v_kappa;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_eps,&__pyx_mstate_global->__pyx_n_u_kappa,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2511, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2511, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2511, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2511, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2511, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, i); __PYX_ERR(0, 2511, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2511, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2511, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2511, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_eps = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_eps == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2511, __pyx_L3_error)
    } else {
      __pyx_v_eps = ((double)0.1);
    }
    if (values[2]) {
      __pyx_v_kappa = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_kappa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2511, __pyx_L3_error)
    } else {
      __pyx_v_kappa = ((double)0.3);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 2511, __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("networkit.centrality.ApproxElectricalCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2511, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness___cinit__(((struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *)__pyx_v_self), __pyx_v_G, __pyx_v_eps, __pyx_v_kappa);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_eps, double __pyx_v_kappa) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::ApproxElectricalCloseness *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2512
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1, double kappa = 0.3):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2513
 * 	def __cinit__(self, Graph G, double eps = 0.1, double kappa = 0.3):
 * 		self._G = G
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)             # <<<<<<<<<<<<<<
 * 
 * 	def getDiagonal(self):
*/
  try {
    __pyx_t_1 = new NetworKit::ApproxElectricalCloseness(__pyx_v_G->_this, __pyx_v_eps, __pyx_v_kappa);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2513, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2511
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1, double kappa = 0.3):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxElectricalCloseness.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2515
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal, "\n\t\tgetDiagonal()\n\n\t\tReturn an epsilon-approximation of the diagonal of the laplacian's pseudoinverse.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tApproximation of the diagonal of the laplacian's pseudoinverse.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal = {"getDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal};
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDiagonal (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getDiagonal", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getDiagonal", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal(((struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDiagonal", 0);

  /* "networkit/centrality.pyx":2526
 * 			Approximation of the diagonal of the laplacian's pseudoinverse.
 * 		"""
 * 		return (<_ApproxElectricalCloseness*>self._this).getDiagonal()             # <<<<<<<<<<<<<<
 * 
 * 	def computeExactDiagonal(self, double tol = 1e-9):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxElectricalCloseness *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getDiagonal();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2526, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2515
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxElectricalCloseness.getDiagonal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2528
 * 		return (<_ApproxElectricalCloseness*>self._this).getDiagonal()
 * 
 * 	def computeExactDiagonal(self, double tol = 1e-9):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeExactDiagonal(tol = 1e-9)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal, "\n\t\tcomputeExactDiagonal(tol = 1e-9)\n\n\t\tCompute and return the nearly-exact values of the diagonal of the laplacian's pseudoinverse.\n\t\tThe values are computed by solving :math:`Lx = e_u - 1 / n` for every vertex `u` of the graph with a\n\t\tLAMG solver.\n\n\t\tParameters\n\t\t----------\n\t\ttol : float\n\t\t\tTolerance for the LAMG solver. Default: 1e-9\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tNearly-exact values of the diagonal of the laplacian's pseudoinverse.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal = {"computeExactDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal};
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_tol;
  #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("computeExactDiagonal (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_tol,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, 2528, __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, 2528, __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, "computeExactDiagonal", 0) < 0) __PYX_ERR(0, 2528, __pyx_L3_error)
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2528, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    if (values[0]) {
      __pyx_v_tol = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_tol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2528, __pyx_L3_error)
    } else {
      __pyx_v_tol = ((double)1e-9);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeExactDiagonal", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 2528, __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("networkit.centrality.ApproxElectricalCloseness.computeExactDiagonal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal(((struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *)__pyx_v_self), __pyx_v_tol);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, double __pyx_v_tol) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeExactDiagonal", 0);

  /* "networkit/centrality.pyx":2546
 * 			Nearly-exact values of the diagonal of the laplacian's pseudoinverse.
 * 		"""
 * 		return (<_ApproxElectricalCloseness*>self._this).computeExactDiagonal(tol)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxElectricalCloseness *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->computeExactDiagonal(__pyx_v_tol);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2546, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2546, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2528
 * 		return (<_ApproxElectricalCloseness*>self._this).getDiagonal()
 * 
 * 	def computeExactDiagonal(self, double tol = 1e-9):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeExactDiagonal(tol = 1e-9)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxElectricalCloseness.computeExactDiagonal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_6__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxElectricalCloseness.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ApproxElectricalCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_8__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_25ApproxElectricalCloseness_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxElectricalCloseness.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2584
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, node root, double eps = 0.1, double kappa = 0.3):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_16ForestCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_16ForestCentrality_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  __pyx_t_9networkit_10structures_node __pyx_v_root;
  double __pyx_v_eps;
  double __pyx_v_kappa;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_root,&__pyx_mstate_global->__pyx_n_u_eps,&__pyx_mstate_global->__pyx_n_u_kappa,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2584, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2584, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2584, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2584, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2584, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2584, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, i); __PYX_ERR(0, 2584, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2584, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2584, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2584, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2584, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_root = __Pyx_PyLong_As_uint64_t(values[1]); if (unlikely((__pyx_v_root == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2584, __pyx_L3_error)
    if (values[2]) {
      __pyx_v_eps = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_eps == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2584, __pyx_L3_error)
    } else {
      __pyx_v_eps = ((double)0.1);
    }
    if (values[3]) {
      __pyx_v_kappa = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_kappa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2584, __pyx_L3_error)
    } else {
      __pyx_v_kappa = ((double)0.3);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 2584, __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("networkit.centrality.ForestCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2584, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_16ForestCentrality___cinit__(((struct __pyx_obj_9networkit_10centrality_ForestCentrality *)__pyx_v_self), __pyx_v_G, __pyx_v_root, __pyx_v_eps, __pyx_v_kappa);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_16ForestCentrality___cinit__(struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, __pyx_t_9networkit_10structures_node __pyx_v_root, double __pyx_v_eps, double __pyx_v_kappa) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::ForestCentrality *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2585
 * 
 * 	def __cinit__(self, Graph G, node root, double eps = 0.1, double kappa = 0.3):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->__pyx_base._G);
  __pyx_v_self->__pyx_base._G = __pyx_v_G;

  /* "networkit/centrality.pyx":2586
 * 	def __cinit__(self, Graph G, node root, double eps = 0.1, double kappa = 0.3):
 * 		self._G = G
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)             # <<<<<<<<<<<<<<
 * 
 * 	def getDiagonal(self):
*/
  try {
    __pyx_t_1 = new NetworKit::ForestCentrality(__pyx_v_G->_this, __pyx_v_root, __pyx_v_eps, __pyx_v_kappa);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2586, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2584
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, node root, double eps = 0.1, double kappa = 0.3):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ForestCentrality.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2588
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_3getDiagonal(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_16ForestCentrality_2getDiagonal, "\n\t\tgetDiagonal()\n\n\t\tReturn an epsilon-approximation of the diagonal of the forest matrix.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tApproximation of the diagonal of the laplacian's pseudoinverse.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_16ForestCentrality_3getDiagonal = {"getDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_3getDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_16ForestCentrality_2getDiagonal};
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_3getDiagonal(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDiagonal (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getDiagonal", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getDiagonal", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_16ForestCentrality_2getDiagonal(((struct __pyx_obj_9networkit_10centrality_ForestCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_2getDiagonal(struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_FakeReference<std::vector<double> > __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDiagonal", 0);

  /* "networkit/centrality.pyx":2599
 * 			Approximation of the diagonal of the laplacian's pseudoinverse.
 * 		"""
 * 		return (<_ForestCentrality*>self._this).getDiagonal()             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ApproxSpanningEdge.hpp>":
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ForestCentrality *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._this)->getDiagonal();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2599, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2588
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ForestCentrality.getDiagonal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_16ForestCentrality_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_16ForestCentrality_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ForestCentrality *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ForestCentrality.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_16ForestCentrality_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_16ForestCentrality_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ForestCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_16ForestCentrality_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ForestCentrality *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_16ForestCentrality_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ForestCentrality *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ForestCentrality.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2624
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  double __pyx_v_eps;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_eps,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2624, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2624, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2624, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2624, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, i); __PYX_ERR(0, 2624, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2624, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2624, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    if (values[1]) {
      __pyx_v_eps = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_eps == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2624, __pyx_L3_error)
    } else {
      __pyx_v_eps = ((double)0.1);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2624, __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("networkit.centrality.ApproxSpanningEdge.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2624, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge___cinit__(((struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)__pyx_v_self), __pyx_v_G, __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge___cinit__(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, double __pyx_v_eps) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  NetworKit::ApproxSpanningEdge *__pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "networkit/centrality.pyx":2625
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1):
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":2626
 * 	def __cinit__(self, Graph G, double eps = 0.1):
 * 		self._G = G
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  try {
    __pyx_t_1 = new NetworKit::ApproxSpanningEdge(__pyx_v_G->_this, __pyx_v_eps);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2626, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_1;

  /* "networkit/centrality.pyx":2624
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, double eps = 0.1):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxSpanningEdge.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2628
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_3scores(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_18ApproxSpanningEdge_2scores, "\n\t\tscores()\n\n\t\tReturn the spanning edge approximation for each edge of the graph\n\t\tin ascending edge ID order.\n\n\t\tReturns\n\t\t-------\n\t\tlist\n\t\t\tSpanning edge approximation for each edge of the input graph.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_3scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18ApproxSpanningEdge_2scores};
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_3scores(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("scores", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("scores", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_2scores(((struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_2scores(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_edgeweight>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":2640
 * 			Spanning edge approximation for each edge of the input graph.
 * 		"""
 * 		return (<_ApproxSpanningEdge*>(self._this)).scores();             # <<<<<<<<<<<<<<
 * 
 * def ranking(G, algorithm=Betweenness, normalized=False):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ApproxSpanningEdge *)__pyx_v_self->__pyx_base.__pyx_base._this)->scores();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2640, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_edgeweight(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2640, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2628
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ApproxSpanningEdge.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_4__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxSpanningEdge.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ApproxSpanningEdge.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_6__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18ApproxSpanningEdge_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ApproxSpanningEdge.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2642
 * 		return (<_ApproxSpanningEdge*>(self._this)).scores();
 * 
 * def ranking(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ranking(G, algorithm=networkit.centrality.Betweenness, normalized=False)
*/

static PyObject *__pyx_pf_9networkit_10centrality_10__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__defaults__", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2642, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2642, __pyx_L1_error);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2642, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 2642, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_1ranking(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_9networkit_10centrality_ranking, " \n\tranking(G, algorithm=networkit.centrality.Betweenness, normalized=False)\n\n\tReturn a ranking of nodes by the specified centrality type\n\t\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\talgorithm : networkit.centrality.Centrality, optional\n\t\tInstance of centrality algorithm to run. Default: networkit.centrality.Betweenness\n\tnormalized : bool, optional\n\t\tSet whether the ranking values should be normalized. Default: False\n\n\tReturns\n\t-------\n\tlist(int)\n\t\tRanking for nodes according to centrality algorithm.\n\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_1ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_1ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_ranking};
static PyObject *__pyx_pw_9networkit_10centrality_1ranking(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_G = 0;
  PyObject *__pyx_v_algorithm = 0;
  PyObject *__pyx_v_normalized = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ranking (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_G,&__pyx_mstate_global->__pyx_n_u_algorithm,&__pyx_mstate_global->__pyx_n_u_normalized,0};
    struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2642, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2642, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2642, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2642, __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, "ranking", 0) < 0) __PYX_ERR(0, 2642, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ranking", 0, 1, 3, i); __PYX_ERR(0, 2642, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2642, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2642, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2642, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_G = values[0];
    __pyx_v_algorithm = values[1];
    __pyx_v_normalized = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ranking", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 2642, __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("networkit.centrality.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_ranking(__pyx_self, __pyx_v_G, __pyx_v_algorithm, __pyx_v_normalized);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_ranking(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_G, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_normalized) {
  PyObject *__pyx_v_centrality = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":2663
 * 	"""
 * 	# FIXME: some centrality algorithms take more Parameters:
 * 	centrality = algorithm(G, normalized)             # <<<<<<<<<<<<<<
 * 	centrality.run()
 * 	return centrality.ranking()
*/
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_v_algorithm);
  __pyx_t_3 = __pyx_v_algorithm; 
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_G, __pyx_v_normalized};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2663, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_centrality = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2664
 * 	# FIXME: some centrality algorithms take more Parameters:
 * 	centrality = algorithm(G, normalized)
 * 	centrality.run()             # <<<<<<<<<<<<<<
 * 	return centrality.ranking()
 * 
*/
  __pyx_t_3 = __pyx_v_centrality;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_run, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2664, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2665
 * 	centrality = algorithm(G, normalized)
 * 	centrality.run()
 * 	return centrality.ranking()             # <<<<<<<<<<<<<<
 * 
 * def scores(G, algorithm=Betweenness, normalized=False):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_v_centrality;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_ranking, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2665, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2642
 * 		return (<_ApproxSpanningEdge*>(self._this)).scores();
 * 
 * def ranking(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ranking(G, algorithm=networkit.centrality.Betweenness, normalized=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_centrality);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2667
 * 	return centrality.ranking()
 * 
 * def scores(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	scores(G, algorithm=Betweenness, normalized=False)
*/

static PyObject *__pyx_pf_9networkit_10centrality_12__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__defaults__", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2667, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2667, __pyx_L1_error);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2667, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 2667, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_3scores(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_9networkit_10centrality_2scores, " \n\tscores(G, algorithm=Betweenness, normalized=False)\n\t\n\tReturn the centrality scores of nodes using the specified centrality type\n\t\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\talgorithm : networkit.centrality.Centrality, optional\n\t\tInstance of centrality algorithm to run. Default: networkit.centrality.Betweenness\n\tnormalized : bool, optional\n\t\tSet whether the ranking values should be normalized. Default: False\n\n\tReturns\n\t-------\n\tlist(int)\n\t\tScores for nodes according to centrality algorithm.\t\n\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_3scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_2scores};
static PyObject *__pyx_pw_9networkit_10centrality_3scores(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_G = 0;
  PyObject *__pyx_v_algorithm = 0;
  PyObject *__pyx_v_normalized = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scores (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_G,&__pyx_mstate_global->__pyx_n_u_algorithm,&__pyx_mstate_global->__pyx_n_u_normalized,0};
    struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2667, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2667, __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, "scores", 0) < 0) __PYX_ERR(0, 2667, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scores", 0, 1, 3, i); __PYX_ERR(0, 2667, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2667, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_G = values[0];
    __pyx_v_algorithm = values[1];
    __pyx_v_normalized = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scores", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 2667, __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("networkit.centrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_2scores(__pyx_self, __pyx_v_G, __pyx_v_algorithm, __pyx_v_normalized);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_2scores(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_G, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_normalized) {
  PyObject *__pyx_v_centrality = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":2687
 * 		Scores for nodes according to centrality algorithm.
 * 	"""
 * 	centrality = algorithm(G, normalized)             # <<<<<<<<<<<<<<
 * 	centrality.run()
 * 	return centrality.scores()
*/
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_v_algorithm);
  __pyx_t_3 = __pyx_v_algorithm; 
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_G, __pyx_v_normalized};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2687, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_centrality = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2688
 * 	"""
 * 	centrality = algorithm(G, normalized)
 * 	centrality.run()             # <<<<<<<<<<<<<<
 * 	return centrality.scores()
 * 
*/
  __pyx_t_3 = __pyx_v_centrality;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_run, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2688, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2689
 * 	centrality = algorithm(G, normalized)
 * 	centrality.run()
 * 	return centrality.scores()             # <<<<<<<<<<<<<<
 * 
 * def rankPerNode(ranking):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_v_centrality;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_scores, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2689, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2667
 * 	return centrality.ranking()
 * 
 * def scores(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	scores(G, algorithm=Betweenness, normalized=False)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_centrality);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2691
 * 	return centrality.scores()
 * 
 * def rankPerNode(ranking):             # <<<<<<<<<<<<<<
 * 	"""
 * 	rankPerNode(ranking)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_5rankPerNode(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_9networkit_10centrality_4rankPerNode, "\n\trankPerNode(ranking)\n\n\tReturns ranks of all nodes sorted by their ID.\n\n\tParameters\n\t----------\n \tranking: list(tuple(int, float))\n\t\tOrdered list of tuples (node, score).\n\n\tReturns\n\t-------\n\tlist(int)\n\t\tFor each node (sorted by node ID), the ranking of the node\n\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_5rankPerNode = {"rankPerNode", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_5rankPerNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_4rankPerNode};
static PyObject *__pyx_pw_9networkit_10centrality_5rankPerNode(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_ranking = 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("rankPerNode (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_ranking,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, 2691, __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, 2691, __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, "rankPerNode", 0) < 0) __PYX_ERR(0, 2691, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rankPerNode", 1, 1, 1, i); __PYX_ERR(0, 2691, __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, 2691, __pyx_L3_error)
    }
    __pyx_v_ranking = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("rankPerNode", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2691, __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("networkit.centrality.rankPerNode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_4rankPerNode(__pyx_self, __pyx_v_ranking);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_4rankPerNode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ranking) {
  Py_ssize_t __pyx_v_n_nodes;
  PyObject *__pyx_v_ranking_id = NULL;
  PyObject *__pyx_v_index = NULL;
  PyObject *__pyx_v_pair = NULL;
  PyObject *__pyx_v_prev_node = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *(*__pyx_t_4)(PyObject *);
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("rankPerNode", 0);

  /* "networkit/centrality.pyx":2707
 * 		For each node (sorted by node ID), the ranking of the node
 * 	"""
 * 	n_nodes = len(ranking)             # <<<<<<<<<<<<<<
 * 	ranking_id = [0]*n_nodes
 * 	for index, pair in enumerate(ranking):
*/
  __pyx_t_1 = PyObject_Length(__pyx_v_ranking); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2707, __pyx_L1_error)
  __pyx_v_n_nodes = __pyx_t_1;

  /* "networkit/centrality.pyx":2708
 * 	"""
 * 	n_nodes = len(ranking)
 * 	ranking_id = [0]*n_nodes             # <<<<<<<<<<<<<<
 * 	for index, pair in enumerate(ranking):
 * 		ranking_id[pair[0]] = index
*/
  __pyx_t_2 = PyList_New(1 * ((__pyx_v_n_nodes<0) ? 0:__pyx_v_n_nodes)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2708, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  { Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < __pyx_v_n_nodes; __pyx_temp++) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
      if (__Pyx_PyList_SET_ITEM(__pyx_t_2, __pyx_temp, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2708, __pyx_L1_error);
    }
  }
  __pyx_v_ranking_id = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2709
 * 	n_nodes = len(ranking)
 * 	ranking_id = [0]*n_nodes
 * 	for index, pair in enumerate(ranking):             # <<<<<<<<<<<<<<
 * 		ranking_id[pair[0]] = index
 * 	#we assign to all nodes the ranking of the first node with the same score
*/
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
  if (likely(PyList_CheckExact(__pyx_v_ranking)) || PyTuple_CheckExact(__pyx_v_ranking)) {
    __pyx_t_3 = __pyx_v_ranking; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_ranking); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2709, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2709, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2709, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_1);
        ++__pyx_t_1;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2709, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1));
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1);
        #endif
        ++__pyx_t_1;
      }
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2709, __pyx_L1_error)
    } else {
      __pyx_t_5 = __pyx_t_4(__pyx_t_3);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2709, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_pair, __pyx_t_5);
    __pyx_t_5 = 0;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_2);
    __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2709, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2);
    __pyx_t_2 = __pyx_t_5;
    __pyx_t_5 = 0;

    /* "networkit/centrality.pyx":2710
 * 	ranking_id = [0]*n_nodes
 * 	for index, pair in enumerate(ranking):
 * 		ranking_id[pair[0]] = index             # <<<<<<<<<<<<<<
 * 	#we assign to all nodes the ranking of the first node with the same score
 * 	for index, pair in enumerate(ranking):
*/
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_pair, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2710, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (unlikely((PyObject_SetItem(__pyx_v_ranking_id, __pyx_t_5, __pyx_v_index) < 0))) __PYX_ERR(0, 2710, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

    /* "networkit/centrality.pyx":2709
 * 	n_nodes = len(ranking)
 * 	ranking_id = [0]*n_nodes
 * 	for index, pair in enumerate(ranking):             # <<<<<<<<<<<<<<
 * 		ranking_id[pair[0]] = index
 * 	#we assign to all nodes the ranking of the first node with the same score
*/
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2712
 * 		ranking_id[pair[0]] = index
 * 	#we assign to all nodes the ranking of the first node with the same score
 * 	for index, pair in enumerate(ranking):             # <<<<<<<<<<<<<<
 * 			if index == 0:
 * 				continue
*/
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
  if (likely(PyList_CheckExact(__pyx_v_ranking)) || PyTuple_CheckExact(__pyx_v_ranking)) {
    __pyx_t_3 = __pyx_v_ranking; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_ranking); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2712, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2712, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2712, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_1);
        ++__pyx_t_1;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2712, __pyx_L1_error)
          #endif
          if (__pyx_t_1 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1));
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1);
        #endif
        ++__pyx_t_1;
      }
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2712, __pyx_L1_error)
    } else {
      __pyx_t_5 = __pyx_t_4(__pyx_t_3);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2712, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_pair, __pyx_t_5);
    __pyx_t_5 = 0;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_2);
    __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2712, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2);
    __pyx_t_2 = __pyx_t_5;
    __pyx_t_5 = 0;

    /* "networkit/centrality.pyx":2713
 * 	#we assign to all nodes the ranking of the first node with the same score
 * 	for index, pair in enumerate(ranking):
 * 			if index == 0:             # <<<<<<<<<<<<<<
 * 				continue
 * 			if pair[1] == ranking[index-1][1]:
*/
    __pyx_t_6 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_index, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2713, __pyx_L1_error)
    if (__pyx_t_6) {

      /* "networkit/centrality.pyx":2714
 * 	for index, pair in enumerate(ranking):
 * 			if index == 0:
 * 				continue             # <<<<<<<<<<<<<<
 * 			if pair[1] == ranking[index-1][1]:
 * 				prev_node = ranking[index-1][0]
*/
      goto __pyx_L6_continue;

      /* "networkit/centrality.pyx":2713
 * 	#we assign to all nodes the ranking of the first node with the same score
 * 	for index, pair in enumerate(ranking):
 * 			if index == 0:             # <<<<<<<<<<<<<<
 * 				continue
 * 			if pair[1] == ranking[index-1][1]:
*/
    }

    /* "networkit/centrality.pyx":2715
 * 			if index == 0:
 * 				continue
 * 			if pair[1] == ranking[index-1][1]:             # <<<<<<<<<<<<<<
 * 				prev_node = ranking[index-1][0]
 * 				ranking_id[pair[0]] = ranking_id[prev_node]
*/
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_pair, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = __Pyx_PyLong_SubtractObjC(__pyx_v_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_ranking, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_5, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2715, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_6) {

      /* "networkit/centrality.pyx":2716
 * 				continue
 * 			if pair[1] == ranking[index-1][1]:
 * 				prev_node = ranking[index-1][0]             # <<<<<<<<<<<<<<
 * 				ranking_id[pair[0]] = ranking_id[prev_node]
 * 	return ranking_id
*/
      __pyx_t_8 = __Pyx_PyLong_SubtractObjC(__pyx_v_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2716, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_ranking, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2716, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2716, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF_SET(__pyx_v_prev_node, __pyx_t_8);
      __pyx_t_8 = 0;

      /* "networkit/centrality.pyx":2717
 * 			if pair[1] == ranking[index-1][1]:
 * 				prev_node = ranking[index-1][0]
 * 				ranking_id[pair[0]] = ranking_id[prev_node]             # <<<<<<<<<<<<<<
 * 	return ranking_id
 * 
*/
      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_ranking_id, __pyx_v_prev_node); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2717, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_pair, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2717, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely((PyObject_SetItem(__pyx_v_ranking_id, __pyx_t_7, __pyx_t_8) < 0))) __PYX_ERR(0, 2717, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

      /* "networkit/centrality.pyx":2715
 * 			if index == 0:
 * 				continue
 * 			if pair[1] == ranking[index-1][1]:             # <<<<<<<<<<<<<<
 * 				prev_node = ranking[index-1][0]
 * 				ranking_id[pair[0]] = ranking_id[prev_node]
*/
    }

    /* "networkit/centrality.pyx":2712
 * 		ranking_id[pair[0]] = index
 * 	#we assign to all nodes the ranking of the first node with the same score
 * 	for index, pair in enumerate(ranking):             # <<<<<<<<<<<<<<
 * 			if index == 0:
 * 				continue
*/
    __pyx_L6_continue:;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2718
 * 				prev_node = ranking[index-1][0]
 * 				ranking_id[pair[0]] = ranking_id[prev_node]
 * 	return ranking_id             # <<<<<<<<<<<<<<
 * 
 * def relativeRankErrors(rx, ry):
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ranking_id);
  __pyx_r = __pyx_v_ranking_id;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2691
 * 	return centrality.scores()
 * 
 * def rankPerNode(ranking):             # <<<<<<<<<<<<<<
 * 	"""
 * 	rankPerNode(ranking)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("networkit.centrality.rankPerNode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ranking_id);
  __Pyx_XDECREF(__pyx_v_index);
  __Pyx_XDECREF(__pyx_v_pair);
  __Pyx_XDECREF(__pyx_v_prev_node);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2720
 * 	return ranking_id
 * 
 * def relativeRankErrors(rx, ry):             # <<<<<<<<<<<<<<
 * 	"""
 * 	relativeRankErrors(rx, ry)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_7relativeRankErrors(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_9networkit_10centrality_6relativeRankErrors, "\n\trelativeRankErrors(rx, ry)\n\n\tLet :math:`r_x(u)` be the rank of node `u` in ranking `x`.\n\tThe relative rank error of node `u` is defined as :math:`r_x(u) / r_y(u)`.\n\n\tParameters\n\t----------\n\trx : list(tuple(int, float))\n\t\tRanking - ordered list of tuples (node, score).\n\n\try : list(tuple(int, float))\n\t\tRanking - ordered list of tuples (node, score).\n\n\tReturns\n\t-------\n\tlist(int)\n\t\tRank errors ordered by node ID\n\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_7relativeRankErrors = {"relativeRankErrors", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7relativeRankErrors, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_6relativeRankErrors};
static PyObject *__pyx_pw_9networkit_10centrality_7relativeRankErrors(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_rx = 0;
  PyObject *__pyx_v_ry = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("relativeRankErrors (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_rx,&__pyx_mstate_global->__pyx_n_u_ry,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, 2720, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2720, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2720, __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, "relativeRankErrors", 0) < 0) __PYX_ERR(0, 2720, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("relativeRankErrors", 1, 2, 2, i); __PYX_ERR(0, 2720, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 2720, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2720, __pyx_L3_error)
    }
    __pyx_v_rx = values[0];
    __pyx_v_ry = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("relativeRankErrors", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2720, __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("networkit.centrality.relativeRankErrors", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_6relativeRankErrors(__pyx_self, __pyx_v_rx, __pyx_v_ry);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_6relativeRankErrors(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rx, PyObject *__pyx_v_ry) {
  PyObject *__pyx_v_diff = NULL;
  Py_ssize_t __pyx_v_n;
  PyObject *__pyx_v_rnode_x = NULL;
  PyObject *__pyx_v_rnode_y = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  Py_ssize_t __pyx_t_7;
  Py_ssize_t __pyx_t_8;
  int __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("relativeRankErrors", 0);

  /* "networkit/centrality.pyx":2740
 * 		Rank errors ordered by node ID
 * 	"""
 * 	diff = []             # <<<<<<<<<<<<<<
 * 	n = len(rx)
 * 	if not(n == len(ry)):
*/
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_diff = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2741
 * 	"""
 * 	diff = []
 * 	n = len(rx)             # <<<<<<<<<<<<<<
 * 	if not(n == len(ry)):
 * 		return diff
*/
  __pyx_t_2 = PyObject_Length(__pyx_v_rx); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2741, __pyx_L1_error)
  __pyx_v_n = __pyx_t_2;

  /* "networkit/centrality.pyx":2742
 * 	diff = []
 * 	n = len(rx)
 * 	if not(n == len(ry)):             # <<<<<<<<<<<<<<
 * 		return diff
 * 	rnode_x = rankPerNode(rx)
*/
  __pyx_t_2 = PyObject_Length(__pyx_v_ry); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2742, __pyx_L1_error)
  __pyx_t_3 = (!(__pyx_v_n == __pyx_t_2));
  if (__pyx_t_3) {

    /* "networkit/centrality.pyx":2743
 * 	n = len(rx)
 * 	if not(n == len(ry)):
 * 		return diff             # <<<<<<<<<<<<<<
 * 	rnode_x = rankPerNode(rx)
 * 	rnode_y = rankPerNode(ry)
*/
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_diff);
    __pyx_r = __pyx_v_diff;
    goto __pyx_L0;

    /* "networkit/centrality.pyx":2742
 * 	diff = []
 * 	n = len(rx)
 * 	if not(n == len(ry)):             # <<<<<<<<<<<<<<
 * 		return diff
 * 	rnode_x = rankPerNode(rx)
*/
  }

  /* "networkit/centrality.pyx":2744
 * 	if not(n == len(ry)):
 * 		return diff
 * 	rnode_x = rankPerNode(rx)             # <<<<<<<<<<<<<<
 * 	rnode_y = rankPerNode(ry)
 * 	for i in range(n):
*/
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rankPerNode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2744, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_rx};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_rnode_x = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2745
 * 		return diff
 * 	rnode_x = rankPerNode(rx)
 * 	rnode_y = rankPerNode(ry)             # <<<<<<<<<<<<<<
 * 	for i in range(n):
 * 		diff.append((rnode_x[i]+1)/(rnode_y[i]+1))
*/
  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_rankPerNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2745, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_ry};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_rnode_y = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2746
 * 	rnode_x = rankPerNode(rx)
 * 	rnode_y = rankPerNode(ry)
 * 	for i in range(n):             # <<<<<<<<<<<<<<
 * 		diff.append((rnode_x[i]+1)/(rnode_y[i]+1))
 * 	return diff
*/
  __pyx_t_2 = __pyx_v_n;
  __pyx_t_7 = __pyx_t_2;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
    __pyx_v_i = __pyx_t_8;

    /* "networkit/centrality.pyx":2747
 * 	rnode_y = rankPerNode(ry)
 * 	for i in range(n):
 * 		diff.append((rnode_x[i]+1)/(rnode_y[i]+1))             # <<<<<<<<<<<<<<
 * 	return diff
 * 
*/
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_rnode_x, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_rnode_y, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_diff, __pyx_t_1); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 2747, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }

  /* "networkit/centrality.pyx":2748
 * 	for i in range(n):
 * 		diff.append((rnode_x[i]+1)/(rnode_y[i]+1))
 * 	return diff             # <<<<<<<<<<<<<<
 * 
 * class SpectralCentrality:
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_diff);
  __pyx_r = __pyx_v_diff;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2720
 * 	return ranking_id
 * 
 * def relativeRankErrors(rx, ry):             # <<<<<<<<<<<<<<
 * 	"""
 * 	relativeRankErrors(rx, ry)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("networkit.centrality.relativeRankErrors", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_diff);
  __Pyx_XDECREF(__pyx_v_rnode_x);
  __Pyx_XDECREF(__pyx_v_rnode_y);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2764
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SpectralCentrality, self).__init__()
 * 
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_1__init__(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 PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_1__init__(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_self = 0;
  PyObject *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (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_self,&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,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, 2764, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2764, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2764, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2764, __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, "__init__", 0) < 0) __PYX_ERR(0, 2764, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, i); __PYX_ERR(0, 2764, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2764, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2764, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2764, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_G = values[1];
    __pyx_v_normalized = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 2764, __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("networkit.centrality.SpectralCentrality.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality___init__(__pyx_self, __pyx_v_self, __pyx_v_G, __pyx_v_normalized);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_normalized) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  size_t __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__init__", 0);

  /* "networkit/centrality.pyx":2765
 * 	"""
 * 	def __init__(self, G, normalized=False):
 * 		super(SpectralCentrality, self).__init__()             # <<<<<<<<<<<<<<
 * 
 * 		self.graph = G
*/
  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_builtin_super);
  __pyx_t_5 = __pyx_builtin_super; 
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SpectralCentrality); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_v_self};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__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;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2765, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_2 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_init, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2765, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2767
 * 		super(SpectralCentrality, self).__init__()
 * 
 * 		self.graph = G             # <<<<<<<<<<<<<<
 * 		self.normalized = normalized
 * 
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_graph, __pyx_v_G) < 0) __PYX_ERR(0, 2767, __pyx_L1_error)

  /* "networkit/centrality.pyx":2768
 * 
 * 		self.graph = G
 * 		self.normalized = normalized             # <<<<<<<<<<<<<<
 * 
 * 		self.scoreList = None
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_normalized, __pyx_v_normalized) < 0) __PYX_ERR(0, 2768, __pyx_L1_error)

  /* "networkit/centrality.pyx":2770
 * 		self.normalized = normalized
 * 
 * 		self.scoreList = None             # <<<<<<<<<<<<<<
 * 		self.rankList = None
 * 		self.evz = {}
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_scoreList, Py_None) < 0) __PYX_ERR(0, 2770, __pyx_L1_error)

  /* "networkit/centrality.pyx":2771
 * 
 * 		self.scoreList = None
 * 		self.rankList = None             # <<<<<<<<<<<<<<
 * 		self.evz = {}
 * 
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_rankList, Py_None) < 0) __PYX_ERR(0, 2771, __pyx_L1_error)

  /* "networkit/centrality.pyx":2772
 * 		self.scoreList = None
 * 		self.rankList = None
 * 		self.evz = {}             # <<<<<<<<<<<<<<
 * 
 * 	def prepareSpectrum(self):
*/
  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_evz, __pyx_t_1) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2764
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SpectralCentrality, self).__init__()
 * 
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2774
 * 		self.evz = {}
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_3prepareSpectrum(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_9networkit_10centrality_18SpectralCentrality_2prepareSpectrum, " \n\t\tprepareSpectrum()\n\n\t\tNot implemented yet.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_3prepareSpectrum = {"prepareSpectrum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_3prepareSpectrum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18SpectralCentrality_2prepareSpectrum};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_3prepareSpectrum(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
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 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("prepareSpectrum (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_self,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, 2774, __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, 2774, __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, "prepareSpectrum", 0) < 0) __PYX_ERR(0, 2774, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, i); __PYX_ERR(0, 2774, __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, 2774, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2774, __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("networkit.centrality.SpectralCentrality.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality_2prepareSpectrum(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_2prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("prepareSpectrum", 0);

  /* "networkit/centrality.pyx":2780
 * 		Not implemented yet.
 * 		"""
 * 		raise NotImplemented             # <<<<<<<<<<<<<<
 * 
 * 	def normFactor(self):
*/
  __Pyx_Raise(__pyx_builtin_NotImplemented, 0, 0, 0);
  __PYX_ERR(0, 2780, __pyx_L1_error)

  /* "networkit/centrality.pyx":2774
 * 		self.evz = {}
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2782
 * 		raise NotImplemented
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_5normFactor(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_9networkit_10centrality_18SpectralCentrality_4normFactor, " \n\t\tnormFactor()\n\n\t\tNot implemented yet.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_5normFactor = {"normFactor", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_5normFactor, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18SpectralCentrality_4normFactor};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_5normFactor(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
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 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("normFactor (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_self,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, 2782, __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, 2782, __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, "normFactor", 0) < 0) __PYX_ERR(0, 2782, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, i); __PYX_ERR(0, 2782, __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, 2782, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2782, __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("networkit.centrality.SpectralCentrality.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality_4normFactor(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("normFactor", 0);

  /* "networkit/centrality.pyx":2788
 * 		Not implemented yet.
 * 		"""
 * 		raise NotImplemented             # <<<<<<<<<<<<<<
 * 
 * 	def run(self):
*/
  __Pyx_Raise(__pyx_builtin_NotImplemented, 0, 0, 0);
  __PYX_ERR(0, 2788, __pyx_L1_error)

  /* "networkit/centrality.pyx":2782
 * 		raise NotImplemented
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2790
 * 		raise NotImplemented
 * 
 * 	def run(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		run()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_7run(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_9networkit_10centrality_18SpectralCentrality_6run, " \n\t\trun()\n\n\t\tRuns computation of spectral centrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_7run = {"run", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_7run, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18SpectralCentrality_6run};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_7run(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_self = 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("run (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_self,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, 2790, __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, 2790, __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, "run", 0) < 0) __PYX_ERR(0, 2790, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("run", 1, 1, 1, i); __PYX_ERR(0, 2790, __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, 2790, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("run", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2790, __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("networkit.centrality.SpectralCentrality.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality_6run(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_6run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_normFactor = NULL;
  PyObject *__pyx_v_v = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  size_t __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  Py_ssize_t __pyx_t_6;
  PyObject *(*__pyx_t_7)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("run", 0);

  /* "networkit/centrality.pyx":2796
 * 		Runs computation of spectral centrality.
 * 		"""
 * 		self.prepareSpectrum()             # <<<<<<<<<<<<<<
 * 
 * 		self.scoreList = None
*/
  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_prepareSpectrum, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2796, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2798
 * 		self.prepareSpectrum()
 * 
 * 		self.scoreList = None             # <<<<<<<<<<<<<<
 * 		self.rankList = None
 * 		self.evz = {}
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_scoreList, Py_None) < 0) __PYX_ERR(0, 2798, __pyx_L1_error)

  /* "networkit/centrality.pyx":2799
 * 
 * 		self.scoreList = None
 * 		self.rankList = None             # <<<<<<<<<<<<<<
 * 		self.evz = {}
 * 
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_rankList, Py_None) < 0) __PYX_ERR(0, 2799, __pyx_L1_error)

  /* "networkit/centrality.pyx":2800
 * 		self.scoreList = None
 * 		self.rankList = None
 * 		self.evz = {}             # <<<<<<<<<<<<<<
 * 
 * 		if self.normalized:
*/
  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2800, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_evz, __pyx_t_1) < 0) __PYX_ERR(0, 2800, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2802
 * 		self.evz = {}
 * 
 * 		if self.normalized:             # <<<<<<<<<<<<<<
 * 			normFactor = self.normFactor()
 * 		else:
*/
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_normalized); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2802, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_4) {

    /* "networkit/centrality.pyx":2803
 * 
 * 		if self.normalized:
 * 			normFactor = self.normFactor()             # <<<<<<<<<<<<<<
 * 		else:
 * 			normFactor = 1
*/
    __pyx_t_2 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_normFactor, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_normFactor = __pyx_t_1;
    __pyx_t_1 = 0;

    /* "networkit/centrality.pyx":2802
 * 		self.evz = {}
 * 
 * 		if self.normalized:             # <<<<<<<<<<<<<<
 * 			normFactor = self.normFactor()
 * 		else:
*/
    goto __pyx_L3;
  }

  /* "networkit/centrality.pyx":2805
 * 			normFactor = self.normFactor()
 * 		else:
 * 			normFactor = 1             # <<<<<<<<<<<<<<
 * 
 * 		for v in self.graph.iterNodes():
*/
  /*else*/ {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
    __pyx_v_normFactor = __pyx_mstate_global->__pyx_int_1;
  }
  __pyx_L3:;

  /* "networkit/centrality.pyx":2807
 * 			normFactor = 1
 * 
 * 		for v in self.graph.iterNodes():             # <<<<<<<<<<<<<<
 * 			self.evz[v] = self.eigenvector[v] * normFactor
 * 		return self
*/
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_graph); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2807, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __pyx_t_5;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_iterNodes, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2807, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    __pyx_t_7 = NULL;
  } else {
    __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2807, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2807, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_7)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2807, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6);
        ++__pyx_t_6;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2807, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6);
        #endif
        ++__pyx_t_6;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2807, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_7(__pyx_t_5);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2807, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1);
    __pyx_t_1 = 0;

    /* "networkit/centrality.pyx":2808
 * 
 * 		for v in self.graph.iterNodes():
 * 			self.evz[v] = self.eigenvector[v] * normFactor             # <<<<<<<<<<<<<<
 * 		return self
 * 
*/
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvector); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2808, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_v); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2808, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyNumber_Multiply(__pyx_t_2, __pyx_v_normFactor); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2808, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_evz); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2808, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (unlikely((PyObject_SetItem(__pyx_t_2, __pyx_v_v, __pyx_t_1) < 0))) __PYX_ERR(0, 2808, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "networkit/centrality.pyx":2807
 * 			normFactor = 1
 * 
 * 		for v in self.graph.iterNodes():             # <<<<<<<<<<<<<<
 * 			self.evz[v] = self.eigenvector[v] * normFactor
 * 		return self
*/
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "networkit/centrality.pyx":2809
 * 		for v in self.graph.iterNodes():
 * 			self.evz[v] = self.eigenvector[v] * normFactor
 * 		return self             # <<<<<<<<<<<<<<
 * 
 * 	def scores(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self);
  __pyx_r = __pyx_v_self;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2790
 * 		raise NotImplemented
 * 
 * 	def run(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		run()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_normFactor);
  __Pyx_XDECREF(__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2811
 * 		return self
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_9scores(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_9networkit_10centrality_18SpectralCentrality_8scores, " \n\t\tscores()\n\t\t\n\t\tGet a vector containing the SpectralCentrality score.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tThe SpectralCentrality scores.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_9scores = {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_9scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18SpectralCentrality_8scores};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_9scores(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_self = 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("scores (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_self,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, 2811, __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, 2811, __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, "scores", 0) < 0) __PYX_ERR(0, 2811, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("scores", 1, 1, 1, i); __PYX_ERR(0, 2811, __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, 2811, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scores", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2811, __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("networkit.centrality.SpectralCentrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality_8scores(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_8scores(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *__pyx_7genexpr__pyx_v_k = NULL;
  PyObject *__pyx_7genexpr__pyx_v_v = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  int __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scores", 0);

  /* "networkit/centrality.pyx":2822
 * 			The SpectralCentrality scores.
 * 		"""
 * 		if self.scoreList is None:             # <<<<<<<<<<<<<<
 * 			self.scoreList = [v for k,v in self.evz.items()]
 * 
*/
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_scoreList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2822, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 == Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {

    /* "networkit/centrality.pyx":2823
 * 		"""
 * 		if self.scoreList is None:
 * 			self.scoreList = [v for k,v in self.evz.items()]             # <<<<<<<<<<<<<<
 * 
 * 		return self.scoreList
*/
    { /* enter inner scope */
      __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2823, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = 0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_evz); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2823, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__pyx_t_7 == Py_None)) {
        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items");
        __PYX_ERR(0, 2823, __pyx_L6_error)
      }
      __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_7, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_5), (&__pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2823, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_3);
      __pyx_t_3 = __pyx_t_8;
      __pyx_t_8 = 0;
      while (1) {
        __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_5, &__pyx_t_4, &__pyx_t_8, &__pyx_t_7, NULL, __pyx_t_6);
        if (unlikely(__pyx_t_9 == 0)) break;
        if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 2823, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_k, __pyx_t_8);
        __pyx_t_8 = 0;
        __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_v, __pyx_t_7);
        __pyx_t_7 = 0;
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_7genexpr__pyx_v_v))) __PYX_ERR(0, 2823, __pyx_L6_error)
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_7genexpr__pyx_v_k); __pyx_7genexpr__pyx_v_k = 0;
      __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v); __pyx_7genexpr__pyx_v_v = 0;
      goto __pyx_L9_exit_scope;
      __pyx_L6_error:;
      __Pyx_XDECREF(__pyx_7genexpr__pyx_v_k); __pyx_7genexpr__pyx_v_k = 0;
      __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v); __pyx_7genexpr__pyx_v_v = 0;
      goto __pyx_L1_error;
      __pyx_L9_exit_scope:;
    } /* exit inner scope */
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_scoreList, __pyx_t_1) < 0) __PYX_ERR(0, 2823, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "networkit/centrality.pyx":2822
 * 			The SpectralCentrality scores.
 * 		"""
 * 		if self.scoreList is None:             # <<<<<<<<<<<<<<
 * 			self.scoreList = [v for k,v in self.evz.items()]
 * 
*/
  }

  /* "networkit/centrality.pyx":2825
 * 			self.scoreList = [v for k,v in self.evz.items()]
 * 
 * 		return self.scoreList             # <<<<<<<<<<<<<<
 * 
 * 	def ranking(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_scoreList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2825, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2811
 * 		return self
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.scores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_k);
  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2827
 * 		return self.scoreList
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_11ranking(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_9networkit_10centrality_18SpectralCentrality_10ranking, " \n\t\tranking()\n\n\t\tReturn a ranking of nodes by SpectralCentrality.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tRanking for nodes according to SpectralCentrality.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_11ranking = {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_11ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18SpectralCentrality_10ranking};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_11ranking(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_self = 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("ranking (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_self,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, 2827, __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, 2827, __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, "ranking", 0) < 0) __PYX_ERR(0, 2827, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ranking", 1, 1, 1, i); __PYX_ERR(0, 2827, __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, 2827, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ranking", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2827, __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("networkit.centrality.SpectralCentrality.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_18SpectralCentrality_10ranking(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2839
 * 		"""
 * 		if self.rankList is None:
 * 			self.rankList = sorted(self.evz.items(),key=lambda x: float(x[1]), reverse=True)             # <<<<<<<<<<<<<<
 * 		return self.rankList
 * 
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_7ranking_lambda(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 PyMethodDef __pyx_mdef_9networkit_10centrality_18SpectralCentrality_7ranking_lambda = {"lambda", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18SpectralCentrality_7ranking_lambda, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_18SpectralCentrality_7ranking_lambda(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_x = 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("lambda (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_x,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, 2839, __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, 2839, __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, "lambda", 0) < 0) __PYX_ERR(0, 2839, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, i); __PYX_ERR(0, 2839, __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, 2839, __pyx_L3_error)
    }
    __pyx_v_x = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2839, __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("networkit.centrality.SpectralCentrality.ranking.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, __pyx_v_x);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("lambda", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.ranking.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2827
 * 		return self.scoreList
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

static PyObject *__pyx_pf_9networkit_10centrality_18SpectralCentrality_10ranking(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  size_t __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ranking", 0);

  /* "networkit/centrality.pyx":2838
 * 			Ranking for nodes according to SpectralCentrality.
 * 		"""
 * 		if self.rankList is None:             # <<<<<<<<<<<<<<
 * 			self.rankList = sorted(self.evz.items(),key=lambda x: float(x[1]), reverse=True)
 * 		return self.rankList
*/
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_rankList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2838, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 == Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {

    /* "networkit/centrality.pyx":2839
 * 		"""
 * 		if self.rankList is None:
 * 			self.rankList = sorted(self.evz.items(),key=lambda x: float(x[1]), reverse=True)             # <<<<<<<<<<<<<<
 * 		return self.rankList
 * 
*/
    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_sorted);
    __pyx_t_4 = __pyx_builtin_sorted; 
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_evz); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2839, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __pyx_t_7;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_7ranking_lambda, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_ranking_local, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2839, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_t_5};
      __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_7, __pyx_t_6, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2839, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_reverse, Py_True, __pyx_t_6, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 2839, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_rankList, __pyx_t_1) < 0) __PYX_ERR(0, 2839, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "networkit/centrality.pyx":2838
 * 			Ranking for nodes according to SpectralCentrality.
 * 		"""
 * 		if self.rankList is None:             # <<<<<<<<<<<<<<
 * 			self.rankList = sorted(self.evz.items(),key=lambda x: float(x[1]), reverse=True)
 * 		return self.rankList
*/
  }

  /* "networkit/centrality.pyx":2840
 * 		if self.rankList is None:
 * 			self.rankList = sorted(self.evz.items(),key=lambda x: float(x[1]), reverse=True)
 * 		return self.rankList             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_rankList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2840, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2827
 * 		return self.scoreList
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("networkit.centrality.SpectralCentrality.ranking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2856
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		if G.isDirected():
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_1__init__(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 PyMethodDef __pyx_mdef_9networkit_10centrality_8SciPyEVZ_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8SciPyEVZ_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_1__init__(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_self = 0;
  PyObject *__pyx_v_G = 0;
  PyObject *__pyx_v_normalized = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (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_self,&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_normalized,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, 2856, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2856, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2856, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2856, __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, "__init__", 0) < 0) __PYX_ERR(0, 2856, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, i); __PYX_ERR(0, 2856, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2856, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2856, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2856, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_G = values[1];
    __pyx_v_normalized = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 2856, __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("networkit.centrality.SciPyEVZ.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8SciPyEVZ___init__(__pyx_self, __pyx_v_self, __pyx_v_G, __pyx_v_normalized);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_normalized) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  size_t __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__init__", 0);

  /* "networkit/centrality.pyx":2857
 * 	"""
 * 	def __init__(self, G, normalized=False):
 * 		if G.isDirected():             # <<<<<<<<<<<<<<
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
*/
  __pyx_t_2 = __pyx_v_G;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_isDirected, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2857, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2857, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_4)) {

    /* "networkit/centrality.pyx":2858
 * 	def __init__(self, G, normalized=False):
 * 		if G.isDirected():
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")             # <<<<<<<<<<<<<<
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
 * 
*/
    __pyx_t_2 = NULL;
    __Pyx_INCREF(__pyx_builtin_NotImplementedError);
    __pyx_t_5 = __pyx_builtin_NotImplementedError; 
    __pyx_t_3 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Not_implemented_for_directed_gra};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 2858, __pyx_L1_error)

    /* "networkit/centrality.pyx":2857
 * 	"""
 * 	def __init__(self, G, normalized=False):
 * 		if G.isDirected():             # <<<<<<<<<<<<<<
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
*/
  }

  /* "networkit/centrality.pyx":2859
 * 		if G.isDirected():
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)             # <<<<<<<<<<<<<<
 * 
 * 	def _length(self, vector):
*/
  __pyx_t_6 = NULL;
  __Pyx_INCREF(__pyx_builtin_super);
  __pyx_t_7 = __pyx_builtin_super; 
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SciPyEVZ); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_v_self};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2859, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __pyx_t_2;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_v_G};
    __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2859, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_normalized, __pyx_v_normalized, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2859, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_init, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2859, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2856
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		if G.isDirected():
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("networkit.centrality.SciPyEVZ.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2861
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		square = sum([val * val for val in vector])
 * 		return math.sqrt(square)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_3_length(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 PyMethodDef __pyx_mdef_9networkit_10centrality_8SciPyEVZ_3_length = {"_length", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8SciPyEVZ_3_length, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_3_length(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
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_vector = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_length (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_self,&__pyx_mstate_global->__pyx_n_u_vector,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, 2861, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2861, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2861, __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, "_length", 0) < 0) __PYX_ERR(0, 2861, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_length", 1, 2, 2, i); __PYX_ERR(0, 2861, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 2861, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2861, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_vector = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_length", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2861, __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("networkit.centrality.SciPyEVZ._length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8SciPyEVZ_2_length(__pyx_self, __pyx_v_self, __pyx_v_vector);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_2_length(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, PyObject *__pyx_v_vector) {
  PyObject *__pyx_v_square = NULL;
  PyObject *__pyx_8genexpr1__pyx_v_val = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  Py_ssize_t __pyx_t_6;
  PyObject *(*__pyx_t_7)(PyObject *);
  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("_length", 0);

  /* "networkit/centrality.pyx":2862
 * 
 * 	def _length(self, vector):
 * 		square = sum([val * val for val in vector])             # <<<<<<<<<<<<<<
 * 		return math.sqrt(square)
 * 
*/
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_sum);
  __pyx_t_3 = __pyx_builtin_sum; 
  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2862, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (likely(PyList_CheckExact(__pyx_v_vector)) || PyTuple_CheckExact(__pyx_v_vector)) {
      __pyx_t_5 = __pyx_v_vector; __Pyx_INCREF(__pyx_t_5);
      __pyx_t_6 = 0;
      __pyx_t_7 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_vector); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2862, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2862, __pyx_L5_error)
    }
    for (;;) {
      if (likely(!__pyx_t_7)) {
        if (likely(PyList_CheckExact(__pyx_t_5))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2862, __pyx_L5_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2862, __pyx_L5_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6));
          #else
          __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2862, __pyx_L5_error)
      } else {
        __pyx_t_8 = __pyx_t_7(__pyx_t_5);
        if (unlikely(!__pyx_t_8)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2862, __pyx_L5_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_val, __pyx_t_8);
      __pyx_t_8 = 0;
      __pyx_t_8 = PyNumber_Multiply(__pyx_8genexpr1__pyx_v_val, __pyx_8genexpr1__pyx_v_val); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2862, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 2862, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_val); __pyx_8genexpr1__pyx_v_val = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_val); __pyx_8genexpr1__pyx_v_val = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2862, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_square = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2863
 * 	def _length(self, vector):
 * 		square = sum([val * val for val in vector])
 * 		return math.sqrt(square)             # <<<<<<<<<<<<<<
 * 
 * 	def normFactor(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2863, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sqrt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2863, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_square};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __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_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2863, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2861
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		square = sum([val * val for val in vector])
 * 		return math.sqrt(square)
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("networkit.centrality.SciPyEVZ._length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_square);
  __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_val);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2865
 * 		return math.sqrt(square)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_5normFactor(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_9networkit_10centrality_8SciPyEVZ_4normFactor, "\n\t\tnormFactor()\n\n\t\tReturns the norm factor.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tNorm factor.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_8SciPyEVZ_5normFactor = {"normFactor", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8SciPyEVZ_5normFactor, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_8SciPyEVZ_4normFactor};
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_5normFactor(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_self = 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("normFactor (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_self,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, 2865, __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, 2865, __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, "normFactor", 0) < 0) __PYX_ERR(0, 2865, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, i); __PYX_ERR(0, 2865, __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, 2865, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2865, __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("networkit.centrality.SciPyEVZ.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8SciPyEVZ_4normFactor(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("normFactor", 0);

  /* "networkit/centrality.pyx":2876
 * 			Norm factor.
 * 		"""
 * 		return 1 / self._length(self.eigenvector)             # <<<<<<<<<<<<<<
 * 
 * 	def prepareSpectrum(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvector); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_length, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2876, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2865
 * 		return math.sqrt(square)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.SciPyEVZ.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2878
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_7prepareSpectrum(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_9networkit_10centrality_8SciPyEVZ_6prepareSpectrum, "\n\t\tprepareSpectrum()\n\n\t\tPrepare the computation of SciPyEVZ.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_8SciPyEVZ_7prepareSpectrum = {"prepareSpectrum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8SciPyEVZ_7prepareSpectrum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_8SciPyEVZ_6prepareSpectrum};
static PyObject *__pyx_pw_9networkit_10centrality_8SciPyEVZ_7prepareSpectrum(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_self = 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("prepareSpectrum (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_self,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, 2878, __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, 2878, __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, "prepareSpectrum", 0) < 0) __PYX_ERR(0, 2878, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, i); __PYX_ERR(0, 2878, __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, 2878, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2878, __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("networkit.centrality.SciPyEVZ.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8SciPyEVZ_6prepareSpectrum(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8SciPyEVZ_6prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_spectrum = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("prepareSpectrum", 0);

  /* "networkit/centrality.pyx":2884
 * 		Prepare the computation of SciPyEVZ.
 * 		"""
 * 		spectrum = adjacencyEigenvector(self.graph, i=0)             # <<<<<<<<<<<<<<
 * 		self.eigenvector = spectrum[1]
 * 		self.eigenvalue = spectrum[0]
*/
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_adjacencyEigenvector); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_graph); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2884, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_i, __pyx_mstate_global->__pyx_int_0, __pyx_t_6, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2884, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2884, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_spectrum = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2885
 * 		"""
 * 		spectrum = adjacencyEigenvector(self.graph, i=0)
 * 		self.eigenvector = spectrum[1]             # <<<<<<<<<<<<<<
 * 		self.eigenvalue = spectrum[0]
 * 
*/
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_spectrum, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvector, __pyx_t_1) < 0) __PYX_ERR(0, 2885, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2886
 * 		spectrum = adjacencyEigenvector(self.graph, i=0)
 * 		self.eigenvector = spectrum[1]
 * 		self.eigenvalue = spectrum[0]             # <<<<<<<<<<<<<<
 * 
 * class SciPyPageRank(SpectralCentrality):
*/
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_spectrum, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvalue, __pyx_t_1) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2878
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("networkit.centrality.SciPyEVZ.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_spectrum);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2903
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, damp=0.95, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)
 * 
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_1__init__(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 PyMethodDef __pyx_mdef_9networkit_10centrality_13SciPyPageRank_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_13SciPyPageRank_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_1__init__(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_self = 0;
  PyObject *__pyx_v_G = 0;
  PyObject *__pyx_v_damp = 0;
  PyObject *__pyx_v_normalized = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (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_self,&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_damp,&__pyx_mstate_global->__pyx_n_u_normalized,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, 2903, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2903, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2903, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2903, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2903, __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, "__init__", 0) < 0) __PYX_ERR(0, 2903, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_float_0_95)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, i); __PYX_ERR(0, 2903, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2903, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2903, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2903, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2903, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_float_0_95)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_G = values[1];
    __pyx_v_damp = values[2];
    __pyx_v_normalized = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 2903, __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("networkit.centrality.SciPyPageRank.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_13SciPyPageRank___init__(__pyx_self, __pyx_v_self, __pyx_v_G, __pyx_v_damp, __pyx_v_normalized);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_G, PyObject *__pyx_v_damp, PyObject *__pyx_v_normalized) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  size_t __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__init__", 0);

  /* "networkit/centrality.pyx":2904
 * 	"""
 * 	def __init__(self, G, damp=0.95, normalized=False):
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)             # <<<<<<<<<<<<<<
 * 
 * 		self.damp = damp
*/
  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_builtin_super);
  __pyx_t_5 = __pyx_builtin_super; 
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SciPyPageRank); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2904, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_v_self};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__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;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_2 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_v_G};
    __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_normalized, __pyx_v_normalized, __pyx_t_5, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2904, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_init, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2906
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)
 * 
 * 		self.damp = damp             # <<<<<<<<<<<<<<
 * 
 * 	def _length(self, vector):
*/
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_damp, __pyx_v_damp) < 0) __PYX_ERR(0, 2906, __pyx_L1_error)

  /* "networkit/centrality.pyx":2903
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, damp=0.95, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)
 * 
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("networkit.centrality.SciPyPageRank.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2908
 * 		self.damp = damp
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		return sum(vector)
 * 
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_3_length(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 PyMethodDef __pyx_mdef_9networkit_10centrality_13SciPyPageRank_3_length = {"_length", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_13SciPyPageRank_3_length, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_3_length(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
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_vector = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[2] = {0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_length (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_self,&__pyx_mstate_global->__pyx_n_u_vector,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, 2908, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2908, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2908, __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, "_length", 0) < 0) __PYX_ERR(0, 2908, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_length", 1, 2, 2, i); __PYX_ERR(0, 2908, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      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, 2908, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2908, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_vector = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_length", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2908, __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("networkit.centrality.SciPyPageRank._length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_13SciPyPageRank_2_length(__pyx_self, __pyx_v_self, __pyx_v_vector);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_2_length(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, PyObject *__pyx_v_vector) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_length", 0);

  /* "networkit/centrality.pyx":2909
 * 
 * 	def _length(self, vector):
 * 		return sum(vector)             # <<<<<<<<<<<<<<
 * 
 * 	def normFactor(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_sum);
  __pyx_t_3 = __pyx_builtin_sum; 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_vector};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2909, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2908
 * 		self.damp = damp
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		return sum(vector)
 * 
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.SciPyPageRank._length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2911
 * 		return sum(vector)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_5normFactor(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_9networkit_10centrality_13SciPyPageRank_4normFactor, "\n\t\tnormFactor()\n\n\t\tReturns the norm factor.\n\n\t\tReturns\n\t\t-------\n\t\tfloat\n\t\t\tNorm factor.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_13SciPyPageRank_5normFactor = {"normFactor", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_13SciPyPageRank_5normFactor, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_13SciPyPageRank_4normFactor};
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_5normFactor(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_self = 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("normFactor (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_self,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, 2911, __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, 2911, __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, "normFactor", 0) < 0) __PYX_ERR(0, 2911, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, i); __PYX_ERR(0, 2911, __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, 2911, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("normFactor", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2911, __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("networkit.centrality.SciPyPageRank.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_13SciPyPageRank_4normFactor(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_4normFactor(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("normFactor", 0);

  /* "networkit/centrality.pyx":2922
 * 			Norm factor.
 * 		"""
 * 		return 1 / self._length(self.eigenvector)             # <<<<<<<<<<<<<<
 * 
 * 	def prepareSpectrum(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvector); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_length, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2922, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2911
 * 		return sum(vector)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.SciPyPageRank.normFactor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2924
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_7prepareSpectrum(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_9networkit_10centrality_13SciPyPageRank_6prepareSpectrum, "\n\t\tprepareSpectrum()\n\n\t\tPrepare the computation of SciPyPageRank.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_13SciPyPageRank_7prepareSpectrum = {"prepareSpectrum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_13SciPyPageRank_7prepareSpectrum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_13SciPyPageRank_6prepareSpectrum};
static PyObject *__pyx_pw_9networkit_10centrality_13SciPyPageRank_7prepareSpectrum(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_self = 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("prepareSpectrum (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_self,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, 2924, __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, 2924, __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, "prepareSpectrum", 0) < 0) __PYX_ERR(0, 2924, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, i); __PYX_ERR(0, 2924, __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, 2924, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("prepareSpectrum", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2924, __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("networkit.centrality.SciPyPageRank.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_13SciPyPageRank_6prepareSpectrum(__pyx_self, __pyx_v_self);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_13SciPyPageRank_6prepareSpectrum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_prMatrix = NULL;
  PyObject *__pyx_v_spectrum = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("prepareSpectrum", 0);

  /* "networkit/centrality.pyx":2930
 * 		Prepare the computation of SciPyPageRank.
 * 		"""
 * 		prMatrix = PageRankMatrix(self.graph, self.damp)             # <<<<<<<<<<<<<<
 * 		spectrum = symmetricEigenvectors(prMatrix, cutoff=0, reverse=False)
 * 
*/
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PageRankMatrix); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2930, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_graph); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2930, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_damp); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2930, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_prMatrix = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2931
 * 		"""
 * 		prMatrix = PageRankMatrix(self.graph, self.damp)
 * 		spectrum = symmetricEigenvectors(prMatrix, cutoff=0, reverse=False)             # <<<<<<<<<<<<<<
 * 
 * 		self.eigenvector = spectrum[1][0]
*/
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_symmetricEigenvectors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2931, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_prMatrix};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_cutoff, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2931, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_reverse, Py_False, __pyx_t_4, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 2931, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_spectrum = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2933
 * 		spectrum = symmetricEigenvectors(prMatrix, cutoff=0, reverse=False)
 * 
 * 		self.eigenvector = spectrum[1][0]             # <<<<<<<<<<<<<<
 * 		self.eigenvalue = spectrum[0][0]
 * 
*/
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_spectrum, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2933, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2933, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvector, __pyx_t_5) < 0) __PYX_ERR(0, 2933, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "networkit/centrality.pyx":2934
 * 
 * 		self.eigenvector = spectrum[1][0]
 * 		self.eigenvalue = spectrum[0][0]             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ComplexPaths.hpp>" namespace "NetworKit::ComplexPathAlgorithm":
*/
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_spectrum, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2934, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2934, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_eigenvalue, __pyx_t_1) < 0) __PYX_ERR(0, 2934, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "networkit/centrality.pyx":2924
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("networkit.centrality.SciPyPageRank.prepareSpectrum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prMatrix);
  __Pyx_XDECREF(__pyx_v_spectrum);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     cdef tuple state
 *     cdef object _dict
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_15ComplexPathMode___reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ComplexPathMode *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15ComplexPathMode___reduce_cython__(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *__pyx_v_self) {
  PyObject *__pyx_v_state = 0;
  PyObject *__pyx_v__dict = 0;
  int __pyx_v_use_setstate;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":5
 *     cdef object _dict
 *     cdef bint use_setstate
 *     state = ()             # <<<<<<<<<<<<<<
 *     _dict = getattr(self, '__dict__', None)
 *     if _dict is not None:
*/
  __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple);
  __pyx_v_state = __pyx_mstate_global->__pyx_empty_tuple;

  /* "(tree fragment)":6
 *     cdef bint use_setstate
 *     state = ()
 *     _dict = getattr(self, '__dict__', None)             # <<<<<<<<<<<<<<
 *     if _dict is not None:
 *         state += (_dict,)
*/
  __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v__dict = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "(tree fragment)":7
 *     state = ()
 *     _dict = getattr(self, '__dict__', None)
 *     if _dict is not None:             # <<<<<<<<<<<<<<
 *         state += (_dict,)
 *         use_setstate = True
*/
  __pyx_t_2 = (__pyx_v__dict != Py_None);
  if (__pyx_t_2) {

    /* "(tree fragment)":8
 *     _dict = getattr(self, '__dict__', None)
 *     if _dict is not None:
 *         state += (_dict,)             # <<<<<<<<<<<<<<
 *         use_setstate = True
 *     else:
*/
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v__dict);
    __Pyx_GIVEREF(__pyx_v__dict);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error);
    __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3));
    __pyx_t_3 = 0;

    /* "(tree fragment)":9
 *     if _dict is not None:
 *         state += (_dict,)
 *         use_setstate = True             # <<<<<<<<<<<<<<
 *     else:
 *         use_setstate = False
*/
    __pyx_v_use_setstate = 1;

    /* "(tree fragment)":7
 *     state = ()
 *     _dict = getattr(self, '__dict__', None)
 *     if _dict is not None:             # <<<<<<<<<<<<<<
 *         state += (_dict,)
 *         use_setstate = True
*/
    goto __pyx_L3;
  }

  /* "(tree fragment)":11
 *         use_setstate = True
 *     else:
 *         use_setstate = False             # <<<<<<<<<<<<<<
 *     if use_setstate:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, None), state
*/
  /*else*/ {
    __pyx_v_use_setstate = 0;
  }
  __pyx_L3:;

  /* "(tree fragment)":12
 *     else:
 *         use_setstate = False
 *     if use_setstate:             # <<<<<<<<<<<<<<
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, None), state
 *     else:
*/
  if (__pyx_v_use_setstate) {

    /* "(tree fragment)":13
 *         use_setstate = False
 *     if use_setstate:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, None), state             # <<<<<<<<<<<<<<
 *     else:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)
*/
    __Pyx_XDECREF(__pyx_r);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_ComplexPathMode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_238750788);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_238750788);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_238750788) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_1);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_state);
    __Pyx_GIVEREF(__pyx_v_state);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_1 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

    /* "(tree fragment)":12
 *     else:
 *         use_setstate = False
 *     if use_setstate:             # <<<<<<<<<<<<<<
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, None), state
 *     else:
*/
  }

  /* "(tree fragment)":15
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, None), state
 *     else:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     __pyx_unpickle_ComplexPathMode__set_state(self, __pyx_state)
*/
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_ComplexPathMode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_238750788);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_238750788);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_238750788) != (0)) __PYX_ERR(1, 15, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_state);
    __Pyx_GIVEREF(__pyx_v_state);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error);
    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_4);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 15, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_1);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error);
    __pyx_t_4 = 0;
    __pyx_t_1 = 0;
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;
  }

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     cdef tuple state
 *     cdef object _dict
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("networkit.centrality.ComplexPathMode.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_state);
  __Pyx_XDECREF(__pyx_v__dict);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":16
 *     else:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     __pyx_unpickle_ComplexPathMode__set_state(self, __pyx_state)
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __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(1, 16, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 16, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __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(1, 16, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __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("networkit.centrality.ComplexPathMode.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_15ComplexPathMode_2__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ComplexPathMode *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_15ComplexPathMode_2__setstate_cython__(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":17
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)
 * def __setstate_cython__(self, __pyx_state):
 *     __pyx_unpickle_ComplexPathMode__set_state(self, __pyx_state)             # <<<<<<<<<<<<<<
*/
  if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error)
  __pyx_t_1 = __pyx_f_9networkit_10centrality___pyx_unpickle_ComplexPathMode__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "(tree fragment)":16
 *     else:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     __pyx_unpickle_ComplexPathMode__set_state(self, __pyx_state)
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.ComplexPathMode.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2987
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):             # <<<<<<<<<<<<<<
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES
*/

/* Python wrapper */
static int __pyx_pw_9networkit_10centrality_12ComplexPaths_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9networkit_10centrality_12ComplexPaths_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G = 0;
  PyObject *__pyx_v_threshold = 0;
  PyObject *__pyx_v_mode = 0;
  PyObject *__pyx_v_start = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[4] = {0,0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #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 -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_G,&__pyx_mstate_global->__pyx_n_u_threshold,&__pyx_mstate_global->__pyx_n_u_mode,&__pyx_mstate_global->__pyx_n_u_start,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2987, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2987, __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, "__cinit__", 0) < 0) __PYX_ERR(0, 2987, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_3));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_allNodes));
      if (!values[3]) values[3] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5);
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, i); __PYX_ERR(0, 2987, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2987, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2987, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_int_3));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_allNodes));
      if (!values[3]) values[3] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5);
    }
    __pyx_v_G = ((struct __pyx_obj_9networkit_5graph_Graph *)values[0]);
    __pyx_v_threshold = values[1];
    __pyx_v_mode = values[2];
    __pyx_v_start = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 2987, __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("networkit.centrality.ComplexPaths.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_G), __pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph, 1, "G", 0))) __PYX_ERR(0, 2987, __pyx_L1_error)
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths___cinit__(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self), __pyx_v_G, __pyx_v_threshold, __pyx_v_mode, __pyx_v_start);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  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 int __pyx_pf_9networkit_10centrality_12ComplexPaths___cinit__(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self, struct __pyx_obj_9networkit_5graph_Graph *__pyx_v_G, PyObject *__pyx_v_threshold, PyObject *__pyx_v_mode, PyObject *__pyx_v_start) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  __pyx_t_9networkit_10structures_count __pyx_t_3;
  enum NetworKit::ComplexPathAlgorithm::Mode __pyx_t_4;
  __pyx_t_9networkit_10structures_node __pyx_t_5;
  NetworKit::ComplexPathAlgorithm *__pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__cinit__", 0);
  __Pyx_INCREF(__pyx_v_mode);

  /* "networkit/centrality.pyx":2988
 * 
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):
 * 		if mode=="allNodes":             # <<<<<<<<<<<<<<
 * 			mode=ComplexPathMode.ALL_NODES
 * 		if mode=="singleNode":
*/
  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_allNodes, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2988, __pyx_L1_error)
  if (__pyx_t_1) {

    /* "networkit/centrality.pyx":2989
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES             # <<<<<<<<<<<<<<
 * 		if mode=="singleNode":
 * 			mode=ComplexPathMode.SINGLE_NODE
*/
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode), __pyx_mstate_global->__pyx_n_u_ALL_NODES); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2989, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_mode, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "networkit/centrality.pyx":2988
 * 
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):
 * 		if mode=="allNodes":             # <<<<<<<<<<<<<<
 * 			mode=ComplexPathMode.ALL_NODES
 * 		if mode=="singleNode":
*/
  }

  /* "networkit/centrality.pyx":2990
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES
 * 		if mode=="singleNode":             # <<<<<<<<<<<<<<
 * 			mode=ComplexPathMode.SINGLE_NODE
 * 		self._G = G
*/
  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_singleNode, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2990, __pyx_L1_error)
  if (__pyx_t_1) {

    /* "networkit/centrality.pyx":2991
 * 			mode=ComplexPathMode.ALL_NODES
 * 		if mode=="singleNode":
 * 			mode=ComplexPathMode.SINGLE_NODE             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)
*/
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode), __pyx_mstate_global->__pyx_n_u_SINGLE_NODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_mode, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "networkit/centrality.pyx":2990
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES
 * 		if mode=="singleNode":             # <<<<<<<<<<<<<<
 * 			mode=ComplexPathMode.SINGLE_NODE
 * 		self._G = G
*/
  }

  /* "networkit/centrality.pyx":2992
 * 		if mode=="singleNode":
 * 			mode=ComplexPathMode.SINGLE_NODE
 * 		self._G = G             # <<<<<<<<<<<<<<
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)
 * 
*/
  __Pyx_INCREF((PyObject *)__pyx_v_G);
  __Pyx_GIVEREF((PyObject *)__pyx_v_G);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_G);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_G);
  __pyx_v_self->_G = __pyx_v_G;

  /* "networkit/centrality.pyx":2993
 * 			mode=ComplexPathMode.SINGLE_NODE
 * 		self._G = G
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)             # <<<<<<<<<<<<<<
 * 
 * 	def getPLci(self):
*/
  __pyx_t_3 = __Pyx_PyLong_As_uint64_t(__pyx_v_threshold); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2993, __pyx_L1_error)
  __pyx_t_4 = ((enum NetworKit::ComplexPathAlgorithm::Mode)__Pyx_PyLong_As_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(__pyx_v_mode)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2993, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyLong_As_uint64_t(__pyx_v_start); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2993, __pyx_L1_error)
  try {
    __pyx_t_6 = new NetworKit::ComplexPathAlgorithm(__pyx_v_G->_this, __pyx_t_3, __pyx_t_4, __pyx_t_5);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 2993, __pyx_L1_error)
  }
  __pyx_v_self->__pyx_base.__pyx_base._this = __pyx_t_6;

  /* "networkit/centrality.pyx":2987
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):             # <<<<<<<<<<<<<<
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mode);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":2995
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)
 * 
 * 	def getPLci(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPLci()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_3getPLci(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12ComplexPaths_2getPLci, " \n\t\tgetPLci()\n\n\t\tReturns complex path lengths for every node in G either with \n\t\tabsolute length, or scaled to [0,1] when normalize() was called before run().\n\t\tOnly available when called in mode ComplexPathMode.ALL_NODES.\n\n\t\tReturns\n\t\t-------\n\t\tlist(float)\n\t\t\tA vector containing complex path lengths for all nodes.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_3getPLci = {"getPLci", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_3getPLci, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_2getPLci};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_3getPLci(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPLci (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getPLci", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getPLci", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_2getPLci(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_2getPLci(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<double>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPLci", 0);

  /* "networkit/centrality.pyx":3008
 * 			A vector containing complex path lengths for all nodes.
 * 		"""
 * 		return (<_ComplexPaths*>(self._this)).getPLci()             # <<<<<<<<<<<<<<
 * 
 * 	def getComplexGraph(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ComplexPathAlgorithm *)__pyx_v_self->__pyx_base.__pyx_base._this)->getPLci();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 3008, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3008, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":2995
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)
 * 
 * 	def getPLci(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPLci()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.getPLci", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":3010
 * 		return (<_ComplexPaths*>(self._this)).getPLci()
 * 
 * 	def getComplexGraph(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getComplexGraph()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_5getComplexGraph(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12ComplexPaths_4getComplexGraph, " \n\t\tgetComplexGraph()\n\n\t\tReturns complex path (sub)graph of G starting in the node start.\n\t\tOnly available when called in mode ComplexPathMode.SINGLE_NODE.\n\n\t\tReturns\n\t\t-------\n\t\tGraph\t\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_5getComplexGraph = {"getComplexGraph", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_5getComplexGraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_4getComplexGraph};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_5getComplexGraph(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getComplexGraph (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getComplexGraph", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getComplexGraph", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_4getComplexGraph(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_4getComplexGraph(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_FakeReference<NetworKit::Graph> __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getComplexGraph", 0);

  /* "networkit/centrality.pyx":3021
 * 		Graph
 * 		"""
 * 		return Graph().setThis((<_ComplexPaths*>(self._this)).getComplexGraph())             # <<<<<<<<<<<<<<
 * 
 * 	def getAdopters(self):
*/
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_5graph_Graph); 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3021, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  try {
    __pyx_t_5 = ((NetworKit::ComplexPathAlgorithm *)__pyx_v_self->__pyx_base.__pyx_base._this)->getComplexGraph();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 3021, __pyx_L1_error)
  }
  __pyx_t_3 = ((struct __pyx_vtabstruct_9networkit_5graph_Graph *)((struct __pyx_obj_9networkit_5graph_Graph *)__pyx_t_1)->__pyx_vtab)->setThis(((struct __pyx_obj_9networkit_5graph_Graph *)__pyx_t_1), __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3021, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":3010
 * 		return (<_ComplexPaths*>(self._this)).getPLci()
 * 
 * 	def getComplexGraph(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getComplexGraph()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.getComplexGraph", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":3023
 * 		return Graph().setThis((<_ComplexPaths*>(self._this)).getComplexGraph())
 * 
 * 	def getAdopters(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getAdopters()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_7getAdopters(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12ComplexPaths_6getAdopters, "\n\t\tgetAdopters()\n\n\t\tReturns all nodes in the complex subgraph with at least\n\t\tthreshold neighbors (those who are adopted/infected when \n\t\tstarting in start).\n\n\t\tReturns\n\t\t-------\n\t\tlist(int) \n\t\t\tA vector of all adopted/infected nodes.\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_7getAdopters = {"getAdopters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_7getAdopters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_6getAdopters};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_7getAdopters(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getAdopters (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("getAdopters", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("getAdopters", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_6getAdopters(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_6getAdopters(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  std::vector<__pyx_t_9networkit_10structures_node>  __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getAdopters", 0);

  /* "networkit/centrality.pyx":3036
 * 			A vector of all adopted/infected nodes.
 * 		"""
 * 		return (<_ComplexPaths*>(self._this)).getAdopters()             # <<<<<<<<<<<<<<
 * 
 * 	def normalize(self):
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    __pyx_t_1 = ((NetworKit::ComplexPathAlgorithm *)__pyx_v_self->__pyx_base.__pyx_base._this)->getAdopters();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 3036, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_convert_vector_to_py___pyx_t_9networkit_10structures_node(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":3023
 * 		return Graph().setThis((<_ComplexPaths*>(self._this)).getComplexGraph())
 * 
 * 	def getAdopters(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getAdopters()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.getAdopters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "networkit/centrality.pyx":3038
 * 		return (<_ComplexPaths*>(self._this)).getAdopters()
 * 
 * 	def normalize(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normalize()
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_9normalize(PyObject *__pyx_v_self, 
#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_9networkit_10centrality_12ComplexPaths_8normalize, "\n\t\tnormalize()\n\n\t\tWhen called before run() all complex path lengths returned by getPLci() are scaled to [0,1].\n\t\tOnly available when called in mode ComplexPathMode.ALL_NODES.\n\n\t\t");
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_9normalize = {"normalize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_9normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_8normalize};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_9normalize(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("normalize (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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("normalize", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("normalize", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_8normalize(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_8normalize(struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("normalize", 0);

  /* "networkit/centrality.pyx":3046
 * 
 * 		"""
 * 		return (<_ComplexPaths*>(self._this)).normalize()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  try {
    ((NetworKit::ComplexPathAlgorithm *)__pyx_v_self->__pyx_base.__pyx_base._this)->normalize();
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 3046, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3046, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "networkit/centrality.pyx":3038
 * 		return (<_ComplexPaths*>(self._this)).getAdopters()
 * 
 * 	def normalize(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normalize()
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.normalize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_11__reduce_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_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);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_10__reduce_cython__(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__reduce_cython__", 0);

  /* "(tree fragment)":2
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 2, __pyx_L1_error)

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_9networkit_10centrality_12ComplexPaths_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_12ComplexPaths_13__setstate_cython__(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
  #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_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __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(1, 3, __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, "__setstate_cython__", 0) < 0) __PYX_ERR(1, 3, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __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(1, 3, __pyx_L3_error)
    }
    __pyx_v___pyx_state = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  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("networkit.centrality.ComplexPaths.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_12ComplexPaths_12__setstate_cython__(((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)__pyx_v_self), __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_12ComplexPaths_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9networkit_10centrality_ComplexPaths *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__setstate_cython__", 0);

  /* "(tree fragment)":4
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
*/
  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0);
  __PYX_ERR(1, 4, __pyx_L1_error)

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("networkit.centrality.ComplexPaths.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":1
 * def __pyx_unpickle_ComplexPathMode(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
*/

/* Python wrapper */
static PyObject *__pyx_pw_9networkit_10centrality_9__pyx_unpickle_ComplexPathMode(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 PyMethodDef __pyx_mdef_9networkit_10centrality_9__pyx_unpickle_ComplexPathMode = {"__pyx_unpickle_ComplexPathMode", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9__pyx_unpickle_ComplexPathMode, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_9networkit_10centrality_9__pyx_unpickle_ComplexPathMode(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___pyx_type = 0;
  long __pyx_v___pyx_checksum;
  PyObject *__pyx_v___pyx_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[3] = {0,0,0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__pyx_unpickle_ComplexPathMode (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_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 1, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __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, "__pyx_unpickle_ComplexPathMode", 0) < 0) __PYX_ERR(1, 1, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ComplexPathMode", 1, 3, 3, i); __PYX_ERR(1, 1, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 1, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 1, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 1, __pyx_L3_error)
    }
    __pyx_v___pyx_type = values[0];
    __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
    __pyx_v___pyx_state = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ComplexPathMode", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __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("networkit.centrality.__pyx_unpickle_ComplexPathMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9networkit_10centrality_8__pyx_unpickle_ComplexPathMode(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);

  /* function exit code */
  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_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9networkit_10centrality_8__pyx_unpickle_ComplexPathMode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_v___pyx_PickleError = 0;
  PyObject *__pyx_v___pyx_result = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_unpickle_ComplexPathMode", 0);

  /* "(tree fragment)":4
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
 *     if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd):             # <<<<<<<<<<<<<<
 *         from pickle import PickleError as __pyx_PickleError
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
*/
  __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[0], Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {

    /* "(tree fragment)":5
 *     cdef object __pyx_result
 *     if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd):
 *         from pickle import PickleError as __pyx_PickleError             # <<<<<<<<<<<<<<
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)
*/
    __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_PickleError);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_PickleError);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_PickleError) != (0)) __PYX_ERR(1, 5, __pyx_L1_error);
    __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_1);
    __pyx_v___pyx_PickleError = __pyx_t_1;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "(tree fragment)":6
 *     if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd):
 *         from pickle import PickleError as __pyx_PickleError
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum             # <<<<<<<<<<<<<<
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)
 *     if __pyx_state is not None:
*/
    __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyUnicode_Format(__pyx_mstate_global->__pyx_kp_u_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(1, 6, __pyx_L1_error)

    /* "(tree fragment)":4
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
 *     if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd):             # <<<<<<<<<<<<<<
 *         from pickle import PickleError as __pyx_PickleError
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
*/
  }

  /* "(tree fragment)":7
 *         from pickle import PickleError as __pyx_PickleError
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)             # <<<<<<<<<<<<<<
 *     if __pyx_state is not None:
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
*/
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v___pyx_result = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "(tree fragment)":8
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)
 *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
 *     return __pyx_result
*/
  __pyx_t_2 = (__pyx_v___pyx_state != Py_None);
  if (__pyx_t_2) {

    /* "(tree fragment)":9
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)
 *     if __pyx_state is not None:
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)             # <<<<<<<<<<<<<<
 *     return __pyx_result
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):
*/
    if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error)
    __pyx_t_1 = __pyx_f_9networkit_10centrality___pyx_unpickle_ComplexPathMode__set_state(((struct __pyx_obj_9networkit_10centrality_ComplexPathMode *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "(tree fragment)":8
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
 *     __pyx_result = ComplexPathMode.__new__(__pyx_type)
 *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
 *     return __pyx_result
*/
  }

  /* "(tree fragment)":10
 *     if __pyx_state is not None:
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
 *     return __pyx_result             # <<<<<<<<<<<<<<
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v___pyx_result);
  __pyx_r = __pyx_v___pyx_result;
  goto __pyx_L0;

  /* "(tree fragment)":1
 * def __pyx_unpickle_ComplexPathMode(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("networkit.centrality.__pyx_unpickle_ComplexPathMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v___pyx_PickleError);
  __Pyx_XDECREF(__pyx_v___pyx_result);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "(tree fragment)":11
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
 *     return __pyx_result
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
 *         __pyx_result.__dict__.update(__pyx_state[0])
*/

static PyObject *__pyx_f_9networkit_10centrality___pyx_unpickle_ComplexPathMode__set_state(struct __pyx_obj_9networkit_10centrality_ComplexPathMode *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  Py_ssize_t __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  size_t __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__pyx_unpickle_ComplexPathMode__set_state", 0);

  /* "(tree fragment)":12
 *     return __pyx_result
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
 *         __pyx_result.__dict__.update(__pyx_state[0])
*/
  if (unlikely(__pyx_v___pyx_state == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(1, 12, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
  __pyx_t_3 = (__pyx_t_2 > 0);
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {

    /* "(tree fragment)":13
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
 *         __pyx_result.__dict__.update(__pyx_state[0])             # <<<<<<<<<<<<<<
*/
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_mstate_global->__pyx_n_u_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __pyx_t_6;
    __Pyx_INCREF(__pyx_t_5);
    if (unlikely(__pyx_v___pyx_state == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(1, 13, __pyx_L1_error)
    }
    __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "(tree fragment)":12
 *     return __pyx_result
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
 *         __pyx_result.__dict__.update(__pyx_state[0])
*/
  }

  /* "(tree fragment)":11
 *         __pyx_unpickle_ComplexPathMode__set_state(<ComplexPathMode> __pyx_result, __pyx_state)
 *     return __pyx_result
 * cdef __pyx_unpickle_ComplexPathMode__set_state(ComplexPathMode __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
 *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
 *         __pyx_result.__dict__.update(__pyx_state[0])
*/

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("networkit.centrality.__pyx_unpickle_ComplexPathMode__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* #### Code section: module_exttypes ### */

static PyObject *__pyx_tp_new_9networkit_10centrality_Centrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_Centrality *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_Centrality *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  return o;
}

static void __pyx_tp_dealloc_9networkit_10centrality_Centrality(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_Centrality *p = (struct __pyx_obj_9networkit_10centrality_Centrality *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_Centrality) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  {
    PyObject *etype, *eval, *etb;
    PyErr_Fetch(&etype, &eval, &etb);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
    __pyx_pw_9networkit_10centrality_10Centrality_3__dealloc__(o);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
    PyErr_Restore(etype, eval, etb);
  }
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_Centrality);
}

static int __pyx_tp_traverse_9networkit_10centrality_Centrality(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_Centrality *p = (struct __pyx_obj_9networkit_10centrality_Centrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_Centrality); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_Centrality(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_Centrality *p = (struct __pyx_obj_9networkit_10centrality_Centrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_Centrality); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_Centrality[] = {
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_5scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_4scores},
  {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_7score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_6score},
  {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_9ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_8ranking},
  {"maximum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_11maximum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_10maximum},
  {"centralization", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_13centralization, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_10Centrality_12centralization},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_10Centrality_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_Centrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" Abstract base class for centrality measures")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_Centrality},
  {Py_tp_init, (void *)__pyx_pw_9networkit_10centrality_10Centrality_1__init__},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_Centrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_Centrality_spec = {
  "networkit.centrality.Centrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_Centrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_Centrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_Centrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""Centrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_Centrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" Abstract base class for centrality measures"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_Centrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_Centrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_Betweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_11Betweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_Betweenness[] = {
  {"edgeScores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_3edgeScores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11Betweenness_2edgeScores},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11Betweenness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_Betweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tBetweenness(G, normalized=False, computeEdgeCentrality=False)\n\n\tConstructs the Betweenness class for the given Graph `G`. If the betweenness scores should be normalized,\n\tthen set `normalized` to True. The run() method takes O(nm) time, where n is the number\n \tof nodes and m is the number of edges of the graph.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tnormalized : bool, optional\n \t\tSet this parameter to True if scores should be normalized in the interval [0,1]. Default: False\n\tcomputeEdgeCentrality: bool, optional\n\t\tSet this to true if edge betweenness scores should be computed as well. Default: False\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_Betweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_Betweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_Betweenness_spec = {
  "networkit.centrality.Betweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_Betweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_Betweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_Betweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""Betweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_Betweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tBetweenness(G, normalized=False, computeEdgeCentrality=False)\n\n\tConstructs the Betweenness class for the given Graph `G`. If the betweenness scores should be normalized,\n\tthen set `normalized` to True. The run() method takes O(nm) time, where n is the number\n \tof nodes and m is the number of edges of the graph.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tnormalized : bool, optional\n \t\tSet this parameter to True if scores should be normalized in the interval [0,1]. Default: False\n\tcomputeEdgeCentrality: bool, optional\n\t\tSet this to true if edge betweenness scores should be computed as well. Default: False\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_Betweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_Betweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_17ApproxBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ApproxBetweenness[] = {
  {"numberOfSamples", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ApproxBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n \tApproxBetweenness(G, epsilon=0.01, delta=0.1, universalConstant=1.0)\n\n\tApproximation of betweenness centrality according to algorithm described in Matteo Riondato \n\tand Evgenios M. Kornaropoulos: Fast Approximation of Betweenness Centrality through Sampling\n\n \tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1- delta)`.\n\tThe values are normalized by default. The run() method takes O(m) time per sample, where  m is\n\tthe number of edges of the graph. The number of samples is proportional to universalConstant/epsilon^2.\n\tAlthough this algorithm has a theoretical guarantee, the algorithm implemented in Estimate Betweenness usually performs better in practice.\n\tTherefore, we recommend to use EstimateBetweenness if no theoretical guarantee is needed.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph\n\tepsilon : double, optional\n\t\tMaximum additive error. Default: 0.01\n\tdelta : double, optional\n\t\tProbability that the values are within the error guarantee. Default: 0.1\n\tuniversalConstant: double, optional\n\t\tThe universal constant to be used in computing the sample size.\n\t\tIt is 1 by default. Some references suggest using 0.5, but there\n\t\tis no guarantee in this case. Default: 1.0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ApproxBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ApproxBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ApproxBetweenness_spec = {
  "networkit.centrality.ApproxBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ApproxBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ApproxBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ApproxBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n \tApproxBetweenness(G, epsilon=0.01, delta=0.1, universalConstant=1.0)\n\n\tApproximation of betweenness centrality according to algorithm described in Matteo Riondato \n\tand Evgenios M. Kornaropoulos: Fast Approximation of Betweenness Centrality through Sampling\n\n \tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1- delta)`.\n\tThe values are normalized by default. The run() method takes O(m) time per sample, where  m is\n\tthe number of edges of the graph. The number of samples is proportional to universalConstant/epsilon^2.\n\tAlthough this algorithm has a theoretical guarantee, the algorithm implemented in Estimate Betweenness usually performs better in practice.\n\tTherefore, we recommend to use EstimateBetweenness if no theoretical guarantee is needed.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph\n\tepsilon : double, optional\n\t\tMaximum additive error. Default: 0.01\n\tdelta : double, optional\n\t\tProbability that the values are within the error guarantee. Default: 0.1\n\tuniversalConstant: double, optional\n\t\tThe universal constant to be used in computing the sample size.\n\t\tIt is 1 by default. Some references suggest using 0.5, but there\n\t\tis no guarantee in this case. Default: 1.0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ApproxBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ApproxBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_EstimateBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_19EstimateBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_EstimateBetweenness[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_EstimateBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tEstimateBetweenness(G, nSamples, normalized=False, parallel=False)\n\t\n\tEstimation of betweenness centrality according to algorithm described in\n\tSanders, Geisberger, Schultes: Better Approximation of Betweenness Centrality\n\n\tThe algorithm estimates the betweenness of all nodes, using weighting\n\tof the contributions to avoid biased estimation. The run() method takes O(m)\n\ttime per sample, where  m is the number of edges of the graph. There is no proven\n\ttheoretical guarantee on the quality of the approximation. However, the algorithm\n\twas shown to perform well in practice. If a guarantee is required, use ApproxBetweenness.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tInput graph\n\tnSamples : count\n\t\tUser defined number of samples\n\tnormalized : bool, optional\n\t\tNormalize centrality values in interval [0,1]\n\tparallel : bool, optional\n\t\tRun in parallel with additional memory cost z + 3z * t\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_EstimateBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_EstimateBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_EstimateBetweenness_spec = {
  "networkit.centrality.EstimateBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_EstimateBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_EstimateBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_EstimateBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""EstimateBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_EstimateBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tEstimateBetweenness(G, nSamples, normalized=False, parallel=False)\n\t\n\tEstimation of betweenness centrality according to algorithm described in\n\tSanders, Geisberger, Schultes: Better Approximation of Betweenness Centrality\n\n\tThe algorithm estimates the betweenness of all nodes, using weighting\n\tof the contributions to avoid biased estimation. The run() method takes O(m)\n\ttime per sample, where  m is the number of edges of the graph. There is no proven\n\ttheoretical guarantee on the quality of the approximation. However, the algorithm\n\twas shown to perform well in practice. If a guarantee is required, use ApproxBetweenness.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tInput graph\n\tnSamples : count\n\t\tUser defined number of samples\n\tnormalized : bool, optional\n\t\tNormalize centrality values in interval [0,1]\n\tparallel : bool, optional\n\t\tRun in parallel with additional memory cost z + 3z * t\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_EstimateBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_EstimateBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_KadabraBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_18KadabraBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_KadabraBetweenness(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_KadabraBetweenness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_KadabraBetweenness);
}

static PyMethodDef __pyx_methods_9networkit_10centrality_KadabraBetweenness[] = {
  {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_3ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_2ranking},
  {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_5topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_4topkNodesList},
  {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_7topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_6topkScoresList},
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_9scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_8scores},
  {"getNumberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_10getNumberOfIterations},
  {"getOmega", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_13getOmega, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18KadabraBetweenness_12getOmega},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_KadabraBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_KadabraBetweenness},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tKadabraBetweenness(Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0, unionSample = 0, startFactor = 100\n\n\tApproximation of the betweenness centrality and computation of the top-k\n\tnodes with highest betweenness centrality according to the algorithm\n\tdescribed in Borassi M. and Natale M. (2016): KADABRA is an ADaptive\n\tAlgorithm for Betweenness via Random Approximation.\n\tParallel implementation by Van der Grinten A., Angriman E., and\n\tMeyerhenke H.: Parallel Adaptive Sampling with almost no\n\tSynchronization, Euro-Par 2019.\n\thttps://link.springer.com/chapter/10.1007/978-3-030-29400-7_31\n\tArXiv pre-print: https://arxiv.org/abs/1903.09422.\n\n\tIf k = 0 the algorithm approximates the betweenness centrality of all\n\tvertices of the graph so that the scores are within an additive error\n\terr with probability at least :math:`(1 - err * delta)`. Otherwise, the algorithm\n\tcomputes the exact ranking of the top-k nodes with highest betweenness\n\tcentrality.\n\tThe algorithm relies on an adaptive random sampling technique of shortest\n\tpaths and the number of samples in the worst case is :math:`w = ((log(D - 2) +\n\tlog(2/delta))/err^2` samples, where D is the diameter of the graph.\n\tThus, the worst-case performance is :math:`O(w * (|E| + |V|))`, but performs better\n\tin practice.\n\n\tNotes\n\t-----\n\tIn order to work properly, the Kadabra algorithm requires a random seed\n\tto be previously set with 'useThreadId' set to True. To do this, call the\n\tsetSeed(<your_seed>, True) fuction within the Random module.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\terr : float, optional\n\t\tMaximum additive error guaranteed when approximating the\n\t\tbetweenness centrality of all nodes. Default: 0.01\n\tdelta : float, optional\n\t\tProbability that the values of the betweenness centrality are\n\t\twithin the error guarantee. Default: 0.1\n\tdeterministic : bool, optional\n\t\tIf True, the algorithm guarante""es that the results of two different executions is the \n\t\tsame for a fixed random seed, regardless of the number of threads. Note that this \n\t\tguarantee leads to increased computational and memory complexity. Default: False\n\tk : int, optional\n\t\tThe number of top-k nodes to be computed. Set it to zero to\n\t\tapproximate the betweenness centrality of all the nodes. Default: 0\n\tunionSample : int, optional\n\t\tAlgorithm parameter. Default: 0\n\tstartFactor : int, optional\n\t\tAlgorithm parameter. Default: 100\n\t")},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_KadabraBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_KadabraBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_KadabraBetweenness_spec = {
  "networkit.centrality.KadabraBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_KadabraBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_KadabraBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""KadabraBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_KadabraBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_KadabraBetweenness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tKadabraBetweenness(Graph G, err = 0.01, delta = 0.1, deterministic = False, k = 0, unionSample = 0, startFactor = 100\n\n\tApproximation of the betweenness centrality and computation of the top-k\n\tnodes with highest betweenness centrality according to the algorithm\n\tdescribed in Borassi M. and Natale M. (2016): KADABRA is an ADaptive\n\tAlgorithm for Betweenness via Random Approximation.\n\tParallel implementation by Van der Grinten A., Angriman E., and\n\tMeyerhenke H.: Parallel Adaptive Sampling with almost no\n\tSynchronization, Euro-Par 2019.\n\thttps://link.springer.com/chapter/10.1007/978-3-030-29400-7_31\n\tArXiv pre-print: https://arxiv.org/abs/1903.09422.\n\n\tIf k = 0 the algorithm approximates the betweenness centrality of all\n\tvertices of the graph so that the scores are within an additive error\n\terr with probability at least :math:`(1 - err * delta)`. Otherwise, the algorithm\n\tcomputes the exact ranking of the top-k nodes with highest betweenness\n\tcentrality.\n\tThe algorithm relies on an adaptive random sampling technique of shortest\n\tpaths and the number of samples in the worst case is :math:`w = ((log(D - 2) +\n\tlog(2/delta))/err^2` samples, where D is the diameter of the graph.\n\tThus, the worst-case performance is :math:`O(w * (|E| + |V|))`, but performs better\n\tin practice.\n\n\tNotes\n\t-----\n\tIn order to work properly, the Kadabra algorithm requires a random seed\n\tto be previously set with 'useThreadId' set to True. To do this, call the\n\tsetSeed(<your_seed>, True) fuction within the Random module.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\terr : float, optional\n\t\tMaximum additive error guaranteed when approximating the\n\t\tbetweenness centrality of all nodes. Default: 0.01\n\tdelta : float, optional\n\t\tProbability that the values of the betweenness centrality are\n\t\twithin the error guarantee. Default: 0.1\n\tdeterministic : bool, optional\n\t\tIf True, the algorithm guarante""es that the results of two different executions is the \n\t\tsame for a fixed random seed, regardless of the number of threads. Note that this \n\t\tguarantee leads to increased computational and memory complexity. Default: False\n\tk : int, optional\n\t\tThe number of top-k nodes to be computed. Set it to zero to\n\t\tapproximate the betweenness centrality of all the nodes. Default: 0\n\tunionSample : int, optional\n\t\tAlgorithm parameter. Default: 0\n\tstartFactor : int, optional\n\t\tAlgorithm parameter. Default: 100\n\t"), /*tp_doc*/
  0, /*tp_traverse*/
  0, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_KadabraBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_KadabraBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DynBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_DynBetweenness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_DynBetweenness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_14DynBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_DynBetweenness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_DynBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynBetweenness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_DynBetweenness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_DynBetweenness);
}

static int __pyx_tp_traverse_9networkit_10centrality_DynBetweenness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_DynBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_DynBetweenness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_DynBetweenness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_DynBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_DynBetweenness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DynBetweenness[] = {
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_2scores},
  {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_5score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_4score},
  {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_7ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14DynBetweenness_6ranking},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14DynBetweenness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DynBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_DynBetweenness},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tDynBetweenness(G)\n\t\n\tThe algorithm computes the betweenness centrality of all nodes\n\tand updates them after an edge insertion.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_DynBetweenness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_DynBetweenness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DynBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DynBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DynBetweenness_spec = {
  "networkit.centrality.DynBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_DynBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DynBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DynBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DynBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DynBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_DynBetweenness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tDynBetweenness(G)\n\t\n\tThe algorithm computes the betweenness centrality of all nodes\n\tand updates them after an edge insertion.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_DynBetweenness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_DynBetweenness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DynBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DynBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DynApproxBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_DynApproxBetweenness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_DynApproxBetweenness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_DynApproxBetweenness);
}

static int __pyx_tp_traverse_9networkit_10centrality_DynApproxBetweenness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_DynApproxBetweenness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_DynApproxBetweenness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *p = (struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_DynApproxBetweenness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DynApproxBetweenness[] = {
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_2scores},
  {"score", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_5score, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_4score},
  {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_7ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_6ranking},
  {"getNumberOfSamples", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20DynApproxBetweenness_8getNumberOfSamples},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DynApproxBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_DynApproxBetweenness},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tDynApproxBetweenness(G, epsilon=0.01, delta=0.1, storePredecessors=True, universalConstant=1.0)\n\t\n\tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1 - delta)`.\n\tThe values are normalized by default.\n\n\tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1 - delta)`.\n\tThe values are normalized by default.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph\n\tepsilon : float, optional\n\t\tMaximum additive error. Default: 0.01\n\tdelta : float, optional\n\t\tProbability that the values are within the error guarantee. Default: 0.1\n\tstorePredecessors : bool, optional\n\t\tStore lists of predecessors. Default: True\n\tuniversalConstant: float, optional\n\t\tThe universal constant to be used in computing the sample size.\n\t\tIt is 1 by default. Some references suggest using 0.5, but there\n\t\tis no guarantee in this case. Default: 1.0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_DynApproxBetweenness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_DynApproxBetweenness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DynApproxBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DynApproxBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DynApproxBetweenness_spec = {
  "networkit.centrality.DynApproxBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DynApproxBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DynApproxBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DynApproxBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DynApproxBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_DynApproxBetweenness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tDynApproxBetweenness(G, epsilon=0.01, delta=0.1, storePredecessors=True, universalConstant=1.0)\n\t\n\tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1 - delta)`.\n\tThe values are normalized by default.\n\n\tThe algorithm approximates the betweenness of all vertices so that the scores are\n\twithin an additive error epsilon with probability at least :math:`(1 - delta)`.\n\tThe values are normalized by default.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph\n\tepsilon : float, optional\n\t\tMaximum additive error. Default: 0.01\n\tdelta : float, optional\n\t\tProbability that the values are within the error guarantee. Default: 0.1\n\tstorePredecessors : bool, optional\n\t\tStore lists of predecessors. Default: True\n\tuniversalConstant: float, optional\n\t\tThe universal constant to be used in computing the sample size.\n\t\tIt is 1 by default. Some references suggest using 0.5, but there\n\t\tis no guarantee in this case. Default: 1.0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_DynApproxBetweenness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_DynApproxBetweenness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DynApproxBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DynApproxBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DynBetweennessOneNode(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_DynBetweennessOneNode(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *p = (struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_DynBetweennessOneNode) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  {
    PyObject *etype, *eval, *etb;
    PyErr_Fetch(&etype, &eval, &etb);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
    __pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_3__dealloc__(o);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
    PyErr_Restore(etype, eval, etb);
  }
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_DynBetweennessOneNode);
}

static int __pyx_tp_traverse_9networkit_10centrality_DynBetweennessOneNode(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *p = (struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_DynBetweennessOneNode); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_DynBetweennessOneNode(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *p = (struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_DynBetweennessOneNode); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DynBetweennessOneNode[] = {
  {"getDistance", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_5getDistance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_4getDistance},
  {"getSigma", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_7getSigma, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_6getSigma},
  {"getSigmax", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_8getSigmax},
  {"getbcx", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_11getbcx, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_21DynBetweennessOneNode_10getbcx},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DynBetweennessOneNode_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_DynBetweennessOneNode},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tDynBetweennessOneNode(G, x)\n\t\n\tDynamic exact algorithm for updating the betweenness of a specific node.\n\tThe algorithm updates the betweenness of a node after an edge insertion\n\t(faster than updating it for all nodes), based on the algorithm\n\tproposed by Bergamini et al. \"Improving the betweenness centrality of a node by adding links\"\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph\n\tx : int\n\t\tThe node for which you want to update betweenness\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_DynBetweennessOneNode},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_DynBetweennessOneNode},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DynBetweennessOneNode},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DynBetweennessOneNode},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DynBetweennessOneNode_spec = {
  "networkit.centrality.DynBetweennessOneNode",
  sizeof(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DynBetweennessOneNode_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DynBetweennessOneNode = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DynBetweennessOneNode", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DynBetweennessOneNode), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_DynBetweennessOneNode, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tDynBetweennessOneNode(G, x)\n\t\n\tDynamic exact algorithm for updating the betweenness of a specific node.\n\tThe algorithm updates the betweenness of a node after an edge insertion\n\t(faster than updating it for all nodes), based on the algorithm\n\tproposed by Bergamini et al. \"Improving the betweenness centrality of a node by adding links\"\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph\n\tx : int\n\t\tThe node for which you want to update betweenness\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_DynBetweennessOneNode, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_DynBetweennessOneNode, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DynBetweennessOneNode, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DynBetweennessOneNode, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_Closeness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_9Closeness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_Closeness[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Closeness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Closeness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_Closeness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tCloseness(G, normalized, checkConnectedness)\n\tCloseness(G, normalized, variant)\n\n\tConstructs the Closeness class for the given Graph `G`. If the Closeness scores should not be normalized,\n\tset `normalized` to False. The run() method takes O(nm) time, where n is the number\n\tof nodes and m is the number of edges of the graph.\n\n\tParameter :code:`variant` can be one of the following:\n\n\t- networkit.centrality.ClosenessVariant.STANDARD\n\t- networkit.centrality.ClosenessVariant.GENERALIZED\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tnormalized : bool\n\t\tSet this parameter to False if scores should not be normalized into an interval of [0,1].\n\t\tNormalization only works for unweighted graphs.\n\tcheckConnectedness : bool\n\t\tSet this parameter to True to also check if the graph is connected before computing closeness.\n\t\tSet this parameter to False to not check if the graph is connected (note: the standard definition\n\t\tof closeness works for connected graphs, choose this if the input graph is known to be connected).\n\tClosenessVariant : networkit.centrality.ClosenessVariant\n\t\tSet this parameter to networkit.centrality.ClosenessVariant.Standard to use the standard\n\t\tdefinition of closeness, that is defined for connected graphs only; in this case, checkConnectedness\n\t\tis automatically set to True.\n\t\tSet this parameter to networkit.centrality.ClosenessVariant.Generalized to use the generalized\n\t\tdefinition of closeness, that is defined for also non-connected graphs; in this case, checkConnectedness\n\t\tis automatically set to False.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_Closeness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_Closeness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_Closeness_spec = {
  "networkit.centrality.Closeness",
  sizeof(struct __pyx_obj_9networkit_10centrality_Closeness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_Closeness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_Closeness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""Closeness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_Closeness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tCloseness(G, normalized, checkConnectedness)\n\tCloseness(G, normalized, variant)\n\n\tConstructs the Closeness class for the given Graph `G`. If the Closeness scores should not be normalized,\n\tset `normalized` to False. The run() method takes O(nm) time, where n is the number\n\tof nodes and m is the number of edges of the graph.\n\n\tParameter :code:`variant` can be one of the following:\n\n\t- networkit.centrality.ClosenessVariant.STANDARD\n\t- networkit.centrality.ClosenessVariant.GENERALIZED\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tnormalized : bool\n\t\tSet this parameter to False if scores should not be normalized into an interval of [0,1].\n\t\tNormalization only works for unweighted graphs.\n\tcheckConnectedness : bool\n\t\tSet this parameter to True to also check if the graph is connected before computing closeness.\n\t\tSet this parameter to False to not check if the graph is connected (note: the standard definition\n\t\tof closeness works for connected graphs, choose this if the input graph is known to be connected).\n\tClosenessVariant : networkit.centrality.ClosenessVariant\n\t\tSet this parameter to networkit.centrality.ClosenessVariant.Standard to use the standard\n\t\tdefinition of closeness, that is defined for connected graphs only; in this case, checkConnectedness\n\t\tis automatically set to True.\n\t\tSet this parameter to networkit.centrality.ClosenessVariant.Generalized to use the generalized\n\t\tdefinition of closeness, that is defined for also non-connected graphs; in this case, checkConnectedness\n\t\tis automatically set to False.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_Closeness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_Closeness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_15ApproxCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ApproxCloseness[] = {
  {"getSquareErrorEstimates", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_15ApproxCloseness_2getSquareErrorEstimates},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ApproxCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tApproxCloseness(G, nSamples, epsilon=0.1, normalized=False, type=networkit.centrality.ClosenessType.OUTBOUND)\n\n\tApproximation of closeness centrality according to algorithm described in\n  \tCohen et al., Computing Classic Closeness Centrality, at Scale.\n\n\tThe algorithm approximates the closeness of all nodes in both directed and undirected graphs using a hybrid estimator.\n\tFirst, it takes nSamples samples. For these sampled nodes, the closeness is computed exactly. The pivot of each of the\n\tremaining nodes is the closest sampled node to it. If a node lies very close to its pivot, a sampling approach is used.\n\tOtherwise, a pivoting approach is used. Notice that the input graph has to be connected.\n\n\tParameter :code:`type` can be one of the following:\n\n\t- networkit.centrality.ClosenessType.INBOUND\n\t- networkit.centrality.ClosenessType.OUTBOUND\n\t- networkit.centrality.ClosenessType.SUM\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tInput graph (undirected).\n\tnSamples : int\n\t\tUser defined number of samples.\n\tepsilon : float, optional\n\t\tParameter used for the error guarantee; it is also used to control when to use sampling and when to use pivoting. Default: 0.1\n\tnormalized : bool, optional\n\t\tNormalize centrality values in interval [0,1]. Default: False\n\ttype : networkit.centrality.ClosenessType, optional\n\t\tUse in- or outbound centrality or the sum of both (see paper) for computing closeness on directed graph. \n\t\tIf G is undirected, this can be ignored. Default: networkit.centrality.ClosenessType.OUTBOUND\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ApproxCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ApproxCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ApproxCloseness_spec = {
  "networkit.centrality.ApproxCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ApproxCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ApproxCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ApproxCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tApproxCloseness(G, nSamples, epsilon=0.1, normalized=False, type=networkit.centrality.ClosenessType.OUTBOUND)\n\n\tApproximation of closeness centrality according to algorithm described in\n  \tCohen et al., Computing Classic Closeness Centrality, at Scale.\n\n\tThe algorithm approximates the closeness of all nodes in both directed and undirected graphs using a hybrid estimator.\n\tFirst, it takes nSamples samples. For these sampled nodes, the closeness is computed exactly. The pivot of each of the\n\tremaining nodes is the closest sampled node to it. If a node lies very close to its pivot, a sampling approach is used.\n\tOtherwise, a pivoting approach is used. Notice that the input graph has to be connected.\n\n\tParameter :code:`type` can be one of the following:\n\n\t- networkit.centrality.ClosenessType.INBOUND\n\t- networkit.centrality.ClosenessType.OUTBOUND\n\t- networkit.centrality.ClosenessType.SUM\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tInput graph (undirected).\n\tnSamples : int\n\t\tUser defined number of samples.\n\tepsilon : float, optional\n\t\tParameter used for the error guarantee; it is also used to control when to use sampling and when to use pivoting. Default: 0.1\n\tnormalized : bool, optional\n\t\tNormalize centrality values in interval [0,1]. Default: False\n\ttype : networkit.centrality.ClosenessType, optional\n\t\tUse in- or outbound centrality or the sum of both (see paper) for computing closeness on directed graph. \n\t\tIf G is undirected, this can be ignored. Default: networkit.centrality.ClosenessType.OUTBOUND\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ApproxCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ApproxCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DegreeCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_16DegreeCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DegreeCentrality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DegreeCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tDegreeCentrality(G, normalized=False, outDeg=True, ignoreSelfLoops=True)\n\t\n\tNode centrality index which ranks nodes by their degree.\n\tOptional normalization by maximum degree.  run() runs in O(n) time if ignoreSelfLoops is false or the graph \n\thas no self-loops; otherwise it runs in O(m).\n\n\tConstructs the DegreeCentrality class for the given Graph `G`. If the scores should be normalized,\n\tthen set `normalized` to True.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tnormalized : bool, optional\n\t\tNormalize centrality values in the interval [0,1]. Default: False\n\toutdeg : bool, optional\n\t\tIf set to true, computes the centrality based on out-degrees, otherwise based on the in-degrees. Default: True\n\tignoreSelfLoops : bool, optional\n\t\tIf set to true, self loops will not be taken into account. Default: True\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DegreeCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DegreeCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DegreeCentrality_spec = {
  "networkit.centrality.DegreeCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_DegreeCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DegreeCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DegreeCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DegreeCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DegreeCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tDegreeCentrality(G, normalized=False, outDeg=True, ignoreSelfLoops=True)\n\t\n\tNode centrality index which ranks nodes by their degree.\n\tOptional normalization by maximum degree.  run() runs in O(n) time if ignoreSelfLoops is false or the graph \n\thas no self-loops; otherwise it runs in O(m).\n\n\tConstructs the DegreeCentrality class for the given Graph `G`. If the scores should be normalized,\n\tthen set `normalized` to True.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tnormalized : bool, optional\n\t\tNormalize centrality values in the interval [0,1]. Default: False\n\toutdeg : bool, optional\n\t\tIf set to true, computes the centrality based on out-degrees, otherwise based on the in-degrees. Default: True\n\tignoreSelfLoops : bool, optional\n\t\tIf set to true, self loops will not be taken into account. Default: True\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DegreeCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DegreeCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_HarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_17HarmonicCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_HarmonicCloseness[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_HarmonicCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tHarmonicCloseness(G, normalized=True)\n\n\tConstructs the HarmonicCloseness class for the given Graph `G`.\n\tIf the harmonic closeness scores should not be normalized, set\n\t`normalized` to False.\n\tThe run() method takes O(nm) time, where n is the number\n\tof nodes and m is the number of edges of the graph.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tnormalized : bool, optional\n \t\tSet this parameter to False if scores should not be normalized \n\t\tinto an interval of [0,1]. Normalization only for unweighted graphs. Default: True\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_HarmonicCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_HarmonicCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_HarmonicCloseness_spec = {
  "networkit.centrality.HarmonicCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_HarmonicCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_HarmonicCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_HarmonicCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""HarmonicCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_HarmonicCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tHarmonicCloseness(G, normalized=True)\n\n\tConstructs the HarmonicCloseness class for the given Graph `G`.\n\tIf the harmonic closeness scores should not be normalized, set\n\t`normalized` to False.\n\tThe run() method takes O(nm) time, where n is the number\n\tof nodes and m is the number of edges of the graph.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tnormalized : bool, optional\n \t\tSet this parameter to False if scores should not be normalized \n\t\tinto an interval of [0,1]. Normalization only for unweighted graphs. Default: True\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_HarmonicCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_HarmonicCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_TopCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_TopCloseness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_TopCloseness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_12TopCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_TopCloseness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_TopCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopCloseness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_TopCloseness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_TopCloseness);
}

static int __pyx_tp_traverse_9networkit_10centrality_TopCloseness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_TopCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_TopCloseness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_TopCloseness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_TopCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_TopCloseness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_TopCloseness[] = {
  {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_3topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_2topkNodesList},
  {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_5topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_4topkScoresList},
  {"restrictTopKComputationToNodes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12TopCloseness_6restrictTopKComputationToNodes},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12TopCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_TopCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_TopCloseness},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tTopCloseness(G, k=1, first_heu=True, sec_heu=True)\n\t\n\tFinds the top k nodes with highest closeness centrality faster than computing it for all nodes, \n\tbased on \"Computing Top-k Closeness Centrality Faster in Unweighted Graphs\", Bergamini et al., ALENEX16.\n\tThe algorithms is based on two independent heuristics, described in the referenced paper. We recommend to \n\tuse :math:`first_heu = true` and :math:`second_heu = false` for complex networks and :math:`first_heu = true` \n\tand :math:`second_heu = true` for street networks or networks with large diameters.\n\n\tNotes\n\t-----\n\tThe worst case running time of the algorithm is :math:`O(nm)`, where n is the number of nodes and m is the number of edges.\n\tHowever, for most networks the empirical running time is :math:`O(m)`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int\n\t\tNumber of nodes with highest closeness that have to be found. \n\t\tFor example, if k = 10, the top 10 nodes with highest closeness will be computed.\n\tfirst_heu : bool, optional\n\t\tIf true, the neighborhood-based lower bound is computed and nodes are sorted according to it. \n\t\tIf false, nodes are simply sorted by degree. Default: True\n\tsec_heu : bool, optional\n\t\tIf true, the BFSbound is re-computed at each iteration. If false, BFScut is used. Default: True\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_TopCloseness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_TopCloseness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_TopCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_TopCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_TopCloseness_spec = {
  "networkit.centrality.TopCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_TopCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_TopCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_TopCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""TopCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_TopCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_TopCloseness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tTopCloseness(G, k=1, first_heu=True, sec_heu=True)\n\t\n\tFinds the top k nodes with highest closeness centrality faster than computing it for all nodes, \n\tbased on \"Computing Top-k Closeness Centrality Faster in Unweighted Graphs\", Bergamini et al., ALENEX16.\n\tThe algorithms is based on two independent heuristics, described in the referenced paper. We recommend to \n\tuse :math:`first_heu = true` and :math:`second_heu = false` for complex networks and :math:`first_heu = true` \n\tand :math:`second_heu = true` for street networks or networks with large diameters.\n\n\tNotes\n\t-----\n\tThe worst case running time of the algorithm is :math:`O(nm)`, where n is the number of nodes and m is the number of edges.\n\tHowever, for most networks the empirical running time is :math:`O(m)`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int\n\t\tNumber of nodes with highest closeness that have to be found. \n\t\tFor example, if k = 10, the top 10 nodes with highest closeness will be computed.\n\tfirst_heu : bool, optional\n\t\tIf true, the neighborhood-based lower bound is computed and nodes are sorted according to it. \n\t\tIf false, nodes are simply sorted by degree. Default: True\n\tsec_heu : bool, optional\n\t\tIf true, the BFSbound is re-computed at each iteration. If false, BFScut is used. Default: True\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_TopCloseness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_TopCloseness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_TopCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_TopCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_TopHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_TopHarmonicCloseness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_TopHarmonicCloseness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_TopHarmonicCloseness);
}

static int __pyx_tp_traverse_9networkit_10centrality_TopHarmonicCloseness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_TopHarmonicCloseness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_TopHarmonicCloseness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_TopHarmonicCloseness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_TopHarmonicCloseness[] = {
  {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_2topkNodesList},
  {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_4topkScoresList},
  {"restrictTopKComputationToNodes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20TopHarmonicCloseness_6restrictTopKComputationToNodes},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_TopHarmonicCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_TopHarmonicCloseness},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tTopHarmonicCloseness(G, k=1, useNBbound=False)\n\n\tFinds the top k nodes with highest harmonic closeness centrality faster\n\tthan computing it for all nodes. The implementation is based on \"Computing\n\tTop-k Centrality Faster in Unweighted Graphs\", Bergamini et al., ALENEX16.\n\tThe algorithm also works with weighted graphs but only if with the NBcut\n\tvariation. We recommend to use useNBbound = False for complex (weighted)\n\tnetworks (or networks with small diameter) and useNBbound = True for\n\tunweighted street networks (or networks with large diameters). \n\t\n\tNotes\n\t-----\n\tNotice that the worst case running time of the algorithm is O(nm), where n is the\n\tnumber of nodes and m is the number of edges. However, for most real-world\n\tnetworks the empirical running time is O(m).\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph. If useNBbound is set to 'True', edge weights will be ignored.\n\tk : int, optional\n\t\tNumber of nodes with highest closeness that have to be found. For example, if k = 10, the\n\t\ttop 10 nodes with highest closeness will be computed. Default: 1\n\tuseNBbound : bool, optional\n\t\tIf True, the NBbound is re-computed at each iteration. If False, NBcut is used. The worst case \n\t\trunning time of the algorithm is :math:`O(nm)`, where n is the number of nodes and m is the number of edges.\n\t\tHowever, for most networks the empirical running time is :math:`O(m)`. Default: False\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_TopHarmonicCloseness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_TopHarmonicCloseness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_TopHarmonicCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_TopHarmonicCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_TopHarmonicCloseness_spec = {
  "networkit.centrality.TopHarmonicCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_TopHarmonicCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_TopHarmonicCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""TopHarmonicCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_TopHarmonicCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_TopHarmonicCloseness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tTopHarmonicCloseness(G, k=1, useNBbound=False)\n\n\tFinds the top k nodes with highest harmonic closeness centrality faster\n\tthan computing it for all nodes. The implementation is based on \"Computing\n\tTop-k Centrality Faster in Unweighted Graphs\", Bergamini et al., ALENEX16.\n\tThe algorithm also works with weighted graphs but only if with the NBcut\n\tvariation. We recommend to use useNBbound = False for complex (weighted)\n\tnetworks (or networks with small diameter) and useNBbound = True for\n\tunweighted street networks (or networks with large diameters). \n\t\n\tNotes\n\t-----\n\tNotice that the worst case running time of the algorithm is O(nm), where n is the\n\tnumber of nodes and m is the number of edges. However, for most real-world\n\tnetworks the empirical running time is O(m).\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph. If useNBbound is set to 'True', edge weights will be ignored.\n\tk : int, optional\n\t\tNumber of nodes with highest closeness that have to be found. For example, if k = 10, the\n\t\ttop 10 nodes with highest closeness will be computed. Default: 1\n\tuseNBbound : bool, optional\n\t\tIf True, the NBbound is re-computed at each iteration. If False, NBcut is used. The worst case \n\t\trunning time of the algorithm is :math:`O(nm)`, where n is the number of nodes and m is the number of edges.\n\t\tHowever, for most networks the empirical running time is :math:`O(m)`. Default: False\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_TopHarmonicCloseness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_TopHarmonicCloseness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_TopHarmonicCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_TopHarmonicCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DynTopHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_DynTopHarmonicCloseness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_DynTopHarmonicCloseness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_DynTopHarmonicCloseness);
}

static int __pyx_tp_traverse_9networkit_10centrality_DynTopHarmonicCloseness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_DynTopHarmonicCloseness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_DynTopHarmonicCloseness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_DynTopHarmonicCloseness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DynTopHarmonicCloseness[] = {
  {"ranking", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_2ranking},
  {"topkNodesList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_4topkNodesList},
  {"topkScoresList", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_23DynTopHarmonicCloseness_6topkScoresList},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_DynTopHarmonicCloseness},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tDynTopHarmonicCloseness(G, k=1, useBFSbound=True)\n\t\n\tFinds the top k nodes with highest harmonic closeness centrality faster\n\tthan computing it for all nodes and updates them after a single or multiple\n\tedge update. The implementation is based on \"Computing Top-k Closeness\n\tCentrality in Fully-dynamic Graphs\", Bisenius et al., ALENEX18.\n\tThe implementation is based on the static algorithms by Borassi et al.\n\t(complex networks) and Bergamini et al. (large-diameter networks).\n\n\tNotes\n\t-----\n\tThe worst case running time of the algorithm is O(nm), where n is the number of nodes and m is the number of edges.\n\tHowever, for most networks the empirical running time is O(m).\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int, optional\n\t\tNumber of nodes with highest closeness that have to be found. \n\t\tFor example, if k = 10, the top 10 nodes with highest closeness will be computed. Default: 1\n\tuseBFSbound : bool, optional\n\t\tIf true, the BFSbound is re-computed at each iteration. If false, BFScut is used. Default: True\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_DynTopHarmonicCloseness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_DynTopHarmonicCloseness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DynTopHarmonicCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DynTopHarmonicCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_spec = {
  "networkit.centrality.DynTopHarmonicCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DynTopHarmonicCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DynTopHarmonicCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DynTopHarmonicCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_DynTopHarmonicCloseness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tDynTopHarmonicCloseness(G, k=1, useBFSbound=True)\n\t\n\tFinds the top k nodes with highest harmonic closeness centrality faster\n\tthan computing it for all nodes and updates them after a single or multiple\n\tedge update. The implementation is based on \"Computing Top-k Closeness\n\tCentrality in Fully-dynamic Graphs\", Bisenius et al., ALENEX18.\n\tThe implementation is based on the static algorithms by Borassi et al.\n\t(complex networks) and Bergamini et al. (large-diameter networks).\n\n\tNotes\n\t-----\n\tThe worst case running time of the algorithm is O(nm), where n is the number of nodes and m is the number of edges.\n\tHowever, for most networks the empirical running time is O(m).\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int, optional\n\t\tNumber of nodes with highest closeness that have to be found. \n\t\tFor example, if k = 10, the top 10 nodes with highest closeness will be computed. Default: 1\n\tuseBFSbound : bool, optional\n\t\tIf true, the BFSbound is re-computed at each iteration. If false, BFScut is used. Default: True\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_DynTopHarmonicCloseness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_DynTopHarmonicCloseness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DynTopHarmonicCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DynTopHarmonicCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_LocalPartitionCoverage(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *p;
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)o);
  p->_P = ((struct __pyx_obj_9networkit_10structures_Partition *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_LocalPartitionCoverage(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *p = (struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_LocalPartitionCoverage) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_P);
  PyObject_GC_Track(o);
  __pyx_tp_dealloc_9networkit_10centrality_Centrality(o);
}

static int __pyx_tp_traverse_9networkit_10centrality_LocalPartitionCoverage(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *p = (struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)o;
  e = __pyx_tp_traverse_9networkit_10centrality_Centrality(o, v, a); if (e) return e;
  if (p->_P) {
    e = (*v)(((PyObject *)p->_P), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_LocalPartitionCoverage(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *p = (struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage *)o;
  __pyx_tp_clear_9networkit_10centrality_Centrality(o);
  tmp = ((PyObject*)p->_P);
  p->_P = ((struct __pyx_obj_9networkit_10structures_Partition *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_LocalPartitionCoverage[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_LocalPartitionCoverage_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_LocalPartitionCoverage},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tLocalPartitionCoverage(G, P)\n\n\tThe local partition coverage is the amount of neighbors of a node u that are in the same partition as u.\n\tThe running time of the run() method is O(m), where m is the number of edges in the graph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tP : networkit.Partition\n\t\tThe partition to use.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_LocalPartitionCoverage},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_LocalPartitionCoverage},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_LocalPartitionCoverage},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_LocalPartitionCoverage},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_LocalPartitionCoverage_spec = {
  "networkit.centrality.LocalPartitionCoverage",
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_LocalPartitionCoverage_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_LocalPartitionCoverage = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""LocalPartitionCoverage", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalPartitionCoverage), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_LocalPartitionCoverage, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tLocalPartitionCoverage(G, P)\n\n\tThe local partition coverage is the amount of neighbors of a node u that are in the same partition as u.\n\tThe running time of the run() method is O(m), where m is the number of edges in the graph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tP : networkit.Partition\n\t\tThe partition to use.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_LocalPartitionCoverage, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_LocalPartitionCoverage, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_LocalPartitionCoverage, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_LocalPartitionCoverage, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupDegree(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupDegree *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupDegree *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_11GroupDegree_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupDegree(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupDegree *p = (struct __pyx_obj_9networkit_10centrality_GroupDegree *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupDegree) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupDegree);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupDegree(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupDegree *p = (struct __pyx_obj_9networkit_10centrality_GroupDegree *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupDegree); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupDegree(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupDegree *p = (struct __pyx_obj_9networkit_10centrality_GroupDegree *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupDegree); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupDegree[] = {
  {"groupMaxDegree", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_3groupMaxDegree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_2groupMaxDegree},
  {"getScore", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_5getScore, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_4getScore},
  {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_7scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_11GroupDegree_6scoreOfGroup},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_11GroupDegree_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupDegree_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupDegree},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupDegree(G, k = 1, countGroupNodes = True)\n\n\tFinds the group with the highest group degree centrality according to the\n\tdefinition proposed in 'The centrality of groups and classes' by Everett et\n\tal. (The Journal of mathematical sociology, 1999). This is a submodular but\n\tnon monotone function so the algorithm can find a solution that is at least\n\t1/2 of the optimum. Worst-case running time is quadratic, but usually\n\tfaster in real-world networks.\n\tThe `countGroupNodes` option also count the nodes inside the group in the\n\tscore, this make the group degree monotone and submodular and the algorithm\n\tis guaranteed to return a :math:`(1 - 1/e)`-approximation of the optimal solution.\n\n\tParameters\n\t----------\n\t\tG : networkit.Graph\n\t\t\tThe input graph.\n\t\tk: int, optional\n\t\t\tSize of the group of nodes. Default: 1\n\t\tcountGroupNodes: bool, optional\n\t\t\tIf nodes inside the group should be counted in the centrality score. Default: True\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupDegree},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupDegree},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupDegree},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupDegree},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupDegree_spec = {
  "networkit.centrality.GroupDegree",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupDegree),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupDegree_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupDegree = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupDegree", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupDegree), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupDegree, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupDegree(G, k = 1, countGroupNodes = True)\n\n\tFinds the group with the highest group degree centrality according to the\n\tdefinition proposed in 'The centrality of groups and classes' by Everett et\n\tal. (The Journal of mathematical sociology, 1999). This is a submodular but\n\tnon monotone function so the algorithm can find a solution that is at least\n\t1/2 of the optimum. Worst-case running time is quadratic, but usually\n\tfaster in real-world networks.\n\tThe `countGroupNodes` option also count the nodes inside the group in the\n\tscore, this make the group degree monotone and submodular and the algorithm\n\tis guaranteed to return a :math:`(1 - 1/e)`-approximation of the optimal solution.\n\n\tParameters\n\t----------\n\t\tG : networkit.Graph\n\t\t\tThe input graph.\n\t\tk: int, optional\n\t\t\tSize of the group of nodes. Default: 1\n\t\tcountGroupNodes: bool, optional\n\t\t\tIf nodes inside the group should be counted in the centrality score. Default: True\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupDegree, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupDegree, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupDegree, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupDegree, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GedWalk(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GedWalk *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GedWalk *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_7GedWalk_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GedWalk(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GedWalk *p = (struct __pyx_obj_9networkit_10centrality_GedWalk *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GedWalk) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  {
    PyObject *etype, *eval, *etb;
    PyErr_Fetch(&etype, &eval, &etb);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
    __pyx_pw_9networkit_10centrality_7GedWalk_3__dealloc__(o);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
    PyErr_Restore(etype, eval, etb);
  }
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GedWalk);
}

static int __pyx_tp_traverse_9networkit_10centrality_GedWalk(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GedWalk *p = (struct __pyx_obj_9networkit_10centrality_GedWalk *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GedWalk); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GedWalk(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GedWalk *p = (struct __pyx_obj_9networkit_10centrality_GedWalk *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GedWalk); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GedWalk[] = {
  {"groupMaxGedWalk", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_5groupMaxGedWalk, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_4groupMaxGedWalk},
  {"getApproximateScore", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_7getApproximateScore, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_6getApproximateScore},
  {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_9scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_7GedWalk_8scoreOfGroup},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_7GedWalk_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GedWalk_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GedWalk},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGedWalk(Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = networkit.centrality.BoundStrategy.GEOMETRIC, gs = networkit.centrality.GreedyStrategy.LAZY, spectralDelta = 0.5)\n\n\tFinds a group of `k` vertices with at least ((1 - 1/e) * opt - epsilon) GedWalk centrality\n\tscore, where opt is the highest possible score. The algorithm is based on the paper \"Group\n\tCentrality Maximization for Large-scale Graphs\", Angriman et al., ALENEX20. It implements two\n\tindependent greedy strategies (lazy and stochastic). Furthermore, it allows to compute the\n\tGedWalk score of a given set of nodes.\n\n\tParameter :code:`bs` can be one of the following:\n\n\t- networkit.centrality.BoundStrategy.NO\n\t- networkit.centrality.BoundStrategy.SPECTRAL\n\t- networkit.centrality.BoundStrategy.GEOMETRIC\n\t- networkit.centrality.BoundStrategy.ADAPTIVE_GEOMETRIC\n\n\tParameter :code:`gs` can be one of the following:\n\n\t- networkit.centrality.GreedyStrategy.LAZY\n\t- networkit.centrality.GreedyStrategy.STOCHASTIC\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA (weakly) connected graph.\n\tk : int, optional\n\t\tThe desired group size. Default: 1\n\tepsilon : float, optional\n\t\tPrecision of the algorithm. Default: 0.1\n\talpha : float, optional\n\t\tExponent to compute the GedWalk score. Default: -1.0\n\tbs : networkit.centrality.BoundStrategy, optional\n\t\tBound strategy to compute the GedWalk bounds.\n\t\tDefault: networkit.centrality.BoundStrategy.GEOMETRIC\n\tgs : networkit.centrality.GreedyStrategy, optional\n\t\tGreedy strategy to be used (lazy or stochastic). \n\t\tDefault: networkit.centrality.GreedyStrategy.LAZY\n\tspectralDelta : float, optional\n\t\tDelta to be used for the spectral bound. Default: 0.5\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GedWalk},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GedWalk},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GedWalk},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GedWalk},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GedWalk_spec = {
  "networkit.centrality.GedWalk",
  sizeof(struct __pyx_obj_9networkit_10centrality_GedWalk),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GedWalk_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GedWalk = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GedWalk", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GedWalk), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GedWalk, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGedWalk(Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = networkit.centrality.BoundStrategy.GEOMETRIC, gs = networkit.centrality.GreedyStrategy.LAZY, spectralDelta = 0.5)\n\n\tFinds a group of `k` vertices with at least ((1 - 1/e) * opt - epsilon) GedWalk centrality\n\tscore, where opt is the highest possible score. The algorithm is based on the paper \"Group\n\tCentrality Maximization for Large-scale Graphs\", Angriman et al., ALENEX20. It implements two\n\tindependent greedy strategies (lazy and stochastic). Furthermore, it allows to compute the\n\tGedWalk score of a given set of nodes.\n\n\tParameter :code:`bs` can be one of the following:\n\n\t- networkit.centrality.BoundStrategy.NO\n\t- networkit.centrality.BoundStrategy.SPECTRAL\n\t- networkit.centrality.BoundStrategy.GEOMETRIC\n\t- networkit.centrality.BoundStrategy.ADAPTIVE_GEOMETRIC\n\n\tParameter :code:`gs` can be one of the following:\n\n\t- networkit.centrality.GreedyStrategy.LAZY\n\t- networkit.centrality.GreedyStrategy.STOCHASTIC\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA (weakly) connected graph.\n\tk : int, optional\n\t\tThe desired group size. Default: 1\n\tepsilon : float, optional\n\t\tPrecision of the algorithm. Default: 0.1\n\talpha : float, optional\n\t\tExponent to compute the GedWalk score. Default: -1.0\n\tbs : networkit.centrality.BoundStrategy, optional\n\t\tBound strategy to compute the GedWalk bounds.\n\t\tDefault: networkit.centrality.BoundStrategy.GEOMETRIC\n\tgs : networkit.centrality.GreedyStrategy, optional\n\t\tGreedy strategy to be used (lazy or stochastic). \n\t\tDefault: networkit.centrality.GreedyStrategy.LAZY\n\tspectralDelta : float, optional\n\t\tDelta to be used for the spectral bound. Default: 0.5\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GedWalk, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GedWalk, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GedWalk, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GedWalk, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxGroupBetweenness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_ApproxGroupBetweenness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *p = (struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_ApproxGroupBetweenness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_ApproxGroupBetweenness);
}

static int __pyx_tp_traverse_9networkit_10centrality_ApproxGroupBetweenness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *p = (struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_ApproxGroupBetweenness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_ApproxGroupBetweenness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *p = (struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_ApproxGroupBetweenness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ApproxGroupBetweenness[] = {
  {"groupMaxBetweenness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22ApproxGroupBetweenness_2groupMaxBetweenness},
  {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22ApproxGroupBetweenness_4scoreOfGroup},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ApproxGroupBetweenness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_ApproxGroupBetweenness},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tApproxGroupBetweenness(G, groupSize, epsilon)\n\n\tConstructs the ApproxGroupBetweenness class for a given undirected Graph\n\t`G`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tgroupSize : int\n\t\tThe desired size of the group.\n\tepsilon : float\n\t\tDetermines the accuracy of the approximation.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_ApproxGroupBetweenness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_ApproxGroupBetweenness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ApproxGroupBetweenness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ApproxGroupBetweenness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ApproxGroupBetweenness_spec = {
  "networkit.centrality.ApproxGroupBetweenness",
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ApproxGroupBetweenness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ApproxGroupBetweenness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ApproxGroupBetweenness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxGroupBetweenness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_ApproxGroupBetweenness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tApproxGroupBetweenness(G, groupSize, epsilon)\n\n\tConstructs the ApproxGroupBetweenness class for a given undirected Graph\n\t`G`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tgroupSize : int\n\t\tThe desired size of the group.\n\tepsilon : float\n\t\tDetermines the accuracy of the approximation.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_ApproxGroupBetweenness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_ApproxGroupBetweenness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ApproxGroupBetweenness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ApproxGroupBetweenness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupCloseness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupCloseness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_14GroupCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupCloseness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupCloseness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupCloseness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupCloseness);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupCloseness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupCloseness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupCloseness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupCloseness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupCloseness[] = {
  {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_2groupMaxCloseness},
  {"computeFarness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_5computeFarness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_4computeFarness},
  {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_7scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_14GroupCloseness_6scoreOfGroup},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14GroupCloseness_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupCloseness},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupCloseness(G, k=1, H=0)\n\t\n\tFinds the group of nodes with highest (group) closeness centrality. The algorithm is the one \n\tproposed in Bergamini et al., ALENEX 2018 and finds a solution that is a (1-1/e)-approximation of the optimum.\n\tThe worst-case running time of this approach is quadratic, but usually much faster in practice.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int, optional\n\t\tSize of the group. Default: 1\n\tH : int, optional\n\t\tIf equal 0, simply runs the algorithm proposed in Bergamini et al.. \n\t\tIf > 0, interrupts all BFSs after H iterations (suggested for very large networks). Default: 0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupCloseness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupCloseness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupCloseness_spec = {
  "networkit.centrality.GroupCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupCloseness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupCloseness(G, k=1, H=0)\n\t\n\tFinds the group of nodes with highest (group) closeness centrality. The algorithm is the one \n\tproposed in Bergamini et al., ALENEX 2018 and finds a solution that is a (1-1/e)-approximation of the optimum.\n\tThe worst-case running time of this approach is quadratic, but usually much faster in practice.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn unweighted graph.\n\tk : int, optional\n\t\tSize of the group. Default: 1\n\tH : int, optional\n\t\tIf equal 0, simply runs the algorithm proposed in Bergamini et al.. \n\t\tIf > 0, interrupts all BFSs after H iterations (suggested for very large networks). Default: 0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupCloseness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupCloseness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessGrowShrink(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessGrowShrink(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessGrowShrink) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessGrowShrink);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupClosenessGrowShrink(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupClosenessGrowShrink); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupClosenessGrowShrink(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupClosenessGrowShrink); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupClosenessGrowShrink[] = {
  {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessGrowShrink_2groupMaxCloseness},
  {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessGrowShrink_4numberOfIterations},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupClosenessGrowShrink_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupClosenessGrowShrink},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupClosenessGrowShrink(Graph G, group, extended = False, insertions = 0)\n\n\tFinds a group of nodes with high group closeness centrality. This is the Grow-Shrink\n\talgorithm presented in Angriman et al. \"Local Search for Group Closeness Maximization on Big\n\tGraphs\" IEEE BigData 2019. The algorithm takes as input a connected, unweighted, undirected\n\tgraph and an arbitrary group of nodes, and improves the group closeness of the given\n\tgroup by performing vertex exchanges.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA connected, undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\textended : bool, optional\n\t\tSet this parameter to true for the Extended Grow-Shrink algorithm (i.e.,\n\t\tswaps are not restricted to only neighbors of the group). Default: False\n\tinsertions : int, optional\n\t\tNumber of consecutive node insertions and removal per iteration. Let this\n\t\tparameter to zero to use Diameter(G)/sqrt(k) nodes (where k is the size of the group). Default: 0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupClosenessGrowShrink},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupClosenessGrowShrink},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupClosenessGrowShrink},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupClosenessGrowShrink},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupClosenessGrowShrink_spec = {
  "networkit.centrality.GroupClosenessGrowShrink",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupClosenessGrowShrink_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupClosenessGrowShrink = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupClosenessGrowShrink", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessGrowShrink), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessGrowShrink, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupClosenessGrowShrink(Graph G, group, extended = False, insertions = 0)\n\n\tFinds a group of nodes with high group closeness centrality. This is the Grow-Shrink\n\talgorithm presented in Angriman et al. \"Local Search for Group Closeness Maximization on Big\n\tGraphs\" IEEE BigData 2019. The algorithm takes as input a connected, unweighted, undirected\n\tgraph and an arbitrary group of nodes, and improves the group closeness of the given\n\tgroup by performing vertex exchanges.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA connected, undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\textended : bool, optional\n\t\tSet this parameter to true for the Extended Grow-Shrink algorithm (i.e.,\n\t\tswaps are not restricted to only neighbors of the group). Default: False\n\tinsertions : int, optional\n\t\tNumber of consecutive node insertions and removal per iteration. Let this\n\t\tparameter to zero to use Diameter(G)/sqrt(k) nodes (where k is the size of the group). Default: 0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupClosenessGrowShrink, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupClosenessGrowShrink, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupClosenessGrowShrink, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupClosenessGrowShrink, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSwaps(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSwaps(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSwaps) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSwaps);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSwaps(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSwaps); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSwaps(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSwaps); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupClosenessLocalSwaps[] = {
  {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessLocalSwaps_2groupMaxCloseness},
  {"numberOfSwaps", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_24GroupClosenessLocalSwaps_4numberOfSwaps},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSwaps},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupClosenessLocalSwaps(Graph G, group, maxSwaps = 0)\n\n\tFinds a group of nodes with high group closeness centrality. This is\n\tthe LS-restrict algorithm presented in Angriman et al. \"Local Search\n\tfor Group Closeness Maximization on Big Graphs\" IEEE BigData 2019. The\n\talgorithm takes as input a graph and an arbitrary group of nodes, and\n\timproves the group closeness of the given\n\tgroup by performing vertex exchanges.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\tmaxSwaps : int, optional\n\t\tMaximum number of vertex exchanges allowed. Default: 0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSwaps},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSwaps},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupClosenessLocalSwaps},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSwaps},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps_spec = {
  "networkit.centrality.GroupClosenessLocalSwaps",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupClosenessLocalSwaps", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSwaps), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSwaps, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupClosenessLocalSwaps(Graph G, group, maxSwaps = 0)\n\n\tFinds a group of nodes with high group closeness centrality. This is\n\tthe LS-restrict algorithm presented in Angriman et al. \"Local Search\n\tfor Group Closeness Maximization on Big Graphs\" IEEE BigData 2019. The\n\talgorithm takes as input a graph and an arbitrary group of nodes, and\n\timproves the group closeness of the given\n\tgroup by performing vertex exchanges.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tAn undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\tmaxSwaps : int, optional\n\t\tMaximum number of vertex exchanges allowed. Default: 0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSwaps, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSwaps, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupClosenessLocalSwaps, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSwaps, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupHarmonicCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupHarmonicCloseness(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupHarmonicCloseness) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupHarmonicCloseness);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupHarmonicCloseness(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupHarmonicCloseness); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupHarmonicCloseness(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *p = (struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupHarmonicCloseness); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupHarmonicCloseness[] = {
  {"groupMaxHarmonicCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22GroupHarmonicCloseness_2groupMaxHarmonicCloseness},
  {"scoreOfGroup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22GroupHarmonicCloseness_4scoreOfGroup},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupHarmonicCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupHarmonicCloseness},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupHarmonicCloseness(Graph G, k = 1)\n\n\tApproximation algorithm for the group-harmonic maximization problem. The\n\tcomputed solutions have a guaranteed :math:`\\lambda(1 - \\frac{1}{2e})`\n\t(directed graphs) and :math:`\\lambda(1 - \\frac{1}{e})/2` (undirected graphs)\n\tapproximation ratio, where :math:`\\lambda` is the ratio between the minimal and\n\tthe maximal edge weight. The algorithm is the one proposed in Angriman et\n\tal., ALENEX 2021. \n\t\n\tNotes\n\t-----\n\tThe worst-case running time of this approach is\n\tquadratic, but usually much faster in practice.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tk : int, optional\n\t\tSize of the group of nodes. Default: 1\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupHarmonicCloseness},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupHarmonicCloseness},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupHarmonicCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupHarmonicCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupHarmonicCloseness_spec = {
  "networkit.centrality.GroupHarmonicCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupHarmonicCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupHarmonicCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupHarmonicCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupHarmonicCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupHarmonicCloseness, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupHarmonicCloseness(Graph G, k = 1)\n\n\tApproximation algorithm for the group-harmonic maximization problem. The\n\tcomputed solutions have a guaranteed :math:`\\lambda(1 - \\frac{1}{2e})`\n\t(directed graphs) and :math:`\\lambda(1 - \\frac{1}{e})/2` (undirected graphs)\n\tapproximation ratio, where :math:`\\lambda` is the ratio between the minimal and\n\tthe maximal edge weight. The algorithm is the one proposed in Angriman et\n\tal., ALENEX 2021. \n\t\n\tNotes\n\t-----\n\tThe worst-case running time of this approach is\n\tquadratic, but usually much faster in practice.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tk : int, optional\n\t\tSize of the group of nodes. Default: 1\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupHarmonicCloseness, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupHarmonicCloseness, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupHarmonicCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupHarmonicCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSearch(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_5__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSearch(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSearch) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSearch);
}

static int __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSearch(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSearch); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSearch(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *p = (struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSearch); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_GroupClosenessLocalSearch[] = {
  {"groupMaxCloseness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25GroupClosenessLocalSearch_6groupMaxCloseness},
  {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25GroupClosenessLocalSearch_8numberOfIterations},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_GroupClosenessLocalSearch_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSearch},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tGroupClosenessLocalSearch(Graph G, group, runGrowShrink, maxIterations)\n\n\tLocal search approximation algorithm for Group Closeness Maximization presented in\n\t\"Group-Harmonic and Group-Closeness Maximization \342\200\223 Approximation and Engineering\", Angriman\n\tet al., ALENEX 2021. The algorithm evaluates all possible swaps between a vertex in the group\n\tand the vertices outside, and performs a swap iff the decrement in farness is at least :math:`(1 -\n\t1 / (k \\cdot (n - k)))`, where `k` is the number of vertices in the group. Thus,\n\teven in a best-case scenario the time complexity of this algorithm is :math:`O(n \\cdot k)`. To\n\tkeep the number of swaps low, it is recommended to use this algorithm as a refinement step of\n\tan already good solution computed by a faster algorithm e.g., greedy (GroupCloseness), or\n\tGrowShrink (GroupClosenessGrowShrink). In undirected graphs the approximation ratio is 1/5,\n\ton directed graphs it has not been demonstrated.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA connected, undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\tuseGrowShrink : bool\n\t\tWhether or not to run the GrowShrink algorithm on the initial group.\n\tmaxIterations : int\n\t\tMaximum number of swaps allowed. Prevents the algorithm from performing\n\t\ttoo many swaps by giving up the approximation guarantee.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSearch},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSearch},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_GroupClosenessLocalSearch},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSearch},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_GroupClosenessLocalSearch_spec = {
  "networkit.centrality.GroupClosenessLocalSearch",
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_GroupClosenessLocalSearch_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_GroupClosenessLocalSearch = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""GroupClosenessLocalSearch", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_GroupClosenessLocalSearch), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_GroupClosenessLocalSearch, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tGroupClosenessLocalSearch(Graph G, group, runGrowShrink, maxIterations)\n\n\tLocal search approximation algorithm for Group Closeness Maximization presented in\n\t\"Group-Harmonic and Group-Closeness Maximization \342\200\223 Approximation and Engineering\", Angriman\n\tet al., ALENEX 2021. The algorithm evaluates all possible swaps between a vertex in the group\n\tand the vertices outside, and performs a swap iff the decrement in farness is at least :math:`(1 -\n\t1 / (k \\cdot (n - k)))`, where `k` is the number of vertices in the group. Thus,\n\teven in a best-case scenario the time complexity of this algorithm is :math:`O(n \\cdot k)`. To\n\tkeep the number of swaps low, it is recommended to use this algorithm as a refinement step of\n\tan already good solution computed by a faster algorithm e.g., greedy (GroupCloseness), or\n\tGrowShrink (GroupClosenessGrowShrink). In undirected graphs the approximation ratio is 1/5,\n\ton directed graphs it has not been demonstrated.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tA connected, undirected, unweighted graph.\n\tgroup : list(int)\n\t\tThe initial group of nodes.\n\tuseGrowShrink : bool\n\t\tWhether or not to run the GrowShrink algorithm on the initial group.\n\tmaxIterations : int\n\t\tMaximum number of swaps allowed. Prevents the algorithm from performing\n\t\ttoo many swaps by giving up the approximation guarantee.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_GroupClosenessLocalSearch, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_GroupClosenessLocalSearch, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_GroupClosenessLocalSearch, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_GroupClosenessLocalSearch, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_KPathCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_15KPathCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_KPathCentrality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15KPathCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15KPathCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_KPathCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tKPathCentrality(G, alpha=0.2, k=0)\n\n\tConstructs the K-Path Centrality class for the given Graph `G`.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe graph.\n \talpha : float, optional\n\t\tTradeoff between runtime and precision with -0.5: maximum precision, maximum runtime\n \t\tand 0.5: lowest precision, lowest runtime. Default: 0.2\n\tk: int, optional\n\t\tmaximum length of paths. Default: 0\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_KPathCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_KPathCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_KPathCentrality_spec = {
  "networkit.centrality.KPathCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_KPathCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_KPathCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_KPathCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""KPathCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_KPathCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tKPathCentrality(G, alpha=0.2, k=0)\n\n\tConstructs the K-Path Centrality class for the given Graph `G`.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe graph.\n \talpha : float, optional\n\t\tTradeoff between runtime and precision with -0.5: maximum precision, maximum runtime\n \t\tand 0.5: lowest precision, lowest runtime. Default: 0.2\n\tk: int, optional\n\t\tmaximum length of paths. Default: 0\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_KPathCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_KPathCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_KatzCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_14KatzCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyObject *__pyx_getprop_9networkit_10centrality_14KatzCentrality_edgeDirection(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_1__get__(o);
}

static int __pyx_setprop_9networkit_10centrality_14KatzCentrality_edgeDirection(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_9networkit_10centrality_14KatzCentrality_13edgeDirection_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_9networkit_10centrality_KatzCentrality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14KatzCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_14KatzCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_9networkit_10centrality_KatzCentrality[] = {
  {"edgeDirection", __pyx_getprop_9networkit_10centrality_14KatzCentrality_edgeDirection, __pyx_setprop_9networkit_10centrality_14KatzCentrality_edgeDirection, PyDoc_STR("\n\t\tProperty :code:`edgeDirection` can be one of the following:\n\n\t\t- networkit.centrality.EdgeDirection.IN_EDGES\n\t\t- networkit.centrality.EdgeDirection.OUT_EDGES\n\n\t\tDefault: networkit.centrality.EdgeDirection.IN_EDGES\n\t\t"), 0},
  {0, 0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_KatzCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tKatzCentrality(G, alpha=0, beta=0.1, tol=1e-8)\n\n\tConstructs a KatzCentrality object for the given Graph `G`.\n\tEach iteration of the algorithm requires O(m) time.\n\tThe number of iterations depends on how long it takes to reach the convergence\n\t(and therefore on the desired tolerance `tol`).\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \talpha : float, optional\n\t\tDamping of the matrix vector product result, must be non negative.\n\t\tLeave this parameter to 0 to use the default value :math:`1 / (max_degree + 1)`. Default: 0\n\tbeta : float, optional\n\t\tConstant value added to the centrality of each vertex. Default: 0.1\n\ttol : float, optional\n\t\tThe tolerance for convergence. Default: 1e-8\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_KatzCentrality},
  {Py_tp_getset, (void *)__pyx_getsets_9networkit_10centrality_KatzCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_KatzCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_KatzCentrality_spec = {
  "networkit.centrality.KatzCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_KatzCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_KatzCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_KatzCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""KatzCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_KatzCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tKatzCentrality(G, alpha=0, beta=0.1, tol=1e-8)\n\n\tConstructs a KatzCentrality object for the given Graph `G`.\n\tEach iteration of the algorithm requires O(m) time.\n\tThe number of iterations depends on how long it takes to reach the convergence\n\t(and therefore on the desired tolerance `tol`).\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \talpha : float, optional\n\t\tDamping of the matrix vector product result, must be non negative.\n\t\tLeave this parameter to 0 to use the default value :math:`1 / (max_degree + 1)`. Default: 0\n\tbeta : float, optional\n\t\tConstant value added to the centrality of each vertex. Default: 0.1\n\ttol : float, optional\n\t\tThe tolerance for convergence. Default: 1e-8\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_KatzCentrality, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_9networkit_10centrality_KatzCentrality, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_KatzCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_DynKatzCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_17DynKatzCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_DynKatzCentrality[] = {
  {"top", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_3top, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_2top},
  {"bound", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_5bound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_4bound},
  {"areDistinguished", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_7areDistinguished, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17DynKatzCentrality_6areDistinguished},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_DynKatzCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\"\n\tDynKatzCentrality(G, k, groupOnly=False, tolerance=1e-9)\n\n\tFinds the top-k nodes with highest Katz centrality.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tk : float\n\t\tThe number k for which we want to find the top-k nodes with highest Katz centrality.\n\tgroupOnly : bool, optional\n\t\tSet whether the update will only update top-k nodes. Default: False\n\ttolerance : float, optional\n\t\tThe tolerance for convergence. Default: 1e-9\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_DynKatzCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_DynKatzCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_DynKatzCentrality_spec = {
  "networkit.centrality.DynKatzCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_DynKatzCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_DynKatzCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""DynKatzCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_DynKatzCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\"\n\tDynKatzCentrality(G, k, groupOnly=False, tolerance=1e-9)\n\n\tFinds the top-k nodes with highest Katz centrality.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n \tk : float\n\t\tThe number k for which we want to find the top-k nodes with highest Katz centrality.\n\tgroupOnly : bool, optional\n\t\tSet whether the update will only update top-k nodes. Default: False\n\ttolerance : float, optional\n\t\tThe tolerance for convergence. Default: 1e-9\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_DynKatzCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_DynKatzCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_LocalClusteringCoefficient(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_LocalClusteringCoefficient[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_LocalClusteringCoefficient_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tLocalClusteringCoefficient(G, turbo=False)\n\n\tConstructs the LocalClusteringCoefficient class for the given Graph `G`. If the local clustering coefficient values should be normalized,\n\tthen set `normalized` to True. The graph may not contain self-loops.\n\n\tThere are two algorithms available. The trivial (parallel) algorithm needs only a small amount of additional memory.\n\tThe turbo mode adds a (sequential, but fast) pre-processing step using ideas from Triangle Listing Algorithms: Back \n\tfrom the Diversion (Mark Ortmann and Ulrik Brandes). This reduces the running time significantly for most graphs. \n\tHowever, the turbo mode needs O(m) additional memory. In practice this should be a bit less than half of the memory \n\tthat is needed for the graph itself. The turbo mode is particularly effective for graphs with nodes of very high degree \n\tand a very skewed degree distribution.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\tturbo : bool, optional\n\t\tIf the turbo mode shall be activated. Default: False\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_LocalClusteringCoefficient},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_LocalClusteringCoefficient},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_LocalClusteringCoefficient_spec = {
  "networkit.centrality.LocalClusteringCoefficient",
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_LocalClusteringCoefficient_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_LocalClusteringCoefficient = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""LocalClusteringCoefficient", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalClusteringCoefficient), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tLocalClusteringCoefficient(G, turbo=False)\n\n\tConstructs the LocalClusteringCoefficient class for the given Graph `G`. If the local clustering coefficient values should be normalized,\n\tthen set `normalized` to True. The graph may not contain self-loops.\n\n\tThere are two algorithms available. The trivial (parallel) algorithm needs only a small amount of additional memory.\n\tThe turbo mode adds a (sequential, but fast) pre-processing step using ideas from Triangle Listing Algorithms: Back \n\tfrom the Diversion (Mark Ortmann and Ulrik Brandes). This reduces the running time significantly for most graphs. \n\tHowever, the turbo mode needs O(m) additional memory. In practice this should be a bit less than half of the memory \n\tthat is needed for the graph itself. The turbo mode is particularly effective for graphs with nodes of very high degree \n\tand a very skewed degree distribution.\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\tturbo : bool, optional\n\t\tIf the turbo mode shall be activated. Default: False\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_LocalClusteringCoefficient, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_LocalClusteringCoefficient, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_LocalSquareClusteringCoefficient(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_LocalSquareClusteringCoefficient[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tLocalSquareClusteringCoefficient(G)\n\n\tConstructs the LocalSquareClusteringCoefficient class for the given Graph `G`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_LocalSquareClusteringCoefficient},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_LocalSquareClusteringCoefficient},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient_spec = {
  "networkit.centrality.LocalSquareClusteringCoefficient",
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""LocalSquareClusteringCoefficient", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_LocalSquareClusteringCoefficient), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tLocalSquareClusteringCoefficient(G)\n\n\tConstructs the LocalSquareClusteringCoefficient class for the given Graph `G`.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_LocalSquareClusteringCoefficient, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_LocalSquareClusteringCoefficient, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_Sfigality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_9Sfigality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_Sfigality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Sfigality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_9Sfigality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_Sfigality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tSfigality(G)\n\n\tSfigality is a new type of node centrality measures that is high if neighboring nodes have a higher degree, e.g. in social networks, \n\tif your friends have more friends than you. Formally this means: :math:`\\sigma(u) = \\frac{| \\{ v: \\{u,v\\} \\in E, deg(u) < deg(v) \\} |}{ deg(u) }`\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_Sfigality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_Sfigality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_Sfigality_spec = {
  "networkit.centrality.Sfigality",
  sizeof(struct __pyx_obj_9networkit_10centrality_Sfigality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_Sfigality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_Sfigality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""Sfigality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_Sfigality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tSfigality(G)\n\n\tSfigality is a new type of node centrality measures that is high if neighboring nodes have a higher degree, e.g. in social networks, \n\tif your friends have more friends than you. Formally this means: :math:`\\sigma(u) = \\frac{| \\{ v: \\{u,v\\} \\in E, deg(u) < deg(v) \\} |}{ deg(u) }`\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_Sfigality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_Sfigality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_PermanenceCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  p->_P = ((struct __pyx_obj_9networkit_10structures_Partition *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_20PermanenceCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_PermanenceCentrality(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *p = (struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_PermanenceCentrality) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  Py_CLEAR(p->_P);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_PermanenceCentrality);
}

static int __pyx_tp_traverse_9networkit_10centrality_PermanenceCentrality(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *p = (struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_PermanenceCentrality); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  if (p->_P) {
    e = (*v)(((PyObject *)p->_P), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_PermanenceCentrality(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *p = (struct __pyx_obj_9networkit_10centrality_PermanenceCentrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_PermanenceCentrality); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  tmp = ((PyObject*)p->_P);
  p->_P = ((struct __pyx_obj_9networkit_10structures_Partition *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_PermanenceCentrality[] = {
  {"getIntraClustering", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20PermanenceCentrality_2getIntraClustering},
  {"getPermanence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_5getPermanence, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_20PermanenceCentrality_4getPermanence},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_PermanenceCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_PermanenceCentrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tPermanenceCentrality(Graph G, Partition P)\n\n\tThis centrality measure measure how well a vertex belongs to its community. The values are calculated on the fly, the \n\tpartion may be changed in between the requests.\n\tFor details see\tOn the permanence of vertices in network communities (Tanmoy Chakraborty, Sriram Srinivasan, \n\tNiloy Ganguly, Animesh Mukherjee, and Sanjukta Bhowmick. 2014)\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\tP : networkit.Partition\n\t\tPartition for graph G.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_PermanenceCentrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_PermanenceCentrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_PermanenceCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_PermanenceCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_PermanenceCentrality_spec = {
  "networkit.centrality.PermanenceCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_PermanenceCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_PermanenceCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""PermanenceCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_PermanenceCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_PermanenceCentrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tPermanenceCentrality(Graph G, Partition P)\n\n\tThis centrality measure measure how well a vertex belongs to its community. The values are calculated on the fly, the \n\tpartion may be changed in between the requests.\n\tFor details see\tOn the permanence of vertices in network communities (Tanmoy Chakraborty, Sriram Srinivasan, \n\tNiloy Ganguly, Animesh Mukherjee, and Sanjukta Bhowmick. 2014)\n\n \tParameters\n \t----------\n \tG : networkit.Graph\n \t\tThe input graph.\n\tP : networkit.Partition\n\t\tPartition for graph G.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_PermanenceCentrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_PermanenceCentrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_PermanenceCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_PermanenceCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_LaplacianCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_19LaplacianCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_LaplacianCentrality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_LaplacianCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tLaplacianCentrality(G, normalized=False)\n\t\n\tComputes the Laplacian centrality of the graph.\n\n\tNotes\n\t-----\n\tThe implementation is a simplification of the original algorithm proposed by Qi et al. in\n\t\"Laplacian centrality: A new centrality measure for weighted networks\".\n\n\tSee https://dl.acm.org/citation.cfm?id=2181343.2181780 for details.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tnormalized : bool, optional\n\t\tWhether scores should be normalized by the energy of the full graph. Default: False\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_LaplacianCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_LaplacianCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_LaplacianCentrality_spec = {
  "networkit.centrality.LaplacianCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_LaplacianCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_LaplacianCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_LaplacianCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""LaplacianCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_LaplacianCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tLaplacianCentrality(G, normalized=False)\n\t\n\tComputes the Laplacian centrality of the graph.\n\n\tNotes\n\t-----\n\tThe implementation is a simplification of the original algorithm proposed by Qi et al. in\n\t\"Laplacian centrality: A new centrality measure for weighted networks\".\n\n\tSee https://dl.acm.org/citation.cfm?id=2181343.2181780 for details.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\tnormalized : bool, optional\n\t\tWhether scores should be normalized by the energy of the full graph. Default: False\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_LaplacianCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_LaplacianCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_CoreDecomposition(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_17CoreDecomposition_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_CoreDecomposition[] = {
  {"maxCoreNumber", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_2maxCoreNumber},
  {"getCover", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_5getCover, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_4getCover},
  {"getPartition", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_7getPartition, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_6getPartition},
  {"getNodeOrder", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_9getNodeOrder, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_17CoreDecomposition_8getNodeOrder},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_CoreDecomposition_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tCoreDecomposition(G, normalized=False, enforceBucketQueueAlgorithm=False, storeNodeOrder = False)\n\n\tComputes k-core decomposition of a graph. The graph may not contain self-loops.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tnormalized : bool, optional\n\t\tDivide each core number by the maximum degree. Default: False\n\tenforceBucketQueueAlgorithm : bool, optional\n\t\tEnforce switch to sequential algorithm. Default: False\n\tstoreNodeOrder : bool, optional\n\t\tIf set to True, the order of the nodes in ascending order of the cores is stored and can later be returned using getNodeOrder(). \n\t\tEnforces the sequential bucket priority queue algorithm. Default: False\n\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_CoreDecomposition},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_CoreDecomposition},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_CoreDecomposition_spec = {
  "networkit.centrality.CoreDecomposition",
  sizeof(struct __pyx_obj_9networkit_10centrality_CoreDecomposition),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_CoreDecomposition_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_CoreDecomposition = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""CoreDecomposition", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_CoreDecomposition), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tCoreDecomposition(G, normalized=False, enforceBucketQueueAlgorithm=False, storeNodeOrder = False)\n\n\tComputes k-core decomposition of a graph. The graph may not contain self-loops.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\tnormalized : bool, optional\n\t\tDivide each core number by the maximum degree. Default: False\n\tenforceBucketQueueAlgorithm : bool, optional\n\t\tEnforce switch to sequential algorithm. Default: False\n\tstoreNodeOrder : bool, optional\n\t\tIf set to True, the order of the nodes in ascending order of the cores is stored and can later be returned using getNodeOrder(). \n\t\tEnforces the sequential bucket priority queue algorithm. Default: False\n\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_CoreDecomposition, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_CoreDecomposition, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_EigenvectorCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_EigenvectorCentrality[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_EigenvectorCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\t\n\tEigenvectorCentrality(G, tol=1e-9)\n\t\n\tComputes the leading eigenvector of the graph's adjacency matrix (normalized in 2-norm).\n\tInterpreted as eigenvector centrality score.\n\n\tConstructs the EigenvectorCentrality class for the given Graph `G`. `tol` defines the tolerance for convergence.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\ttol : float, optional\n\t\tThe tolerance for convergence.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_EigenvectorCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_EigenvectorCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_EigenvectorCentrality_spec = {
  "networkit.centrality.EigenvectorCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_EigenvectorCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_EigenvectorCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""EigenvectorCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_EigenvectorCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\t\n\tEigenvectorCentrality(G, tol=1e-9)\n\t\n\tComputes the leading eigenvector of the graph's adjacency matrix (normalized in 2-norm).\n\tInterpreted as eigenvector centrality score.\n\n\tConstructs the EigenvectorCentrality class for the given Graph `G`. `tol` defines the tolerance for convergence.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\ttol : float, optional\n\t\tThe tolerance for convergence.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_EigenvectorCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_EigenvectorCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_PageRank(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_8PageRank_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyObject *__pyx_getprop_9networkit_10centrality_8PageRank_norm(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_9networkit_10centrality_8PageRank_4norm_1__get__(o);
}

static int __pyx_setprop_9networkit_10centrality_8PageRank_norm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_9networkit_10centrality_8PageRank_4norm_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_9networkit_10centrality_8PageRank_maxIterations(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_1__get__(o);
}

static int __pyx_setprop_9networkit_10centrality_8PageRank_maxIterations(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_9networkit_10centrality_8PageRank_13maxIterations_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_9networkit_10centrality_PageRank[] = {
  {"numberOfIterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_3numberOfIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_8PageRank_2numberOfIterations},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_8PageRank_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_9networkit_10centrality_PageRank[] = {
  {"norm", __pyx_getprop_9networkit_10centrality_8PageRank_norm, __pyx_setprop_9networkit_10centrality_8PageRank_norm, PyDoc_STR("\n\t\tProperty :code:`norm` can be one of the following:\n\n\t\t- networkit.centrality.Norm.L1_NORM\n\t\t- networkit.centrality.Norm.L2_NORM\n\n\t\tSet this property before calling run() to change norm computation.\n\t\tDefault: networkit.centrality.Norm.L2_NORM\n\t\t"), 0},
  {"maxIterations", __pyx_getprop_9networkit_10centrality_8PageRank_maxIterations, __pyx_setprop_9networkit_10centrality_8PageRank_maxIterations, PyDoc_STR("\n\t\tProperty :code:`maxIterations` sets a stopping criteria based on number\n\t\tof runs. Default: unlimited\n\t\t"), 0},
  {0, 0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_PageRank_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tPageRank(G, damp=0.85, tol=1e-9, normalized=False, distributeSinks=SinkHandling.NoSinkHandling)\n\t\n\tCompute PageRank as node centrality measure. In the default mode this computation is in line\n \twith the original paper \"The PageRank citation ranking: Bringing order to the web.\" by L. Brin et al (1999).\n \tIn later publications (\"PageRank revisited.\" by M. Brinkmeyer et al. (2005) amongst others) sink-node handling\n \twas added for directed graphs in order to comply with the theoretical assumptions by the underlying \n \tMarkov chain model. This can be activated by setting the matching parameter to true. By default \n \tthis is disabled, since it is an addition to the original definition.\n\t\n \tPage-Rank values can also be normalized by post-processed according to \"Comparing Apples and\n \tOranges: Normalized PageRank for Evolving Graphs\" by Berberich et al. (2007). This decouples\n \tthe PageRank values from the size of the input graph. To enable this, set the matching parameter\n \tto true. Note that, sink-node handling is automatically activated if normalization is used.\n\n\tParameter :code:`distributeSinks` can be one of the following:\n\n\t- networkit.centrality.SinkHandling.NO_SINK_HANDLING\n\t- networkit.centrality.SinkHandling.DISTRIBUTE_SINKS\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tGraph to be processed.\n\tdamp : float, optional\n\t\tDamping factor of the PageRank algorithm. Default: 0.85\n\ttol : float, optional\n\t\tError tolerance for PageRank iteration. Default: 1e-8\n\tdistributeSinks: networkit.centrality.SinkHandling, optional\n\t\tSet to distribute PageRank values for sink nodes. Default: SinkHandling.NO_SINK_HANDLING\n\tnormalized : bool, optional\n\t\tIf the results should be normalized by the lower bound of scores. \n\t\tThis decouples the PageRank values from the size of the input graph. Default: False\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_PageRank},
  {Py_tp_getset, (void *)__pyx_getsets_9networkit_10centrality_PageRank},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_PageRank},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_PageRank_spec = {
  "networkit.centrality.PageRank",
  sizeof(struct __pyx_obj_9networkit_10centrality_PageRank),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_PageRank_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_PageRank = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""PageRank", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_PageRank), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tPageRank(G, damp=0.85, tol=1e-9, normalized=False, distributeSinks=SinkHandling.NoSinkHandling)\n\t\n\tCompute PageRank as node centrality measure. In the default mode this computation is in line\n \twith the original paper \"The PageRank citation ranking: Bringing order to the web.\" by L. Brin et al (1999).\n \tIn later publications (\"PageRank revisited.\" by M. Brinkmeyer et al. (2005) amongst others) sink-node handling\n \twas added for directed graphs in order to comply with the theoretical assumptions by the underlying \n \tMarkov chain model. This can be activated by setting the matching parameter to true. By default \n \tthis is disabled, since it is an addition to the original definition.\n\t\n \tPage-Rank values can also be normalized by post-processed according to \"Comparing Apples and\n \tOranges: Normalized PageRank for Evolving Graphs\" by Berberich et al. (2007). This decouples\n \tthe PageRank values from the size of the input graph. To enable this, set the matching parameter\n \tto true. Note that, sink-node handling is automatically activated if normalization is used.\n\n\tParameter :code:`distributeSinks` can be one of the following:\n\n\t- networkit.centrality.SinkHandling.NO_SINK_HANDLING\n\t- networkit.centrality.SinkHandling.DISTRIBUTE_SINKS\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tGraph to be processed.\n\tdamp : float, optional\n\t\tDamping factor of the PageRank algorithm. Default: 0.85\n\ttol : float, optional\n\t\tError tolerance for PageRank iteration. Default: 1e-8\n\tdistributeSinks: networkit.centrality.SinkHandling, optional\n\t\tSet to distribute PageRank values for sink nodes. Default: SinkHandling.NO_SINK_HANDLING\n\tnormalized : bool, optional\n\t\tIf the results should be normalized by the lower bound of scores. \n\t\tThis decouples the PageRank values from the size of the input graph. Default: False\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_PageRank, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_9networkit_10centrality_PageRank, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_PageRank, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_SpanningEdgeCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_SpanningEdgeCentrality(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *p = (struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_SpanningEdgeCentrality) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_SpanningEdgeCentrality);
}

static int __pyx_tp_traverse_9networkit_10centrality_SpanningEdgeCentrality(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *p = (struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_SpanningEdgeCentrality); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_SpanningEdgeCentrality(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *p = (struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_SpanningEdgeCentrality); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_SpanningEdgeCentrality[] = {
  {"runApproximation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_2runApproximation},
  {"runParallelApproximation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_4runParallelApproximation},
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_7scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_22SpanningEdgeCentrality_6scores},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_SpanningEdgeCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_SpanningEdgeCentrality},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tSpanningEdgeCentrality(G, tol = 0.1)\n\t\n\tComputes the Spanning Edge centrality for the edges of the graph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\ttol: float, optional\n\t\tTolerance used for the approximation: with probability at least 1-1/n, the approximated \n\t\tscores are within a factor 1+tol from the exact scores. Default: 0.1\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_SpanningEdgeCentrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_SpanningEdgeCentrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_SpanningEdgeCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_SpanningEdgeCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_SpanningEdgeCentrality_spec = {
  "networkit.centrality.SpanningEdgeCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_SpanningEdgeCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_SpanningEdgeCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""SpanningEdgeCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_SpanningEdgeCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_SpanningEdgeCentrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tSpanningEdgeCentrality(G, tol = 0.1)\n\t\n\tComputes the Spanning Edge centrality for the edges of the graph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\ttol: float, optional\n\t\tTolerance used for the approximation: with probability at least 1-1/n, the approximated \n\t\tscores are within a factor 1+tol from the exact scores. Default: 0.1\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_SpanningEdgeCentrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_SpanningEdgeCentrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_SpanningEdgeCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_SpanningEdgeCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxElectricalCloseness(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ApproxElectricalCloseness[] = {
  {"getDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25ApproxElectricalCloseness_2getDiagonal},
  {"computeExactDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_25ApproxElectricalCloseness_4computeExactDiagonal},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ApproxElectricalCloseness_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tApproxElectricalCloseness(G, eps = 0.1, kappa = 0.3)\n\t\n\tApproximates the electrical closeness of all the vertices of the graph by approximating the\n\tdiagonal of the laplacian's pseudoinverse of G. Every element of the diagonal is\n\tguaranteed to have a maximum absolute error of eps. Based on \"Approximation of the\n\tDiagonal of a Laplacian\342\200\231s Pseudoinverse for Complex Network Analysis\", Angriman et al., ESA\n\t2020. The algorithm does two steps: solves a linear system and samples uniform spanning trees\n\t(USTs). The parameter kappa balances the tolerance of solver for the linear system and the\n\tnumber of USTs to be sampled. A high value of kappa raises the tolerance (solver converges\n\tfaster) but more USTs need to be sampled, vice versa for a low value of kappa.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\teps : float, optional\n\t\tMaximum absolute error of the elements in the diagonal. Default: 0.1\n\tkappa : float, optional\n\t\tBalances the tolerance of the solver for the linear system and the\n\t\tnumber of USTs to be sampled. Default: 0.3\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ApproxElectricalCloseness},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ApproxElectricalCloseness},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ApproxElectricalCloseness_spec = {
  "networkit.centrality.ApproxElectricalCloseness",
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ApproxElectricalCloseness_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ApproxElectricalCloseness = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ApproxElectricalCloseness", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxElectricalCloseness), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tApproxElectricalCloseness(G, eps = 0.1, kappa = 0.3)\n\t\n\tApproximates the electrical closeness of all the vertices of the graph by approximating the\n\tdiagonal of the laplacian's pseudoinverse of G. Every element of the diagonal is\n\tguaranteed to have a maximum absolute error of eps. Based on \"Approximation of the\n\tDiagonal of a Laplacian\342\200\231s Pseudoinverse for Complex Network Analysis\", Angriman et al., ESA\n\t2020. The algorithm does two steps: solves a linear system and samples uniform spanning trees\n\t(USTs). The parameter kappa balances the tolerance of solver for the linear system and the\n\tnumber of USTs to be sampled. A high value of kappa raises the tolerance (solver converges\n\tfaster) but more USTs need to be sampled, vice versa for a low value of kappa.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\teps : float, optional\n\t\tMaximum absolute error of the elements in the diagonal. Default: 0.1\n\tkappa : float, optional\n\t\tBalances the tolerance of the solver for the linear system and the\n\t\tnumber of USTs to be sampled. Default: 0.3\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ApproxElectricalCloseness, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ApproxElectricalCloseness, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ForestCentrality(PyTypeObject *t, PyObject *a, PyObject *k) {
  PyObject *o = __pyx_tp_new_9networkit_10centrality_Centrality(t, a, k);
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_9networkit_10centrality_16ForestCentrality_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ForestCentrality[] = {
  {"getDiagonal", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_3getDiagonal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_16ForestCentrality_2getDiagonal},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_16ForestCentrality_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ForestCentrality_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_Centrality},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tForestCentrality(G, root, eps=0.1, kappa=0.3)\n\t\n\tApproximates the forest closeness centrality of all the vertices of a graph by approximating\n\tthe diagonal of the forest matrix of @a G. Every element of the diagonal is guaranteed to\n\thave a maximum absolute error of @a epsilon. Based on \"New Approximation Algorithms for\n\tForest Closeness Centrality - for Individual Vertices and Vertex Groups\", van der Grinten et\n\tal, SDM 2021.\n\tThe algorithm runs in two steps: (i) solving a linear system and (ii) sampling uniform\n\tspanning trees (USTs). The parameter @a kappa balances the tolerance of the linear sytem\n\tsolver and the number of USTs to be sampled. A high value of @a kappa raises the tolerance\n\t(solver converges faster) but more USTs need to be sampled, vice versa for a low value of @a\n\tkappa. Note: the algorithm requires an augmented graph as input (see the reference paper for\n\tdetails). An augmented graphs can be generated with graphtools.createAugmentedGraph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph. Must be an augmented graph; an augmented graph can be crated with\n\t\tgraphtools.createAugmentedGraph.\n\troot : int\n\t\tRoot node of the augmented graph.\n\tepsilon : float, optional\n\t\tMaximum absolute error of the elements in the diagonal. Default: 0.1\n\tkappa : float, optional\n\t\tBalances the tolerance of the linear system solver and the number of USTs to be\n\t\tsampled. Default: 0.3\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_Centrality},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_Centrality},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ForestCentrality},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ForestCentrality},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ForestCentrality_spec = {
  "networkit.centrality.ForestCentrality",
  sizeof(struct __pyx_obj_9networkit_10centrality_ForestCentrality),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ForestCentrality_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ForestCentrality = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ForestCentrality", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ForestCentrality), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_Centrality, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tForestCentrality(G, root, eps=0.1, kappa=0.3)\n\t\n\tApproximates the forest closeness centrality of all the vertices of a graph by approximating\n\tthe diagonal of the forest matrix of @a G. Every element of the diagonal is guaranteed to\n\thave a maximum absolute error of @a epsilon. Based on \"New Approximation Algorithms for\n\tForest Closeness Centrality - for Individual Vertices and Vertex Groups\", van der Grinten et\n\tal, SDM 2021.\n\tThe algorithm runs in two steps: (i) solving a linear system and (ii) sampling uniform\n\tspanning trees (USTs). The parameter @a kappa balances the tolerance of the linear sytem\n\tsolver and the number of USTs to be sampled. A high value of @a kappa raises the tolerance\n\t(solver converges faster) but more USTs need to be sampled, vice versa for a low value of @a\n\tkappa. Note: the algorithm requires an augmented graph as input (see the reference paper for\n\tdetails). An augmented graphs can be generated with graphtools.createAugmentedGraph.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph. Must be an augmented graph; an augmented graph can be crated with\n\t\tgraphtools.createAugmentedGraph.\n\troot : int\n\t\tRoot node of the augmented graph.\n\tepsilon : float, optional\n\t\tMaximum absolute error of the elements in the diagonal. Default: 0.1\n\tkappa : float, optional\n\t\tBalances the tolerance of the linear system solver and the number of USTs to be\n\t\tsampled. Default: 0.3\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_Centrality, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_Centrality, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ForestCentrality, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY || 0
  __pyx_pw_9networkit_10centrality_10Centrality_1__init__, /*tp_init*/
  #else
  0, /*tp_init*/
  #endif
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ForestCentrality, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ApproxSpanningEdge(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_ApproxSpanningEdge(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *p = (struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_ApproxSpanningEdge) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_ApproxSpanningEdge);
}

static int __pyx_tp_traverse_9networkit_10centrality_ApproxSpanningEdge(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *p = (struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_ApproxSpanningEdge); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_ApproxSpanningEdge(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *p = (struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_ApproxSpanningEdge); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ApproxSpanningEdge[] = {
  {"scores", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_3scores, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_18ApproxSpanningEdge_2scores},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ApproxSpanningEdge_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_ApproxSpanningEdge},
  {Py_tp_doc, (void *)PyDoc_STR("\n\tApproxSpanningEdge(G, eps = 0.1)\n\n\tComputes an epsilon-approximation of the spanning edge centrality of every edge of the input\n\tgraph with probability :math:`(1 - 1/n)`, based on \"Efficient Algorithms for Spanning Tree\n\tCentrality\", Hayashi et al., IJCAI, 2016. This implementation also supports multi-threading.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\teps : float, optional\n\t\tMaximum additive error. Default: 0.1\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_ApproxSpanningEdge},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_ApproxSpanningEdge},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ApproxSpanningEdge},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ApproxSpanningEdge},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ApproxSpanningEdge_spec = {
  "networkit.centrality.ApproxSpanningEdge",
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ApproxSpanningEdge_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ApproxSpanningEdge = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ApproxSpanningEdge", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ApproxSpanningEdge), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_ApproxSpanningEdge, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR("\n\tApproxSpanningEdge(G, eps = 0.1)\n\n\tComputes an epsilon-approximation of the spanning edge centrality of every edge of the input\n\tgraph with probability :math:`(1 - 1/n)`, based on \"Efficient Algorithms for Spanning Tree\n\tCentrality\", Hayashi et al., IJCAI, 2016. This implementation also supports multi-threading.\n\n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe input graph.\n\teps : float, optional\n\t\tMaximum additive error. Default: 0.1\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_ApproxSpanningEdge, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_ApproxSpanningEdge, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ApproxSpanningEdge, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ApproxSpanningEdge, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ComplexPathMode(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
  PyObject *o;
  #if CYTHON_COMPILING_IN_LIMITED_API
  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
  o = alloc_func(t, 0);
  #else
  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
    o = (*t->tp_alloc)(t, 0);
  } else {
    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0);
  }
  if (unlikely(!o)) return 0;
  #endif
  return o;
}

static void __pyx_tp_dealloc_9networkit_10centrality_ComplexPathMode(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_ComplexPathMode) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  #if CYTHON_USE_TYPE_SLOTS
  (*Py_TYPE(o)->tp_free)(o);
  #else
  {
    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
    if (tp_free) tp_free(o);
  }
  #endif
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ComplexPathMode[] = {
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ComplexPathMode_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_ComplexPathMode},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ComplexPathMode},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ComplexPathMode},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ComplexPathMode_spec = {
  "networkit.centrality.ComplexPathMode",
  sizeof(struct __pyx_obj_9networkit_10centrality_ComplexPathMode),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
  __pyx_type_9networkit_10centrality_ComplexPathMode_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ComplexPathMode = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ComplexPathMode", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ComplexPathMode), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_ComplexPathMode, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
  0, /*tp_doc*/
  0, /*tp_traverse*/
  0, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ComplexPathMode, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ComplexPathMode, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality_ComplexPaths(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct __pyx_obj_9networkit_10centrality_ComplexPaths *p;
  PyObject *o = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_new, newfunc)(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct __pyx_obj_9networkit_10centrality_ComplexPaths *)o);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  if (unlikely(__pyx_pw_9networkit_10centrality_12ComplexPaths_1__cinit__(o, a, k) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_9networkit_10centrality_ComplexPaths(PyObject *o) {
  struct __pyx_obj_9networkit_10centrality_ComplexPaths *p = (struct __pyx_obj_9networkit_10centrality_ComplexPaths *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality_ComplexPaths) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->_G);
  if (PyType_IS_GC(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) PyObject_GC_Track(o);
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_dealloc, destructor)(o); else
  #endif
  __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_9networkit_10centrality_ComplexPaths);
}

static int __pyx_tp_traverse_9networkit_10centrality_ComplexPaths(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_obj_9networkit_10centrality_ComplexPaths *p = (struct __pyx_obj_9networkit_10centrality_ComplexPaths *)o;
  #if !CYTHON_USE_MODULE_STATE
  e = 0;
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    traverseproc traverse = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_traverse, traverseproc);
    if (traverse) { e = traverse(o, v, a); }
  } else
  #endif
  { e = __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_9networkit_10centrality_ComplexPaths); }
  if (e) return e;
  {
    e = __Pyx_call_type_traverse(o, 0, v, a);
    if (e) return e;
  }
  if (p->_G) {
    e = (*v)(((PyObject *)p->_G), a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality_ComplexPaths(PyObject *o) {
  PyObject* tmp;
  struct __pyx_obj_9networkit_10centrality_ComplexPaths *p = (struct __pyx_obj_9networkit_10centrality_ComplexPaths *)o;
  #if !CYTHON_USE_MODULE_STATE
  if (likely(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm)) {
    inquiry clear = __Pyx_PyType_GetSlot(__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm, tp_clear, inquiry);
    if (clear) clear(o);
  } else
  #endif
  { __Pyx_call_next_tp_clear(o, __pyx_tp_clear_9networkit_10centrality_ComplexPaths); }
  tmp = ((PyObject*)p->_G);
  p->_G = ((struct __pyx_obj_9networkit_5graph_Graph *)Py_None); Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}

static PyMethodDef __pyx_methods_9networkit_10centrality_ComplexPaths[] = {
  {"getPLci", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_3getPLci, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_2getPLci},
  {"getComplexGraph", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_5getComplexGraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_4getComplexGraph},
  {"getAdopters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_7getAdopters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_6getAdopters},
  {"normalize", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_9normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9networkit_10centrality_12ComplexPaths_8normalize},
  {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9networkit_10centrality_12ComplexPaths_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0},
  {0, 0, 0, 0}
};
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality_ComplexPaths_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality_ComplexPaths},
  {Py_tp_doc, (void *)PyDoc_STR(" \n\tComplexPaths(G, threshold, mode, start)\n\n\tThe ComplexPathAlgorithm analysis the spread of complex contagions in a given graph. \n\tReturns the complex contagion paths of a given phenomenon (determined by the threshold) \n\tfor single nodes or the entire graph, according to:\n\t[ Guilbeault, D., Centola, D. Topological measures for \n\t  identifying and predicting the spread of complex contagions. \n\t  Nat Commun 12, 4430 (2021). \n\t  https://doi.org/10.1038/s41467-021-24704-6 ]\n \n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\n\tthreshold : int\n\t\tThe complex path width: minimal number of neighbors.\n\n\tParameter :code:`mode` can be one of the following:\n\n\t- ComplexPathMode.allNodes: Calculate complex path lengths\n\t\t\t\t\t  from every start node(default).\n\t- ComplexPathMode.singleNode: Calculate complex path graph\n\t\t\t\t\t  from node start.\n\t\n\tstart : node\n\t\tStart node for ComplexPathMode.singleNode.\n\t")},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality_ComplexPaths},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality_ComplexPaths},
  {Py_tp_methods, (void *)__pyx_methods_9networkit_10centrality_ComplexPaths},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality_ComplexPaths},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality_ComplexPaths_spec = {
  "networkit.centrality.ComplexPaths",
  sizeof(struct __pyx_obj_9networkit_10centrality_ComplexPaths),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality_ComplexPaths_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality_ComplexPaths = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""ComplexPaths", /*tp_name*/
  sizeof(struct __pyx_obj_9networkit_10centrality_ComplexPaths), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality_ComplexPaths, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  PyDoc_STR(" \n\tComplexPaths(G, threshold, mode, start)\n\n\tThe ComplexPathAlgorithm analysis the spread of complex contagions in a given graph. \n\tReturns the complex contagion paths of a given phenomenon (determined by the threshold) \n\tfor single nodes or the entire graph, according to:\n\t[ Guilbeault, D., Centola, D. Topological measures for \n\t  identifying and predicting the spread of complex contagions. \n\t  Nat Commun 12, 4430 (2021). \n\t  https://doi.org/10.1038/s41467-021-24704-6 ]\n \n\tParameters\n\t----------\n\tG : networkit.Graph\n\t\tThe graph.\n\n\tthreshold : int\n\t\tThe complex path width: minimal number of neighbors.\n\n\tParameter :code:`mode` can be one of the following:\n\n\t- ComplexPathMode.allNodes: Calculate complex path lengths\n\t\t\t\t\t  from every start node(default).\n\t- ComplexPathMode.singleNode: Calculate complex path graph\n\t\t\t\t\t  from node start.\n\t\n\tstart : node\n\t\tStart node for ComplexPathMode.singleNode.\n\t"), /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality_ComplexPaths, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality_ComplexPaths, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_9networkit_10centrality_ComplexPaths, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality_ComplexPaths, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

static PyObject *__pyx_tp_new_9networkit_10centrality___pyx_defaults(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
  PyObject *o;
  #if CYTHON_COMPILING_IN_LIMITED_API
  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
  o = alloc_func(t, 0);
  #else
  o = (*t->tp_alloc)(t, 0);
  if (unlikely(!o)) return 0;
  #endif
  return o;
}

static void __pyx_tp_dealloc_9networkit_10centrality___pyx_defaults(PyObject *o) {
  struct __pyx_defaults *p = (struct __pyx_defaults *)o;
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9networkit_10centrality___pyx_defaults) {
      if (PyObject_CallFinalizerFromDealloc(o)) return;
    }
  }
  #endif
  PyObject_GC_UnTrack(o);
  Py_CLEAR(p->arg0);
  #if CYTHON_USE_TYPE_SLOTS
  (*Py_TYPE(o)->tp_free)(o);
  #else
  {
    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
    if (tp_free) tp_free(o);
  }
  #endif
}

static int __pyx_tp_traverse_9networkit_10centrality___pyx_defaults(PyObject *o, visitproc v, void *a) {
  int e;
  struct __pyx_defaults *p = (struct __pyx_defaults *)o;
  {
    e = __Pyx_call_type_traverse(o, 1, v, a);
    if (e) return e;
  }
  if (p->arg0) {
    e = (*v)(p->arg0, a); if (e) return e;
  }
  return 0;
}

static int __pyx_tp_clear_9networkit_10centrality___pyx_defaults(PyObject *o) {
  PyObject* tmp;
  struct __pyx_defaults *p = (struct __pyx_defaults *)o;
  tmp = ((PyObject*)p->arg0);
  p->arg0 = Py_None; Py_INCREF(Py_None);
  Py_XDECREF(tmp);
  return 0;
}
#if CYTHON_USE_TYPE_SPECS
static PyType_Slot __pyx_type_9networkit_10centrality___pyx_defaults_slots[] = {
  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9networkit_10centrality___pyx_defaults},
  {Py_tp_traverse, (void *)__pyx_tp_traverse_9networkit_10centrality___pyx_defaults},
  {Py_tp_clear, (void *)__pyx_tp_clear_9networkit_10centrality___pyx_defaults},
  {Py_tp_new, (void *)__pyx_tp_new_9networkit_10centrality___pyx_defaults},
  {0, 0},
};
static PyType_Spec __pyx_type_9networkit_10centrality___pyx_defaults_spec = {
  "networkit.centrality.__pyx_defaults",
  sizeof(struct __pyx_defaults),
  0,
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
  __pyx_type_9networkit_10centrality___pyx_defaults_slots,
};
#else

static PyTypeObject __pyx_type_9networkit_10centrality___pyx_defaults = {
  PyVarObject_HEAD_INIT(0, 0)
  "networkit.centrality.""__pyx_defaults", /*tp_name*/
  sizeof(struct __pyx_defaults), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_9networkit_10centrality___pyx_defaults, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  0, /*tp_as_async*/
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
  0, /*tp_doc*/
  __pyx_tp_traverse_9networkit_10centrality___pyx_defaults, /*tp_traverse*/
  __pyx_tp_clear_9networkit_10centrality___pyx_defaults, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  0, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  #if !CYTHON_USE_TYPE_SPECS
  0, /*tp_dictoffset*/
  #endif
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_9networkit_10centrality___pyx_defaults, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if CYTHON_USE_TP_FINALIZE
  0, /*tp_finalize*/
  #else
  NULL, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if __PYX_NEED_TP_PRINT_SLOT == 1
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030C0000
  0, /*tp_watched*/
  #endif
  #if PY_VERSION_HEX >= 0x030d00A4
  0, /*tp_versions_used*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
  0, /*tp_pypy_flags*/
  #endif
};
#endif

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_EnumBase = Py_None; Py_INCREF(Py_None);
  __Pyx_FlagBase = 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);
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
  /*--- Function export code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
  /*--- Type init code ---*/
  __pyx_t_1 = PyImport_ImportModule("networkit.base"); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_mstate->__pyx_ptype_9networkit_4base_Algorithm = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.base", "Algorithm",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_4base_Algorithm), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base_Algorithm),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_4base_Algorithm), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base_Algorithm),
  #else
  sizeof(struct __pyx_obj_9networkit_4base_Algorithm), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base_Algorithm),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_4base_Algorithm) __PYX_ERR(0, 1, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_Centrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality)) __PYX_ERR(0, 36, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_Centrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality = &__pyx_type_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Centrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Centrality) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_Betweenness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness)) __PYX_ERR(0, 140, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_Betweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness = &__pyx_type_9networkit_10centrality_Betweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Betweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Betweenness) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ApproxBetweenness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness)) __PYX_ERR(0, 183, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ApproxBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness = &__pyx_type_9networkit_10centrality_ApproxBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ApproxBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxBetweenness) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_EstimateBetweenness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness)) __PYX_ERR(0, 224, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_EstimateBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness = &__pyx_type_9networkit_10centrality_EstimateBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_EstimateBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_EstimateBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_EstimateBetweenness) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_KadabraBetweenness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness)) __PYX_ERR(0, 264, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_KadabraBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness) < 0) __PYX_ERR(0, 264, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness = &__pyx_type_9networkit_10centrality_KadabraBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness) < 0) __PYX_ERR(0, 264, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness) < 0) __PYX_ERR(0, 264, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KadabraBetweenness) < 0) __PYX_ERR(0, 264, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 684, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_Closeness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness)) __PYX_ERR(0, 684, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_Closeness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness) < 0) __PYX_ERR(0, 684, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness = &__pyx_type_9networkit_10centrality_Closeness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Closeness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness) < 0) __PYX_ERR(0, 684, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Closeness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness) < 0) __PYX_ERR(0, 684, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Closeness) < 0) __PYX_ERR(0, 684, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ApproxCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness)) __PYX_ERR(0, 749, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ApproxCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness) < 0) __PYX_ERR(0, 749, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness = &__pyx_type_9networkit_10centrality_ApproxCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness) < 0) __PYX_ERR(0, 749, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ApproxCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness) < 0) __PYX_ERR(0, 749, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxCloseness) < 0) __PYX_ERR(0, 749, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DegreeCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality)) __PYX_ERR(0, 804, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DegreeCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality) < 0) __PYX_ERR(0, 804, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality = &__pyx_type_9networkit_10centrality_DegreeCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DegreeCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality) < 0) __PYX_ERR(0, 804, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DegreeCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality) < 0) __PYX_ERR(0, 804, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DegreeCentrality) < 0) __PYX_ERR(0, 804, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 836, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_HarmonicCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness)) __PYX_ERR(0, 836, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_HarmonicCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness) < 0) __PYX_ERR(0, 836, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness = &__pyx_type_9networkit_10centrality_HarmonicCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_HarmonicCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness) < 0) __PYX_ERR(0, 836, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_HarmonicCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness) < 0) __PYX_ERR(0, 836, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_HarmonicCloseness) < 0) __PYX_ERR(0, 836, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_TopCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness)) __PYX_ERR(0, 872, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_TopCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness) < 0) __PYX_ERR(0, 872, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness = &__pyx_type_9networkit_10centrality_TopCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness) < 0) __PYX_ERR(0, 872, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_TopCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness) < 0) __PYX_ERR(0, 872, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopCloseness) < 0) __PYX_ERR(0, 872, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 974, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_TopHarmonicCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness)) __PYX_ERR(0, 974, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_TopHarmonicCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness) < 0) __PYX_ERR(0, 974, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness = &__pyx_type_9networkit_10centrality_TopHarmonicCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness) < 0) __PYX_ERR(0, 974, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness) < 0) __PYX_ERR(0, 974, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness) < 0) __PYX_ERR(0, 974, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_LocalPartitionCoverage_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage)) __PYX_ERR(0, 1184, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_LocalPartitionCoverage_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage) < 0) __PYX_ERR(0, 1184, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage = &__pyx_type_9networkit_10centrality_LocalPartitionCoverage;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage) < 0) __PYX_ERR(0, 1184, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_LocalPartitionCoverage, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage) < 0) __PYX_ERR(0, 1184, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalPartitionCoverage) < 0) __PYX_ERR(0, 1184, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupDegree_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree)) __PYX_ERR(0, 1213, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupDegree_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree) < 0) __PYX_ERR(0, 1213, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree = &__pyx_type_9networkit_10centrality_GroupDegree;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupDegree->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree) < 0) __PYX_ERR(0, 1213, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupDegree, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree) < 0) __PYX_ERR(0, 1213, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupDegree) < 0) __PYX_ERR(0, 1213, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GedWalk_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk)) __PYX_ERR(0, 1325, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GedWalk_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk) < 0) __PYX_ERR(0, 1325, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk = &__pyx_type_9networkit_10centrality_GedWalk;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GedWalk->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk) < 0) __PYX_ERR(0, 1325, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GedWalk, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk) < 0) __PYX_ERR(0, 1325, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GedWalk) < 0) __PYX_ERR(0, 1325, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1440, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ApproxGroupBetweenness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness)) __PYX_ERR(0, 1440, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ApproxGroupBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness) < 0) __PYX_ERR(0, 1440, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness = &__pyx_type_9networkit_10centrality_ApproxGroupBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness) < 0) __PYX_ERR(0, 1440, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ApproxGroupBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness) < 0) __PYX_ERR(0, 1440, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness) < 0) __PYX_ERR(0, 1440, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1502, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness)) __PYX_ERR(0, 1502, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness) < 0) __PYX_ERR(0, 1502, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness = &__pyx_type_9networkit_10centrality_GroupCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness) < 0) __PYX_ERR(0, 1502, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness) < 0) __PYX_ERR(0, 1502, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupCloseness) < 0) __PYX_ERR(0, 1502, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1586, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink)) __PYX_ERR(0, 1586, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink) < 0) __PYX_ERR(0, 1586, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink = &__pyx_type_9networkit_10centrality_GroupClosenessGrowShrink;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink) < 0) __PYX_ERR(0, 1586, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupClosenessGrowShrink, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink) < 0) __PYX_ERR(0, 1586, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink) < 0) __PYX_ERR(0, 1586, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps)) __PYX_ERR(0, 1646, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps) < 0) __PYX_ERR(0, 1646, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps = &__pyx_type_9networkit_10centrality_GroupClosenessLocalSwaps;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps) < 0) __PYX_ERR(0, 1646, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSwaps, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps) < 0) __PYX_ERR(0, 1646, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps) < 0) __PYX_ERR(0, 1646, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1706, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupHarmonicCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness)) __PYX_ERR(0, 1706, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupHarmonicCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness) < 0) __PYX_ERR(0, 1706, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness = &__pyx_type_9networkit_10centrality_GroupHarmonicCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness) < 0) __PYX_ERR(0, 1706, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupHarmonicCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness) < 0) __PYX_ERR(0, 1706, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness) < 0) __PYX_ERR(0, 1706, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch)) __PYX_ERR(0, 1779, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch) < 0) __PYX_ERR(0, 1779, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch = &__pyx_type_9networkit_10centrality_GroupClosenessLocalSearch;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch) < 0) __PYX_ERR(0, 1779, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSearch, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch) < 0) __PYX_ERR(0, 1779, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch) < 0) __PYX_ERR(0, 1779, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_KPathCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality)) __PYX_ERR(0, 1852, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_KPathCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality) < 0) __PYX_ERR(0, 1852, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality = &__pyx_type_9networkit_10centrality_KPathCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KPathCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality) < 0) __PYX_ERR(0, 1852, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_KPathCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality) < 0) __PYX_ERR(0, 1852, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KPathCentrality) < 0) __PYX_ERR(0, 1852, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_KatzCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality)) __PYX_ERR(0, 1891, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_KatzCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality) < 0) __PYX_ERR(0, 1891, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality = &__pyx_type_9networkit_10centrality_KatzCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KatzCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality) < 0) __PYX_ERR(0, 1891, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_KatzCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality) < 0) __PYX_ERR(0, 1891, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_KatzCentrality) < 0) __PYX_ERR(0, 1891, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DynKatzCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality)) __PYX_ERR(0, 1941, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DynKatzCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality) < 0) __PYX_ERR(0, 1941, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality = &__pyx_type_9networkit_10centrality_DynKatzCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynKatzCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality) < 0) __PYX_ERR(0, 1941, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality) < 0) __PYX_ERR(0, 1941, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynKatzCentrality) < 0) __PYX_ERR(0, 1941, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2024, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_LocalClusteringCoefficient_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient)) __PYX_ERR(0, 2024, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_LocalClusteringCoefficient_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient) < 0) __PYX_ERR(0, 2024, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient = &__pyx_type_9networkit_10centrality_LocalClusteringCoefficient;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient) < 0) __PYX_ERR(0, 2024, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_LocalClusteringCoefficient, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient) < 0) __PYX_ERR(0, 2024, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalClusteringCoefficient) < 0) __PYX_ERR(0, 2024, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient)) __PYX_ERR(0, 2056, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient) < 0) __PYX_ERR(0, 2056, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient = &__pyx_type_9networkit_10centrality_LocalSquareClusteringCoefficient;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient) < 0) __PYX_ERR(0, 2056, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_LocalSquareClusteringCoefficient, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient) < 0) __PYX_ERR(0, 2056, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LocalSquareClusteringCoefficient) < 0) __PYX_ERR(0, 2056, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2078, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_Sfigality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality)) __PYX_ERR(0, 2078, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_Sfigality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality) < 0) __PYX_ERR(0, 2078, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality = &__pyx_type_9networkit_10centrality_Sfigality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Sfigality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality) < 0) __PYX_ERR(0, 2078, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Sfigality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality) < 0) __PYX_ERR(0, 2078, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_Sfigality) < 0) __PYX_ERR(0, 2078, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_PermanenceCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality)) __PYX_ERR(0, 2102, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_PermanenceCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality) < 0) __PYX_ERR(0, 2102, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality = &__pyx_type_9networkit_10centrality_PermanenceCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_PermanenceCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality) < 0) __PYX_ERR(0, 2102, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PermanenceCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality) < 0) __PYX_ERR(0, 2102, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_PermanenceCentrality) < 0) __PYX_ERR(0, 2102, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_LaplacianCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality)) __PYX_ERR(0, 2168, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_LaplacianCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality) < 0) __PYX_ERR(0, 2168, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality = &__pyx_type_9networkit_10centrality_LaplacianCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_LaplacianCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality) < 0) __PYX_ERR(0, 2168, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_LaplacianCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality) < 0) __PYX_ERR(0, 2168, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_LaplacianCentrality) < 0) __PYX_ERR(0, 2168, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_CoreDecomposition_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition)) __PYX_ERR(0, 2202, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_CoreDecomposition_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition) < 0) __PYX_ERR(0, 2202, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition = &__pyx_type_9networkit_10centrality_CoreDecomposition;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_CoreDecomposition->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition) < 0) __PYX_ERR(0, 2202, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_CoreDecomposition, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition) < 0) __PYX_ERR(0, 2202, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_CoreDecomposition) < 0) __PYX_ERR(0, 2202, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_EigenvectorCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality)) __PYX_ERR(0, 2283, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_EigenvectorCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality) < 0) __PYX_ERR(0, 2283, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality = &__pyx_type_9networkit_10centrality_EigenvectorCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality) < 0) __PYX_ERR(0, 2283, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_EigenvectorCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality) < 0) __PYX_ERR(0, 2283, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_EigenvectorCentrality) < 0) __PYX_ERR(0, 2283, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2334, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_PageRank_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank)) __PYX_ERR(0, 2334, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_PageRank_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank) < 0) __PYX_ERR(0, 2334, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank = &__pyx_type_9networkit_10centrality_PageRank;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_PageRank->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank) < 0) __PYX_ERR(0, 2334, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PageRank, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank) < 0) __PYX_ERR(0, 2334, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_PageRank) < 0) __PYX_ERR(0, 2334, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_SpanningEdgeCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality)) __PYX_ERR(0, 2427, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_SpanningEdgeCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality) < 0) __PYX_ERR(0, 2427, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality = &__pyx_type_9networkit_10centrality_SpanningEdgeCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality) < 0) __PYX_ERR(0, 2427, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality) < 0) __PYX_ERR(0, 2427, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality) < 0) __PYX_ERR(0, 2427, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ApproxElectricalCloseness_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness)) __PYX_ERR(0, 2487, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ApproxElectricalCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness) < 0) __PYX_ERR(0, 2487, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness = &__pyx_type_9networkit_10centrality_ApproxElectricalCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness) < 0) __PYX_ERR(0, 2487, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ApproxElectricalCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness) < 0) __PYX_ERR(0, 2487, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness) < 0) __PYX_ERR(0, 2487, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2554, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ForestCentrality_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality)) __PYX_ERR(0, 2554, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ForestCentrality_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality) < 0) __PYX_ERR(0, 2554, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality = &__pyx_type_9networkit_10centrality_ForestCentrality;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ForestCentrality->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality) < 0) __PYX_ERR(0, 2554, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ForestCentrality, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality) < 0) __PYX_ERR(0, 2554, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ForestCentrality) < 0) __PYX_ERR(0, 2554, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ApproxSpanningEdge_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge)) __PYX_ERR(0, 2606, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ApproxSpanningEdge_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge) < 0) __PYX_ERR(0, 2606, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge = &__pyx_type_9networkit_10centrality_ApproxSpanningEdge;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge) < 0) __PYX_ERR(0, 2606, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ApproxSpanningEdge, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge) < 0) __PYX_ERR(0, 2606, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge) < 0) __PYX_ERR(0, 2606, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ComplexPathMode_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode)) __PYX_ERR(0, 2942, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ComplexPathMode_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode) < 0) __PYX_ERR(0, 2942, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode = &__pyx_type_9networkit_10centrality_ComplexPathMode;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode) < 0) __PYX_ERR(0, 2942, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ComplexPathMode, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode) < 0) __PYX_ERR(0, 2942, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPathMode) < 0) __PYX_ERR(0, 2942, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_t_2 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2954, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_ComplexPaths_spec, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths)) __PYX_ERR(0, 2954, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_ComplexPaths_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths) < 0) __PYX_ERR(0, 2954, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths = &__pyx_type_9networkit_10centrality_ComplexPaths;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPaths->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths) < 0) __PYX_ERR(0, 2954, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_ComplexPaths, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths) < 0) __PYX_ERR(0, 2954, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_ComplexPaths) < 0) __PYX_ERR(0, 2954, __pyx_L1_error)
  #if CYTHON_USE_TYPE_SPECS
  __pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality___pyx_defaults_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults)) __PYX_ERR(0, 2642, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality___pyx_defaults_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults) < 0) __PYX_ERR(0, 2642, __pyx_L1_error)
  #else
  __pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults = &__pyx_type_9networkit_10centrality___pyx_defaults;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults) < 0) __PYX_ERR(0, 2642, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality___pyx_defaults->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_type_import_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_type_import_code", 0);
  /*--- Type import code ---*/
  __pyx_t_1 = PyImport_ImportModule("networkit.base"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_mstate->__pyx_ptype_9networkit_4base__CythonParentClass = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.base", "_CythonParentClass",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_4base__CythonParentClass), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base__CythonParentClass),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_4base__CythonParentClass), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base__CythonParentClass),
  #else
  sizeof(struct __pyx_obj_9networkit_4base__CythonParentClass), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_4base__CythonParentClass),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_4base__CythonParentClass) __PYX_ERR(2, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyImport_ImportModule("networkit.structures"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_mstate->__pyx_ptype_9networkit_10structures_Cover = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.structures", "Cover",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_10structures_Cover), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Cover),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_10structures_Cover), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Cover),
  #else
  sizeof(struct __pyx_obj_9networkit_10structures_Cover), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Cover),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_10structures_Cover) __PYX_ERR(3, 50, __pyx_L1_error)
  __pyx_vtabptr_9networkit_10structures_Cover = (struct __pyx_vtabstruct_9networkit_10structures_Cover*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_10structures_Cover); if (unlikely(!__pyx_vtabptr_9networkit_10structures_Cover)) __PYX_ERR(3, 50, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_10structures_Partition = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.structures", "Partition",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_10structures_Partition), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Partition),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_10structures_Partition), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Partition),
  #else
  sizeof(struct __pyx_obj_9networkit_10structures_Partition), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_10structures_Partition),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_10structures_Partition) __PYX_ERR(3, 86, __pyx_L1_error)
  __pyx_vtabptr_9networkit_10structures_Partition = (struct __pyx_vtabstruct_9networkit_10structures_Partition*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_10structures_Partition); if (unlikely(!__pyx_vtabptr_9networkit_10structures_Partition)) __PYX_ERR(3, 86, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyImport_ImportModule("networkit.dynamics"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 36, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_mstate->__pyx_ptype_9networkit_8dynamics_GraphEvent = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.dynamics", "GraphEvent",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_8dynamics_GraphEvent), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_8dynamics_GraphEvent),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_8dynamics_GraphEvent), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_8dynamics_GraphEvent),
  #else
  sizeof(struct __pyx_obj_9networkit_8dynamics_GraphEvent), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_8dynamics_GraphEvent),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_8dynamics_GraphEvent) __PYX_ERR(4, 36, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyImport_ImportModule("networkit.graph"); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_mstate->__pyx_ptype_9networkit_5graph_Graph = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "Graph",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_Graph), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_Graph),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_Graph), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_Graph),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_Graph), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_Graph),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_Graph) __PYX_ERR(5, 289, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_Graph = (struct __pyx_vtabstruct_9networkit_5graph_Graph*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_Graph); if (unlikely(!__pyx_vtabptr_9networkit_5graph_Graph)) __PYX_ERR(5, 289, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_NodeIntAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "NodeIntAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_NodeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeIntAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_NodeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeIntAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_NodeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeIntAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeIntAttribute) __PYX_ERR(5, 293, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_NodeIntAttribute = (struct __pyx_vtabstruct_9networkit_5graph_NodeIntAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeIntAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_NodeIntAttribute)) __PYX_ERR(5, 293, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_NodeDoubleAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "NodeDoubleAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeDoubleAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeDoubleAttribute) __PYX_ERR(5, 300, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_NodeDoubleAttribute = (struct __pyx_vtabstruct_9networkit_5graph_NodeDoubleAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeDoubleAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_NodeDoubleAttribute)) __PYX_ERR(5, 300, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_NodeStringAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "NodeStringAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_NodeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeStringAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_NodeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeStringAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_NodeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_NodeStringAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeStringAttribute) __PYX_ERR(5, 307, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_NodeStringAttribute = (struct __pyx_vtabstruct_9networkit_5graph_NodeStringAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_NodeStringAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_NodeStringAttribute)) __PYX_ERR(5, 307, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeIntAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "EdgeIntAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeIntAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeIntAttribute) __PYX_ERR(5, 314, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_EdgeIntAttribute = (struct __pyx_vtabstruct_9networkit_5graph_EdgeIntAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeIntAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_EdgeIntAttribute)) __PYX_ERR(5, 314, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "EdgeDoubleAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeDoubleAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute) __PYX_ERR(5, 321, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_EdgeDoubleAttribute = (struct __pyx_vtabstruct_9networkit_5graph_EdgeDoubleAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeDoubleAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_EdgeDoubleAttribute)) __PYX_ERR(5, 321, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeStringAttribute = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "EdgeStringAttribute",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_EdgeStringAttribute),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeStringAttribute) __PYX_ERR(5, 328, __pyx_L1_error)
  __pyx_vtabptr_9networkit_5graph_EdgeStringAttribute = (struct __pyx_vtabstruct_9networkit_5graph_EdgeStringAttribute*)__Pyx_GetVtable(__pyx_mstate->__pyx_ptype_9networkit_5graph_EdgeStringAttribute); if (unlikely(!__pyx_vtabptr_9networkit_5graph_EdgeStringAttribute)) __PYX_ERR(5, 328, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_RandomMaximumSpanningForest = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "RandomMaximumSpanningForest",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_RandomMaximumSpanningForest),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_RandomMaximumSpanningForest) __PYX_ERR(5, 364, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_5graph_UnionMaximumSpanningForest = __Pyx_ImportType_3_1_4(__pyx_t_1, "networkit.graph", "UnionMaximumSpanningForest",
  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
  sizeof(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest),
  #elif CYTHON_COMPILING_IN_LIMITED_API
  sizeof(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest),
  #else
  sizeof(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest), __PYX_GET_STRUCT_ALIGNMENT_3_1_4(struct __pyx_obj_9networkit_5graph_UnionMaximumSpanningForest),
  #endif
  __Pyx_ImportType_CheckSize_Warn_3_1_4); if (!__pyx_mstate->__pyx_ptype_9networkit_5graph_UnionMaximumSpanningForest) __PYX_ERR(5, 379, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_variable_import_code(__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_centrality(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec_centrality},
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
  {Py_mod_gil, Py_MOD_GIL_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,
      "centrality",
      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_centrality(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit_centrality(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
  return PyModuleDef_Init(&__pyx_moduledef);
}
/* ModuleCreationPEP489 */
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000
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
    PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000
    PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get());
#elif CYTHON_COMPILING_IN_LIMITED_API
    PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId();
#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_centrality(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;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  size_t __pyx_t_8;
  int __pyx_t_9;
  PyTypeObject *__pyx_t_10 = NULL;
  enum NetworKit::ApproxCloseness::ClosenessType __pyx_t_11;
  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 'centrality' 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 "centrality" 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_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_centrality", 0);
  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pxy_PyFrame_Initialize_Offsets
  __Pxy_PyFrame_Initialize_Offsets();
  #endif
  __pyx_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)
  /*--- 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 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED)
  if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_AsyncGen_USED
  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  if (__pyx_module_is_main_networkit__centrality) {
    if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __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, "networkit.centrality")) {
      if (unlikely((PyDict_SetItemString(modules, "networkit.centrality", __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);
  (void)__Pyx_modinit_function_export_code(__pyx_mstate);
  if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
  if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
  (void)__Pyx_modinit_variable_import_code(__pyx_mstate);
  (void)__Pyx_modinit_function_import_code(__pyx_mstate);
  /*--- Execution code ---*/

  /* "EnumBase":10
 * 
 * cdef object __Pyx_EnumBase
 * from enum import IntEnum as __Pyx_EnumBase             # <<<<<<<<<<<<<<
 * 
 * cdef object __Pyx_FlagBase
*/
  __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_IntEnum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_enum, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_IntEnum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__Pyx_EnumBase);
  __Pyx_DECREF_SET(__Pyx_EnumBase, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "EnumBase":13
 * 
 * cdef object __Pyx_FlagBase
 * from enum import IntFlag as __Pyx_FlagBase             # <<<<<<<<<<<<<<
 * 
*/
  __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_IntFlag); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_enum, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_IntFlag); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_t_3);
  __Pyx_XGOTREF(__Pyx_FlagBase);
  __Pyx_DECREF_SET(__Pyx_FlagBase, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "EnumType":23
 * 
 * 
 * _ClosenessVariant = __Pyx_FlagBase('_ClosenessVariant', [             # <<<<<<<<<<<<<<
 *     ('STANDARD', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(STANDARD)),
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),
*/
  __pyx_t_3 = NULL;
  __Pyx_INCREF(__Pyx_FlagBase);
  __pyx_t_4 = __Pyx_FlagBase; 

  /* "EnumType":24
 * 
 * _ClosenessVariant = __Pyx_FlagBase('_ClosenessVariant', [
 *     ('STANDARD', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(STANDARD)),             # <<<<<<<<<<<<<<
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),
 * 
*/
  __pyx_t_5 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(NetworKit::ClosenessVariant::STANDARD); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_STANDARD, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "EnumType":25
 * _ClosenessVariant = __Pyx_FlagBase('_ClosenessVariant', [
 *     ('STANDARD', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(STANDARD)),
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),             # <<<<<<<<<<<<<<
 * 
 * ], module=globals().get("__module__", 'networkit.centrality'))
*/
  __pyx_t_5 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(NetworKit::ClosenessVariant::GENERALIZED); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_GENERALIZED, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "EnumType":23
 * 
 * 
 * _ClosenessVariant = __Pyx_FlagBase('_ClosenessVariant', [             # <<<<<<<<<<<<<<
 *     ('STANDARD', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(STANDARD)),
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),
*/
  __pyx_t_5 = __Pyx_PyList_Pack(2, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "EnumType":27
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),
 * 
 * ], module=globals().get("__module__", 'networkit.centrality'))             # <<<<<<<<<<<<<<
 * 
 * if PY_VERSION_HEX >= 0x030B0000:
*/
  __pyx_t_7 = __Pyx_Globals(); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[1], NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ClosenessVariant, __pyx_t_5};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 23, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_module, __pyx_t_7, __pyx_t_6, __pyx_callargs+3, 0) < 0) __PYX_ERR(1, 23, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 23, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ClosenessVariant, __pyx_t_2) < 0) __PYX_ERR(1, 23, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "EnumType":29
 * ], module=globals().get("__module__", 'networkit.centrality'))
 * 
 * if PY_VERSION_HEX >= 0x030B0000:             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_t_9 = (PY_VERSION_HEX >= 0x030B0000);
  if (__pyx_t_9) {

    /* "EnumType":34
 * 
 * 
 *     _ClosenessVariant._member_names_ = list(_ClosenessVariant.__members__)             # <<<<<<<<<<<<<<
 * 
*/
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ClosenessVariant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 34, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_members); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 34, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PySequence_ListKeepNew(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 34, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ClosenessVariant); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 34, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_member_names, __pyx_t_2) < 0) __PYX_ERR(1, 34, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "EnumType":29
 * ], module=globals().get("__module__", 'networkit.centrality'))
 * 
 * if PY_VERSION_HEX >= 0x030B0000:             # <<<<<<<<<<<<<<
 * 
 * 
*/
  }

  /* "networkit/centrality.pyx":9
 * from libcpp cimport bool as bool_t
 * 
 * import math             # <<<<<<<<<<<<<<
 * 
 * from .base cimport _Algorithm, Algorithm
*/
  __pyx_t_4 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_math, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_4) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":13
 * from .base cimport _Algorithm, Algorithm
 * from .dynbase cimport _DynAlgorithm
 * from .dynbase import DynAlgorithm             # <<<<<<<<<<<<<<
 * from .dynamics cimport _GraphEvent, GraphEvent
 * from .graph cimport _Graph, Graph
*/
  __pyx_t_4 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_dynbase, __pyx_t_4, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); 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_mstate_global->__pyx_n_u_DynAlgorithm, __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;

  /* "networkit/centrality.pyx":17
 * from .graph cimport _Graph, Graph
 * from .structures cimport _Cover, Cover, _Partition, Partition, count, index, node, edgeweight
 * from networkit.algebraic import adjacencyEigenvector, PageRankMatrix, symmetricEigenvectors             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "limits.h":
*/
  __pyx_t_2 = __Pyx_PyList_Pack(3, __pyx_mstate_global->__pyx_n_u_adjacencyEigenvector, __pyx_mstate_global->__pyx_n_u_PageRankMatrix, __pyx_mstate_global->__pyx_n_u_symmetricEigenvectors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_networkit_algebraic, __pyx_t_2, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_adjacencyEigenvector); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_adjacencyEigenvector, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PageRankMatrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PageRankMatrix, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_symmetricEigenvectors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_symmetricEigenvectors, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":48
 * 		self._G = None # just to be sure the graph is deleted
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_5scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":63
 * 		return (<_Centrality*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_7score, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality_score, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality, __pyx_mstate_global->__pyx_n_u_score, __pyx_t_4) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":83
 * 		return (<_Centrality*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_9ranking, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_4) < 0) __PYX_ERR(0, 83, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":98
 * 		return (<_Centrality*>(self._this)).ranking()
 * 
 * 	def maximum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maximum()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_11maximum, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality_maximum, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality, __pyx_mstate_global->__pyx_n_u_maximum, __pyx_t_4) < 0) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":113
 * 		return (<_Centrality*>(self._this)).maximum()
 * 
 * 	def centralization(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		centralization()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_13centralization, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality_centralization, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Centrality, __pyx_mstate_global->__pyx_n_u_centralization, __pyx_t_4) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "self._this cannot be converted to a Python object for pickling"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_10Centrality_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Centrality___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":163
 * 
 * 
 * 	def edgeScores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		edgeScores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11Betweenness_3edgeScores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Betweenness_edgeScores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness, __pyx_mstate_global->__pyx_n_u_edgeScores, __pyx_t_4) < 0) __PYX_ERR(0, 163, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11Betweenness_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Betweenness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11Betweenness_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Betweenness___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":215
 * 		self._this = new _ApproxBetweenness(G._this, epsilon, delta, universalConstant)
 * 
 * 	def numberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		return (<_ApproxBetweenness*>(self._this)).numberOfSamples()
 * 
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17ApproxBetweenness_3numberOfSamples, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxBetweenness_numberOfSample, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxBetweenness, __pyx_mstate_global->__pyx_n_u_numberOfSamples, __pyx_t_4) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17ApproxBetweenness_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxBetweenness___reduce_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17ApproxBetweenness_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxBetweenness___setstate_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_19EstimateBetweenness_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_EstimateBetweenness___reduce_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_19EstimateBetweenness_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_EstimateBetweenness___setstate_c, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":323
 * 										   startFactor)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_3ranking, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_4) < 0) __PYX_ERR(0, 323, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":337
 * 		return (<_KadabraBetweenness*>(self._this)).ranking()
 * 
 * 	def topkNodesList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_5topkNodesList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_topkNodesList, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_topkNodesList, __pyx_t_4) < 0) __PYX_ERR(0, 337, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":352
 * 		return (<_KadabraBetweenness*>(self._this)).topkNodesList()
 * 
 * 	def topkScoresList(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_7topkScoresList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_topkScoresLis, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_topkScoresList, __pyx_t_4) < 0) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":366
 * 		return (<_KadabraBetweenness*>(self._this)).topkScoresList()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_9scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 366, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 366, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":381
 * 		return (<_KadabraBetweenness*>(self._this)).scores()
 * 
 * 	def getNumberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfIterations()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_11getNumberOfIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_getNumberOfIt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 381, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_getNumberOfIterations, __pyx_t_4) < 0) __PYX_ERR(0, 381, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":394
 * 		return (<_KadabraBetweenness*>(self._this)).getNumberOfIterations()
 * 
 * 	def getOmega(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getOmega()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_13getOmega, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness_getOmega, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_KadabraBetweenness, __pyx_mstate_global->__pyx_n_u_getOmega, __pyx_t_4) < 0) __PYX_ERR(0, 394, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness___reduce_cyth, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18KadabraBetweenness_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KadabraBetweenness___setstate_cy, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":415
 * 		double score(node) except +
 * 
 * cdef class DynBetweenness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynBetweenness(G)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyTuple_Pack(2, ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm), __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyTuple_Pack(3, __pyx_mstate_global->__pyx_n_u_DynBetweenness, __pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyTuple_GET_ITEM(__pyx_t_7, 1);
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_4)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_10 = ((PyTypeObject*)__Pyx_PyTuple_GET_ITEM(__pyx_t_4, 0));
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_10)) __PYX_ERR(0, 415, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
  if (__Pyx_get_runtime_version() < 0x030A0000) {
    __pyx_t_6 = PyObject_GetAttrString((PyObject*)&PyType_Type, "__new__");
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyTuple_Pack(1, (PyObject*)&PyType_Type);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 415, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_7);
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 415, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyObject_Call(__pyx_t_6, __pyx_t_3, NULL);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else
  #endif
  __pyx_t_2 = __Pyx_PyType_GetSlot(&PyType_Type, tp_new, newfunc)(&PyType_Type, __pyx_t_7, NULL);
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_2, tp_base, PyTypeObject*) != __pyx_t_10) {
    __Pyx_TypeName base_name = __Pyx_PyType_GetFullyQualifiedName(__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_2, tp_base, PyTypeObject*));
    __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(__pyx_t_10);
    PyErr_Format(PyExc_TypeError, "best base '" __Pyx_FMT_TYPENAME "' must be equal to first base '" __Pyx_FMT_TYPENAME "'",
                 base_name, type_name);
    __Pyx_DECREF_TypeName(base_name);
    __Pyx_DECREF_TypeName(type_name);
    __PYX_ERR(0, 415, __pyx_L1_error)
  }
  __pyx_t_10 = NULL;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  #if CYTHON_USE_TYPE_SPECS
  if (__Pyx_validate_bases_tuple(__pyx_type_9networkit_10centrality_DynBetweenness_spec.name, 0, __pyx_t_4) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DynBetweenness_spec, __pyx_t_4);
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness)) __PYX_ERR(0, 415, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DynBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
  #else
  __Pyx_INCREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_type_9networkit_10centrality_DynBetweenness.tp_bases = __pyx_t_4;
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness = &__pyx_type_9networkit_10centrality_DynBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DynBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweenness) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":433
 * 		self._this = new _DynBetweenness(G._this)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14DynBetweenness_3scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweenness_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweenness, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 433, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":446
 * 		return (<_DynBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14DynBetweenness_5score, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweenness_score, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 446, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweenness, __pyx_mstate_global->__pyx_n_u_score, __pyx_t_4) < 0) __PYX_ERR(0, 446, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":464
 * 		return (<_DynBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14DynBetweenness_7ranking, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweenness_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 464, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweenness, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_4) < 0) __PYX_ERR(0, 464, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14DynBetweenness_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweenness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14DynBetweenness_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweenness___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":487
 * 		count getNumberOfSamples() except +
 * 
 * cdef class DynApproxBetweenness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynApproxBetweenness(G, epsilon=0.01, delta=0.1, storePredecessors=True, universalConstant=1.0)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = PyTuple_Pack(2, ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm), __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = PyTuple_Pack(3, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness, __pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_4 = __Pyx_PyTuple_GET_ITEM(__pyx_t_3, 1);
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_4)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_10 = ((PyTypeObject*)__Pyx_PyTuple_GET_ITEM(__pyx_t_4, 0));
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_10)) __PYX_ERR(0, 487, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
  if (__Pyx_get_runtime_version() < 0x030A0000) {
    __pyx_t_2 = PyObject_GetAttrString((PyObject*)&PyType_Type, "__new__");
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = PyTuple_Pack(1, (PyObject*)&PyType_Type);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 487, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_3);
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 487, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyObject_Call(__pyx_t_2, __pyx_t_6, NULL);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else
  #endif
  __pyx_t_7 = __Pyx_PyType_GetSlot(&PyType_Type, tp_new, newfunc)(&PyType_Type, __pyx_t_3, NULL);
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_7, tp_base, PyTypeObject*) != __pyx_t_10) {
    __Pyx_TypeName base_name = __Pyx_PyType_GetFullyQualifiedName(__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_7, tp_base, PyTypeObject*));
    __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(__pyx_t_10);
    PyErr_Format(PyExc_TypeError, "best base '" __Pyx_FMT_TYPENAME "' must be equal to first base '" __Pyx_FMT_TYPENAME "'",
                 base_name, type_name);
    __Pyx_DECREF_TypeName(base_name);
    __Pyx_DECREF_TypeName(type_name);
    __PYX_ERR(0, 487, __pyx_L1_error)
  }
  __pyx_t_10 = NULL;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  #if CYTHON_USE_TYPE_SPECS
  if (__Pyx_validate_bases_tuple(__pyx_type_9networkit_10centrality_DynApproxBetweenness_spec.name, 0, __pyx_t_4) < 0) __PYX_ERR(0, 487, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DynApproxBetweenness_spec, __pyx_t_4);
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness)) __PYX_ERR(0, 487, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DynApproxBetweenness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness) < 0) __PYX_ERR(0, 487, __pyx_L1_error)
  #else
  __Pyx_INCREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_type_9networkit_10centrality_DynApproxBetweenness.tp_bases = __pyx_t_4;
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness = &__pyx_type_9networkit_10centrality_DynApproxBetweenness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness) < 0) __PYX_ERR(0, 487, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness) < 0) __PYX_ERR(0, 487, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness) < 0) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":520
 * 		self._this = new _DynApproxBetweenness(G._this, epsilon, delta, storePredecessors, universalConstant)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_3scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 520, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 520, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":533
 * 		return (<_DynApproxBetweenness*>(self._this)).scores()
 * 
 * 	def score(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		score(v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_5score, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness_score, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 533, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness, __pyx_mstate_global->__pyx_n_u_score, __pyx_t_4) < 0) __PYX_ERR(0, 533, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":551
 * 		return (<_DynApproxBetweenness*>(self._this)).score(v)
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_7ranking, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_4) < 0) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":565
 * 		return (<_DynApproxBetweenness*>(self._this)).ranking()
 * 
 * 	def getNumberOfSamples(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNumberOfSamples()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_9getNumberOfSamples, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness_getNumberOf, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynApproxBetweenness, __pyx_mstate_global->__pyx_n_u_getNumberOfSamples, __pyx_t_4) < 0) __PYX_ERR(0, 565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness___reduce_cy, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20DynApproxBetweenness_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynApproxBetweenness___setstate, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":587
 * 		double getbcx() except +
 * 
 * cdef class DynBetweennessOneNode(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynBetweennessOneNode(G, x)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = PyTuple_Pack(2, ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm), __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyTuple_Pack(3, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode, __pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __Pyx_PyTuple_GET_ITEM(__pyx_t_6, 1);
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_4)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_10 = ((PyTypeObject*)__Pyx_PyTuple_GET_ITEM(__pyx_t_4, 0));
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_10)) __PYX_ERR(0, 587, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
  if (__Pyx_get_runtime_version() < 0x030A0000) {
    __pyx_t_7 = PyObject_GetAttrString((PyObject*)&PyType_Type, "__new__");
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 587, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = PyTuple_Pack(1, (PyObject*)&PyType_Type);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 587, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_6);
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 587, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyObject_Call(__pyx_t_7, __pyx_t_2, NULL);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  } else
  #endif
  __pyx_t_3 = __Pyx_PyType_GetSlot(&PyType_Type, tp_new, newfunc)(&PyType_Type, __pyx_t_6, NULL);
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_3, tp_base, PyTypeObject*) != __pyx_t_10) {
    __Pyx_TypeName base_name = __Pyx_PyType_GetFullyQualifiedName(__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_3, tp_base, PyTypeObject*));
    __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(__pyx_t_10);
    PyErr_Format(PyExc_TypeError, "best base '" __Pyx_FMT_TYPENAME "' must be equal to first base '" __Pyx_FMT_TYPENAME "'",
                 base_name, type_name);
    __Pyx_DECREF_TypeName(base_name);
    __Pyx_DECREF_TypeName(type_name);
    __PYX_ERR(0, 587, __pyx_L1_error)
  }
  __pyx_t_10 = NULL;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  #if CYTHON_USE_TYPE_SPECS
  if (__Pyx_validate_bases_tuple(__pyx_type_9networkit_10centrality_DynBetweennessOneNode_spec.name, 0, __pyx_t_4) < 0) __PYX_ERR(0, 587, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DynBetweennessOneNode_spec, __pyx_t_4);
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode)) __PYX_ERR(0, 587, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DynBetweennessOneNode_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode) < 0) __PYX_ERR(0, 587, __pyx_L1_error)
  #else
  __Pyx_INCREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_type_9networkit_10centrality_DynBetweennessOneNode.tp_bases = __pyx_t_4;
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode = &__pyx_type_9networkit_10centrality_DynBetweennessOneNode;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode) < 0) __PYX_ERR(0, 587, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode) < 0) __PYX_ERR(0, 587, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode) < 0) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":613
 * 		del self._this
 * 
 * 	def getDistance(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDistance(u, v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_5getDistance, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode_getDistanc, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode, __pyx_mstate_global->__pyx_n_u_getDistance, __pyx_t_4) < 0) __PYX_ERR(0, 613, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":626
 * 		return (<_DynBetweennessOneNode*>(self._this)).getDistance(u, v)
 * 
 * 	def getSigma(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigma(u, v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_7getSigma, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode_getSigma, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode, __pyx_mstate_global->__pyx_n_u_getSigma, __pyx_t_4) < 0) __PYX_ERR(0, 626, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":639
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigma(u, v)
 * 
 * 	def getSigmax(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSigmax(u, v)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_9getSigmax, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode_getSigmax, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode, __pyx_mstate_global->__pyx_n_u_getSigmax, __pyx_t_4) < 0) __PYX_ERR(0, 639, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":653
 * 		return (<_DynBetweennessOneNode*>(self._this)).getSigmax(u, v)
 * 
 * 	def getbcx(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getbcx()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_11getbcx, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode_getbcx, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynBetweennessOneNode, __pyx_mstate_global->__pyx_n_u_getbcx, __pyx_t_4) < 0) __PYX_ERR(0, 653, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode___reduce_c, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21DynBetweennessOneNode_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynBetweennessOneNode___setstate, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":672
 * 		GENERALIZED
 * 
 * class ClosenessVariant(object):             # <<<<<<<<<<<<<<
 * 	STANDARD = _ClosenessVariant.STANDARD
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
*/
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_ClosenessVariant_2, __pyx_mstate_global->__pyx_n_u_ClosenessVariant_2, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[3]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[3]) < 0))) __PYX_ERR(0, 672, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":673
 * 
 * class ClosenessVariant(object):
 * 	STANDARD = _ClosenessVariant.STANDARD             # <<<<<<<<<<<<<<
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
 * 	Standard = STANDARD # this + following added for backwards compatibility
*/
  __pyx_t_2 = __Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(NetworKit::ClosenessVariant::STANDARD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_STANDARD, __pyx_t_2) < 0) __PYX_ERR(0, 673, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":674
 * class ClosenessVariant(object):
 * 	STANDARD = _ClosenessVariant.STANDARD
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED             # <<<<<<<<<<<<<<
 * 	Standard = STANDARD # this + following added for backwards compatibility
 * 	Generalized = GENERALIZED
*/
  __pyx_t_2 = __Pyx_Enum_f49861__9networkit_10centrality_enum__space_NetworKit___etc_to_py(NetworKit::ClosenessVariant::GENERALIZED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_GENERALIZED, __pyx_t_2) < 0) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":675
 * 	STANDARD = _ClosenessVariant.STANDARD
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
 * 	Standard = STANDARD # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	Generalized = GENERALIZED
 * 
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_STANDARD);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_STANDARD);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Standard, __pyx_t_2) < 0) __PYX_ERR(0, 675, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":676
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
 * 	Standard = STANDARD # this + following added for backwards compatibility
 * 	Generalized = GENERALIZED             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/Closeness.hpp>":
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_GENERALIZED);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_GENERALIZED);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Generalized, __pyx_t_2) < 0) __PYX_ERR(0, 676, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":672
 * 		GENERALIZED
 * 
 * class ClosenessVariant(object):             # <<<<<<<<<<<<<<
 * 	STANDARD = _ClosenessVariant.STANDARD
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
*/
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ClosenessVariant_2, __pyx_t_4, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ClosenessVariant_2, __pyx_t_2) < 0) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_9Closeness_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Closeness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_9Closeness_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Closeness___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":734
 * 		SUM
 * 
 * class ClosenessType(object):             # <<<<<<<<<<<<<<
 * 	INBOUND = _ClosenessType.INBOUND
 * 	OUTBOUND = _ClosenessType.OUTBOUND
*/
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[5]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_ClosenessType, __pyx_mstate_global->__pyx_n_u_ClosenessType, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[5]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[5]) < 0))) __PYX_ERR(0, 734, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":735
 * 
 * class ClosenessType(object):
 * 	INBOUND = _ClosenessType.INBOUND             # <<<<<<<<<<<<<<
 * 	OUTBOUND = _ClosenessType.OUTBOUND
 * 	SUM = _ClosenessType.SUM
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(NetworKit::ApproxCloseness::INBOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 735, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INBOUND, __pyx_t_2) < 0) __PYX_ERR(0, 735, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":736
 * class ClosenessType(object):
 * 	INBOUND = _ClosenessType.INBOUND
 * 	OUTBOUND = _ClosenessType.OUTBOUND             # <<<<<<<<<<<<<<
 * 	SUM = _ClosenessType.SUM
 * 	Inbound = INBOUND # this + following added for backwards compatibility
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(NetworKit::ApproxCloseness::OUTBOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OUTBOUND, __pyx_t_2) < 0) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":737
 * 	INBOUND = _ClosenessType.INBOUND
 * 	OUTBOUND = _ClosenessType.OUTBOUND
 * 	SUM = _ClosenessType.SUM             # <<<<<<<<<<<<<<
 * 	Inbound = INBOUND # this + following added for backwards compatibility
 * 	Outbound = OUTBOUND
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(NetworKit::ApproxCloseness::SUM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_t_2) < 0) __PYX_ERR(0, 737, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":738
 * 	OUTBOUND = _ClosenessType.OUTBOUND
 * 	SUM = _ClosenessType.SUM
 * 	Inbound = INBOUND # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	Outbound = OUTBOUND
 * 	Sum = SUM
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INBOUND);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_INBOUND);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 738, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Inbound, __pyx_t_2) < 0) __PYX_ERR(0, 738, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":739
 * 	SUM = _ClosenessType.SUM
 * 	Inbound = INBOUND # this + following added for backwards compatibility
 * 	Outbound = OUTBOUND             # <<<<<<<<<<<<<<
 * 	Sum = SUM
 * 
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OUTBOUND);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_OUTBOUND);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Outbound, __pyx_t_2) < 0) __PYX_ERR(0, 739, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":740
 * 	Inbound = INBOUND # this + following added for backwards compatibility
 * 	Outbound = OUTBOUND
 * 	Sum = SUM             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ApproxCloseness.hpp>":
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SUM);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SUM);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Sum, __pyx_t_2) < 0) __PYX_ERR(0, 740, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":734
 * 		SUM
 * 
 * class ClosenessType(object):             # <<<<<<<<<<<<<<
 * 	INBOUND = _ClosenessType.INBOUND
 * 	OUTBOUND = _ClosenessType.OUTBOUND
*/
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ClosenessType, __pyx_t_4, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ClosenessType, __pyx_t_2) < 0) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":782
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, nSamples, epsilon=0.1, normalized=False, _ClosenessType type=ClosenessType.OUTBOUND):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ClosenessType); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_OUTBOUND); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_11 = ((enum NetworKit::ApproxCloseness::ClosenessType)__Pyx_PyLong_As_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(__pyx_t_6)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 782, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_mstate_global->__pyx_k_ = __pyx_t_11;

  /* "networkit/centrality.pyx":786
 * 		self._this = new _ApproxCloseness(G._this, nSamples, epsilon, normalized, type)
 * 
 * 	def getSquareErrorEstimates(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getSquareErrorEstimates()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15ApproxCloseness_3getSquareErrorEstimates, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxCloseness_getSquareErrorEs, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 786, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxCloseness, __pyx_mstate_global->__pyx_n_u_getSquareErrorEstimates, __pyx_t_6) < 0) __PYX_ERR(0, 786, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15ApproxCloseness_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxCloseness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15ApproxCloseness_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxCloseness___setstate_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_16DegreeCentrality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DegreeCentrality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_16DegreeCentrality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DegreeCentrality___setstate_cyth, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17HarmonicCloseness_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HarmonicCloseness___reduce_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17HarmonicCloseness_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_HarmonicCloseness___setstate_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":906
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12TopCloseness_3topkNodesList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopCloseness_topkNodesList, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopCloseness, __pyx_mstate_global->__pyx_n_u_topkNodesList, __pyx_t_6) < 0) __PYX_ERR(0, 906, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":928
 * 		return (<_TopCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12TopCloseness_5topkScoresList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopCloseness_topkScoresList, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopCloseness, __pyx_mstate_global->__pyx_n_u_topkScoresList, __pyx_t_6) < 0) __PYX_ERR(0, 928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":950
 * 		return (<_TopCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		restrictTopKComputationToNodes(nodeList)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12TopCloseness_7restrictTopKComputationToNodes, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopCloseness_restrictTopKComputa, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopCloseness, __pyx_mstate_global->__pyx_n_u_restrictTopKComputationToNodes, __pyx_t_6) < 0) __PYX_ERR(0, 950, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12TopCloseness_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopCloseness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12TopCloseness_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopCloseness___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1010
 * 		self._this = new _TopHarmonicCloseness(G._this, k, useNBbound)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_3topkNodesList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness_topkNodesLi, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_topkNodesList, __pyx_t_6) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1032
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail=False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_5topkScoresList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness_topkScoresL, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1032, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_topkScoresList, __pyx_t_6) < 0) __PYX_ERR(0, 1032, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1054
 * 		return (<_TopHarmonicCloseness*>(self._this)).topkScoresList(includeTrail)
 * 
 * 	def restrictTopKComputationToNodes(self, nodeList):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(nodeList)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_7restrictTopKComputationToNodes, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness_restrictTop, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_TopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_restrictTopKComputationToNodes, __pyx_t_6) < 0) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness___reduce_cy, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20TopHarmonicCloseness_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_TopHarmonicCloseness___setstate, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1079
 * 		vector[edgeweight] topkScoresList(bool_t) except +
 * 
 * cdef class DynTopHarmonicCloseness(Algorithm, DynAlgorithm):             # <<<<<<<<<<<<<<
 * 	"""
 * 	DynTopHarmonicCloseness(G, k=1, useBFSbound=True)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DynAlgorithm); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyTuple_Pack(2, ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyTuple_Pack(3, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyTuple_GET_ITEM(__pyx_t_2, 1);
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_6)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_10 = ((PyTypeObject*)__Pyx_PyTuple_GET_ITEM(__pyx_t_6, 0));
  if (unlikely(!CYTHON_ASSUME_SAFE_MACROS && !__pyx_t_10)) __PYX_ERR(0, 1079, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
  if (__Pyx_get_runtime_version() < 0x030A0000) {
    __pyx_t_3 = PyObject_GetAttrString((PyObject*)&PyType_Type, "__new__");
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1079, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyTuple_Pack(1, (PyObject*)&PyType_Type);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1079, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = PyNumber_Add(__pyx_t_5, __pyx_t_2);
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1079, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_4 = PyObject_Call(__pyx_t_3, __pyx_t_7, NULL);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  } else
  #endif
  __pyx_t_4 = __Pyx_PyType_GetSlot(&PyType_Type, tp_new, newfunc)(&PyType_Type, __pyx_t_2, NULL);
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_4, tp_base, PyTypeObject*) != __pyx_t_10) {
    __Pyx_TypeName base_name = __Pyx_PyType_GetFullyQualifiedName(__Pyx_PyType_GetSlot((PyTypeObject*) __pyx_t_4, tp_base, PyTypeObject*));
    __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(__pyx_t_10);
    PyErr_Format(PyExc_TypeError, "best base '" __Pyx_FMT_TYPENAME "' must be equal to first base '" __Pyx_FMT_TYPENAME "'",
                 base_name, type_name);
    __Pyx_DECREF_TypeName(base_name);
    __Pyx_DECREF_TypeName(type_name);
    __PYX_ERR(0, 1079, __pyx_L1_error)
  }
  __pyx_t_10 = NULL;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  #if CYTHON_USE_TYPE_SPECS
  if (__Pyx_validate_bases_tuple(__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_spec.name, 0, __pyx_t_6) < 0) __PYX_ERR(0, 1079, __pyx_L1_error)
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_spec, __pyx_t_6);
  if (unlikely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness)) __PYX_ERR(0, 1079, __pyx_L1_error)
  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness_spec, __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness) < 0) __PYX_ERR(0, 1079, __pyx_L1_error)
  #else
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_6);
  __pyx_type_9networkit_10centrality_DynTopHarmonicCloseness.tp_bases = __pyx_t_6;
  __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness = &__pyx_type_9networkit_10centrality_DynTopHarmonicCloseness;
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  __pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness->tp_base = __pyx_mstate_global->__pyx_ptype_9networkit_4base_Algorithm;
  #endif
  #if !CYTHON_USE_TYPE_SPECS
  if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness) < 0) __PYX_ERR(0, 1079, __pyx_L1_error)
  #endif
  #if !CYTHON_COMPILING_IN_LIMITED_API
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness->tp_dictoffset && __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness->tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness->tp_getattro = PyObject_GenericGetAttr;
  }
  #endif
  if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness, (PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness) < 0) __PYX_ERR(0, 1079, __pyx_L1_error)
  if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness) < 0) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1111
 * 		self._this = new _DynTopHarmonicCloseness(G._this, k, useBFSbound)
 * 
 * 	def ranking(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking(includeTrail = False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_3ranking, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_6) < 0) __PYX_ERR(0, 1111, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1133
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).ranking(includeTrail)
 * 
 * 	def topkNodesList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail = False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_5topkNodesList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness_topkNode, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_topkNodesList, __pyx_t_6) < 0) __PYX_ERR(0, 1133, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1155
 * 		return (<_DynTopHarmonicCloseness*>(self._this)).topkNodesList(includeTrail)
 * 
 * 	def topkScoresList(self, includeTrail = False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkScoresList(includeTrail = False)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_7topkScoresList, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness_topkScor, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynTopHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_topkScoresList, __pyx_t_6) < 0) __PYX_ERR(0, 1155, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness___reduce, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_23DynTopHarmonicCloseness_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynTopHarmonicCloseness___setsta, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22LocalPartitionCoverage_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalPartitionCoverage___reduce, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22LocalPartitionCoverage_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalPartitionCoverage___setstat, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1242
 * 		self._this = new _GroupDegree(G._this, k, countGroupNodes)
 * 
 * 	def groupMaxDegree(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxDegree()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11GroupDegree_3groupMaxDegree, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupDegree_groupMaxDegree, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1242, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupDegree, __pyx_mstate_global->__pyx_n_u_groupMaxDegree, __pyx_t_6) < 0) __PYX_ERR(0, 1242, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1255
 * 		return (<_GroupDegree*>(self._this)).groupMaxDegree()
 * 
 * 	def getScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getScore()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11GroupDegree_5getScore, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupDegree_getScore, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupDegree, __pyx_mstate_global->__pyx_n_u_getScore, __pyx_t_6) < 0) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1271
 * 		return (<_GroupDegree*>(self._this)).getScore()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(vector[node] group)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11GroupDegree_7scoreOfGroup, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupDegree_scoreOfGroup, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1271, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupDegree, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1271, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11GroupDegree_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupDegree___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_11GroupDegree_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupDegree___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1301
 * 		STOCHASTIC
 * 
 * class BoundStrategy(object):             # <<<<<<<<<<<<<<
 * 	NO = _BoundStrategy.NO
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
*/
  __pyx_t_6 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_BoundStrategy, __pyx_mstate_global->__pyx_n_u_BoundStrategy, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__pyx_t_6 != __pyx_mstate_global->__pyx_tuple[8]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[8]) < 0))) __PYX_ERR(0, 1301, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":1302
 * 
 * class BoundStrategy(object):
 * 	NO = _BoundStrategy.NO             # <<<<<<<<<<<<<<
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
 * 	GEOMETRIC = _BoundStrategy.GEOMETRIC
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(NetworKit::GedWalk::NO); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_NO, __pyx_t_7) < 0) __PYX_ERR(0, 1302, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1303
 * class BoundStrategy(object):
 * 	NO = _BoundStrategy.NO
 * 	SPECTRAL = _BoundStrategy.SPECTRAL             # <<<<<<<<<<<<<<
 * 	GEOMETRIC = _BoundStrategy.GEOMETRIC
 * 	ADAPTIVE_GEOMETRIC = _BoundStrategy.ADAPTIVE_GEOMETRIC
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(NetworKit::GedWalk::SPECTRAL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1303, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SPECTRAL, __pyx_t_7) < 0) __PYX_ERR(0, 1303, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1304
 * 	NO = _BoundStrategy.NO
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
 * 	GEOMETRIC = _BoundStrategy.GEOMETRIC             # <<<<<<<<<<<<<<
 * 	ADAPTIVE_GEOMETRIC = _BoundStrategy.ADAPTIVE_GEOMETRIC
 * 	No = NO # this + following added for backwards compatibility
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(NetworKit::GedWalk::GEOMETRIC); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_GEOMETRIC, __pyx_t_7) < 0) __PYX_ERR(0, 1304, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1305
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
 * 	GEOMETRIC = _BoundStrategy.GEOMETRIC
 * 	ADAPTIVE_GEOMETRIC = _BoundStrategy.ADAPTIVE_GEOMETRIC             # <<<<<<<<<<<<<<
 * 	No = NO # this + following added for backwards compatibility
 * 	Spectral = SPECTRAL
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(NetworKit::GedWalk::ADAPTIVE_GEOMETRIC); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1305, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ADAPTIVE_GEOMETRIC, __pyx_t_7) < 0) __PYX_ERR(0, 1305, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1306
 * 	GEOMETRIC = _BoundStrategy.GEOMETRIC
 * 	ADAPTIVE_GEOMETRIC = _BoundStrategy.ADAPTIVE_GEOMETRIC
 * 	No = NO # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	Spectral = SPECTRAL
 * 	Geometric = GEOMETRIC
*/
  __pyx_t_7 = PyObject_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_NO);
  if (unlikely(!__pyx_t_7)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NO);
  }
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_No, __pyx_t_7) < 0) __PYX_ERR(0, 1306, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1307
 * 	ADAPTIVE_GEOMETRIC = _BoundStrategy.ADAPTIVE_GEOMETRIC
 * 	No = NO # this + following added for backwards compatibility
 * 	Spectral = SPECTRAL             # <<<<<<<<<<<<<<
 * 	Geometric = GEOMETRIC
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC
*/
  __pyx_t_7 = PyObject_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SPECTRAL);
  if (unlikely(!__pyx_t_7)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SPECTRAL);
  }
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1307, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Spectral, __pyx_t_7) < 0) __PYX_ERR(0, 1307, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1308
 * 	No = NO # this + following added for backwards compatibility
 * 	Spectral = SPECTRAL
 * 	Geometric = GEOMETRIC             # <<<<<<<<<<<<<<
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC
 * 
*/
  __pyx_t_7 = PyObject_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_GEOMETRIC);
  if (unlikely(!__pyx_t_7)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_GEOMETRIC);
  }
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1308, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Geometric, __pyx_t_7) < 0) __PYX_ERR(0, 1308, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1309
 * 	Spectral = SPECTRAL
 * 	Geometric = GEOMETRIC
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC             # <<<<<<<<<<<<<<
 * 
 * class GreedyStrategy(object):
*/
  __pyx_t_7 = PyObject_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ADAPTIVE_GEOMETRIC);
  if (unlikely(!__pyx_t_7)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ADAPTIVE_GEOMETRIC);
  }
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1309, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_AdaptiveGeometric, __pyx_t_7) < 0) __PYX_ERR(0, 1309, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1301
 * 		STOCHASTIC
 * 
 * class BoundStrategy(object):             # <<<<<<<<<<<<<<
 * 	NO = _BoundStrategy.NO
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
*/
  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BoundStrategy, __pyx_t_6, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BoundStrategy, __pyx_t_7) < 0) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1311
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC
 * 
 * class GreedyStrategy(object):             # <<<<<<<<<<<<<<
 * 	LAZY = _GreedyStrategy.LAZY
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
*/
  __pyx_t_6 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[10]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_GreedyStrategy, __pyx_mstate_global->__pyx_n_u_GreedyStrategy, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__pyx_t_6 != __pyx_mstate_global->__pyx_tuple[10]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[10]) < 0))) __PYX_ERR(0, 1311, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":1312
 * 
 * class GreedyStrategy(object):
 * 	LAZY = _GreedyStrategy.LAZY             # <<<<<<<<<<<<<<
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
 * 	Lazy = _GreedyStrategy.LAZY # this + following added for backwards compatibility
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(NetworKit::GedWalk::LAZY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_LAZY, __pyx_t_7) < 0) __PYX_ERR(0, 1312, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1313
 * class GreedyStrategy(object):
 * 	LAZY = _GreedyStrategy.LAZY
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC             # <<<<<<<<<<<<<<
 * 	Lazy = _GreedyStrategy.LAZY # this + following added for backwards compatibility
 * 	Stochastic = _GreedyStrategy.STOCHASTIC
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(NetworKit::GedWalk::STOCHASTIC); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_STOCHASTIC, __pyx_t_7) < 0) __PYX_ERR(0, 1313, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1314
 * 	LAZY = _GreedyStrategy.LAZY
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
 * 	Lazy = _GreedyStrategy.LAZY # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	Stochastic = _GreedyStrategy.STOCHASTIC
 * 
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(NetworKit::GedWalk::LAZY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Lazy, __pyx_t_7) < 0) __PYX_ERR(0, 1314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1315
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
 * 	Lazy = _GreedyStrategy.LAZY # this + following added for backwards compatibility
 * 	Stochastic = _GreedyStrategy.STOCHASTIC             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/GedWalk.hpp>":
*/
  __pyx_t_7 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(NetworKit::GedWalk::STOCHASTIC); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Stochastic, __pyx_t_7) < 0) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":1311
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC
 * 
 * class GreedyStrategy(object):             # <<<<<<<<<<<<<<
 * 	LAZY = _GreedyStrategy.LAZY
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
*/
  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_GreedyStrategy, __pyx_t_6, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_GreedyStrategy, __pyx_t_7) < 0) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1369
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = BoundStrategy.GEOMETRIC,             # <<<<<<<<<<<<<<
 * 			gs = GreedyStrategy.LAZY, spectralDelta = 0.5):
 * 
*/
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BoundStrategy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_GEOMETRIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_mstate_global->__pyx_k__2 = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":1370
 * 
 * 	def __cinit__(self, Graph G, k = 1, epsilon = 0.1, alpha = -1.0, bs = BoundStrategy.GEOMETRIC,
 * 			gs = GreedyStrategy.LAZY, spectralDelta = 0.5):             # <<<<<<<<<<<<<<
 * 
 * 		self._G = G
*/
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_GreedyStrategy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_LAZY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_mstate_global->__pyx_k__3 = __pyx_t_6;
  __Pyx_GIVEREF(__pyx_t_6);
  __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1380
 * 			self._this = NULL
 * 
 * 	def groupMaxGedWalk(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxGedWalk()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7GedWalk_5groupMaxGedWalk, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GedWalk_groupMaxGedWalk, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1380, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GedWalk, __pyx_mstate_global->__pyx_n_u_groupMaxGedWalk, __pyx_t_6) < 0) __PYX_ERR(0, 1380, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1393
 * 		return (<_GedWalk*>(self._this)).groupMaxGedWalk()
 * 
 * 	def getApproximateScore(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getApproximateScore()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7GedWalk_7getApproximateScore, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GedWalk_getApproximateScore, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1393, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GedWalk, __pyx_mstate_global->__pyx_n_u_getApproximateScore, __pyx_t_6) < 0) __PYX_ERR(0, 1393, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1406
 * 		return (<_GedWalk*>(self._this)).getApproximateScore()
 * 
 * 	def scoreOfGroup(self, group, epsilon = 0.1):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group, epsilon = 0.1)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7GedWalk_9scoreOfGroup, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GedWalk_scoreOfGroup, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[11]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GedWalk, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1406, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7GedWalk_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GedWalk___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7GedWalk_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GedWalk___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1462
 * 		self._this = new _ApproxGroupBetweenness(G._this, groupSize, epsilon)
 * 
 * 	def groupMaxBetweenness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxBetweenness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_3groupMaxBetweenness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxGroupBetweenness_groupMaxB, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1462, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness, __pyx_mstate_global->__pyx_n_u_groupMaxBetweenness, __pyx_t_6) < 0) __PYX_ERR(0, 1462, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1476
 * 		return (<_ApproxGroupBetweenness*>(self._this)).groupMaxBetweenness()
 * 
 * 	def scoreOfGroup(self, vector[node] group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_5scoreOfGroup, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxGroupBetweenness_scoreOfGr, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxGroupBetweenness, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1476, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxGroupBetweenness___reduce, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22ApproxGroupBetweenness_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxGroupBetweenness___setstat, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1526
 * 		self._this = new _GroupCloseness(G._this, k, H)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14GroupCloseness_3groupMaxCloseness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupCloseness_groupMaxCloseness, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupCloseness, __pyx_mstate_global->__pyx_n_u_groupMaxCloseness, __pyx_t_6) < 0) __PYX_ERR(0, 1526, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1539
 * 		return (<_GroupCloseness*>(self._this)).groupMaxCloseness()
 * 
 * 	def computeFarness(self, S, H=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeFarness(S, H=0)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14GroupCloseness_5computeFarness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupCloseness_computeFarness, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1539, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[12]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupCloseness, __pyx_mstate_global->__pyx_n_u_computeFarness, __pyx_t_6) < 0) __PYX_ERR(0, 1539, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1560
 * 		return (<_GroupCloseness*>(self._this)).computeFarness(S, H)
 * 
 * 	def scoreOfGroup(self, group):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14GroupCloseness_7scoreOfGroup, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupCloseness_scoreOfGroup, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupCloseness, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1560, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14GroupCloseness_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupCloseness___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14GroupCloseness_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupCloseness___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1615
 * 		self._this = new _GroupClosenessGrowShrink(G._this, group, extended, insertions)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_3groupMaxCloseness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessGrowShrink_groupMa, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1615, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink, __pyx_mstate_global->__pyx_n_u_groupMaxCloseness, __pyx_t_6) < 0) __PYX_ERR(0, 1615, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1628
 * 		return (<_GroupClosenessGrowShrink*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		Return the total number of iterations performed by the algorithm.
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_5numberOfIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessGrowShrink_numberO, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessGrowShrink, __pyx_mstate_global->__pyx_n_u_numberOfIterations, __pyx_t_6) < 0) __PYX_ERR(0, 1628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessGrowShrink___reduc, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessGrowShrink_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessGrowShrink___setst, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1672
 * 		self._this = new _GroupClosenessLocalSwaps(G._this, group, maxSwaps)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_3groupMaxCloseness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSwaps_groupMa, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps, __pyx_mstate_global->__pyx_n_u_groupMaxCloseness, __pyx_t_6) < 0) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1685
 * 		return (<_GroupClosenessLocalSwaps*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfSwaps(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfSwaps()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_5numberOfSwaps, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSwaps_numberO, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSwaps, __pyx_mstate_global->__pyx_n_u_numberOfSwaps, __pyx_t_6) < 0) __PYX_ERR(0, 1685, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSwaps___reduc, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_24GroupClosenessLocalSwaps_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSwaps___setst, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1735
 * 		self._this = new _GroupHarmonicCloseness(G._this, k)
 * 
 * 	def groupMaxHarmonicCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxHarmonicCloseness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_3groupMaxHarmonicCloseness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupHarmonicCloseness_groupMaxH, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1735, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_groupMaxHarmonicCloseness, __pyx_t_6) < 0) __PYX_ERR(0, 1735, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1748
 * 		return (<_GroupHarmonicCloseness*>(self._this)).groupMaxHarmonicCloseness()
 * 
 * 	@staticmethod             # <<<<<<<<<<<<<<
 * 	def scoreOfGroup(Graph graph, vector[node] inputGroup):
 * 		"""
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_5scoreOfGroup, __Pyx_CYFUNCTION_STATICMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupHarmonicCloseness_scoreOfGr, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1748, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_staticmethod);
  __pyx_t_4 = __pyx_builtin_staticmethod; 
  __Pyx_GetNameInClass(__pyx_t_7, (PyObject*)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_scoreOfGroup); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupHarmonicCloseness, __pyx_mstate_global->__pyx_n_u_scoreOfGroup, __pyx_t_6) < 0) __PYX_ERR(0, 1748, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupHarmonicCloseness___reduce, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22GroupHarmonicCloseness_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupHarmonicCloseness___setstat, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1820
 * 		self._this = new _GroupClosenessLocalSearch(G._this, group)
 * 
 * 	def groupMaxCloseness(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		groupMaxCloseness()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_7groupMaxCloseness, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSearch_groupM, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch, __pyx_mstate_global->__pyx_n_u_groupMaxCloseness, __pyx_t_6) < 0) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1833
 * 		return (<_GroupClosenessLocalSearch*>(self._this)).groupMaxCloseness()
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_9numberOfIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSearch_number, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_GroupClosenessLocalSearch, __pyx_mstate_global->__pyx_n_u_numberOfIterations, __pyx_t_6) < 0) __PYX_ERR(0, 1833, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSearch___redu, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25GroupClosenessLocalSearch_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GroupClosenessLocalSearch___sets, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15KPathCentrality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KPathCentrality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15KPathCentrality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KPathCentrality___setstate_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1879
 * 		OUT_EDGES
 * 
 * class EdgeDirection(object):             # <<<<<<<<<<<<<<
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
*/
  __pyx_t_6 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[14]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_EdgeDirection, __pyx_mstate_global->__pyx_n_u_EdgeDirection, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__pyx_t_6 != __pyx_mstate_global->__pyx_tuple[14]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_7, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[14]) < 0))) __PYX_ERR(0, 1879, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":1880
 * 
 * class EdgeDirection(object):
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,             # <<<<<<<<<<<<<<
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
 * 	inEdges = IN_EDGES # this + following added for backwards compatibility
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_EdgeDirection(NetworKit::IN_EDGES); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_IN_EDGES, __pyx_t_5) < 0) __PYX_ERR(0, 1880, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "networkit/centrality.pyx":1881
 * class EdgeDirection(object):
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,             # <<<<<<<<<<<<<<
 * 	inEdges = IN_EDGES # this + following added for backwards compatibility
 * 	outEdges = OUT_EDGES
*/
  __pyx_t_5 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_EdgeDirection(NetworKit::OUT_EDGES); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_OUT_EDGES, __pyx_t_2) < 0) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":1882
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
 * 	inEdges = IN_EDGES # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	outEdges = OUT_EDGES
 * 
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_IN_EDGES);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_IN_EDGES);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_inEdges, __pyx_t_2) < 0) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":1883
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
 * 	inEdges = IN_EDGES # this + following added for backwards compatibility
 * 	outEdges = OUT_EDGES             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/KatzCentrality.hpp>":
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_OUT_EDGES);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_OUT_EDGES);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_outEdges, __pyx_t_2) < 0) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":1879
 * 		OUT_EDGES
 * 
 * class EdgeDirection(object):             # <<<<<<<<<<<<<<
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
*/
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EdgeDirection, __pyx_t_6, __pyx_t_7, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EdgeDirection, __pyx_t_2) < 0) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14KatzCentrality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KatzCentrality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_14KatzCentrality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_KatzCentrality___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1963
 * 		self._this = new _DynKatzCentrality(G._this, k, groupOnly, tolerance)
 * 
 * 	def top(self, n=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		top(n=0)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17DynKatzCentrality_3top, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality_top, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1963, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[12]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynKatzCentrality, __pyx_mstate_global->__pyx_n_u_top, __pyx_t_6) < 0) __PYX_ERR(0, 1963, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1981
 * 		return (<_DynKatzCentrality*>(self._this)).top(n)
 * 
 * 	def bound(self, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		bound(v)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17DynKatzCentrality_5bound, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality_bound, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1981, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynKatzCentrality, __pyx_mstate_global->__pyx_n_u_bound, __pyx_t_6) < 0) __PYX_ERR(0, 1981, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":1999
 * 		return (<_DynKatzCentrality*>(self._this)).bound(v)
 * 
 * 	def areDistinguished(self, u, v):             # <<<<<<<<<<<<<<
 * 		"""
 * 		areDistinguished(u, v)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17DynKatzCentrality_7areDistinguished, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality_areDistinguish, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_DynKatzCentrality, __pyx_mstate_global->__pyx_n_u_areDistinguished, __pyx_t_6) < 0) __PYX_ERR(0, 1999, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17DynKatzCentrality_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality___reduce_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17DynKatzCentrality_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_DynKatzCentrality___setstate_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_26LocalClusteringCoefficient_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalClusteringCoefficient___red, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_26LocalClusteringCoefficient_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalClusteringCoefficient___set, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_32LocalSquareClusteringCoefficient_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalSquareClusteringCoefficient_2, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_32LocalSquareClusteringCoefficient_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LocalSquareClusteringCoefficient_3, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_9Sfigality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Sfigality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_9Sfigality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Sfigality___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[116])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2126
 * 		self._P = P
 * 
 * 	def getIntraClustering(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getIntraClustering(u)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20PermanenceCentrality_3getIntraClustering, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PermanenceCentrality_getIntraClu, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_PermanenceCentrality, __pyx_mstate_global->__pyx_n_u_getIntraClustering, __pyx_t_6) < 0) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2144
 * 		return (<_PermanenceCentrality*>(self._this)).getIntraClustering(u)
 * 
 * 	def getPermanence(self, node u):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPermanence(u)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20PermanenceCentrality_5getPermanence, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PermanenceCentrality_getPermanen, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_PermanenceCentrality, __pyx_mstate_global->__pyx_n_u_getPermanence, __pyx_t_6) < 0) __PYX_ERR(0, 2144, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20PermanenceCentrality_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PermanenceCentrality___reduce_cy, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_20PermanenceCentrality_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PermanenceCentrality___setstate, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_19LaplacianCentrality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LaplacianCentrality___reduce_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_19LaplacianCentrality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_LaplacianCentrality___setstate_c, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2226
 * 		self._this = new _CoreDecomposition(G._this, normalized, enforceBucketQueueAlgorithm, storeNodeOrder)
 * 
 * 	def maxCoreNumber(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		maxCoreNumber()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_3maxCoreNumber, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition_maxCoreNumber, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_CoreDecomposition, __pyx_mstate_global->__pyx_n_u_maxCoreNumber, __pyx_t_6) < 0) __PYX_ERR(0, 2226, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2239
 * 		return (<_CoreDecomposition*>(self._this)).maxCoreNumber()
 * 
 * 	def getCover(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getCover()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_5getCover, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition_getCover, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2239, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_CoreDecomposition, __pyx_mstate_global->__pyx_n_u_getCover, __pyx_t_6) < 0) __PYX_ERR(0, 2239, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2252
 * 		return Cover().setThis((<_CoreDecomposition*>(self._this)).getCover())
 * 
 * 	def getPartition(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPartition()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_7getPartition, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition_getPartition, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_CoreDecomposition, __pyx_mstate_global->__pyx_n_u_getPartition, __pyx_t_6) < 0) __PYX_ERR(0, 2252, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2265
 * 		return Partition().setThis((<_CoreDecomposition*>(self._this)).getPartition())
 * 
 * 	def getNodeOrder(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getNodeOrder()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_9getNodeOrder, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition_getNodeOrder, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_CoreDecomposition, __pyx_mstate_global->__pyx_n_u_getNodeOrder, __pyx_t_6) < 0) __PYX_ERR(0, 2265, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition___reduce_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_17CoreDecomposition_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_CoreDecomposition___setstate_cyt, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21EigenvectorCentrality_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_EigenvectorCentrality___reduce_c, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_21EigenvectorCentrality_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_EigenvectorCentrality___setstate, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_6) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2314
 * 		DISTRIBUTE_SINKS,
 * 
 * class Norm(object):             # <<<<<<<<<<<<<<
 * 	L1_NORM = _Norm.L1_NORM
 * 	L2_NORM = _Norm.L2_NORM
*/
  __pyx_t_6 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[16]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_Norm, __pyx_mstate_global->__pyx_n_u_Norm, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__pyx_t_6 != __pyx_mstate_global->__pyx_tuple[16]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_7, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[16]) < 0))) __PYX_ERR(0, 2314, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":2315
 * 
 * class Norm(object):
 * 	L1_NORM = _Norm.L1_NORM             # <<<<<<<<<<<<<<
 * 	L2_NORM = _Norm.L2_NORM
 * 	l1norm = L1_NORM # this + following added for backwards compatibility
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(NetworKit::PageRank::L1_NORM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_L1_NORM, __pyx_t_2) < 0) __PYX_ERR(0, 2315, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2316
 * class Norm(object):
 * 	L1_NORM = _Norm.L1_NORM
 * 	L2_NORM = _Norm.L2_NORM             # <<<<<<<<<<<<<<
 * 	l1norm = L1_NORM # this + following added for backwards compatibility
 * 	l2norm = L2_NORM
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(NetworKit::PageRank::L2_NORM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_L2_NORM, __pyx_t_2) < 0) __PYX_ERR(0, 2316, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2317
 * 	L1_NORM = _Norm.L1_NORM
 * 	L2_NORM = _Norm.L2_NORM
 * 	l1norm = L1_NORM # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	l2norm = L2_NORM
 * 
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_L1_NORM);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_L1_NORM);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2317, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_l1norm, __pyx_t_2) < 0) __PYX_ERR(0, 2317, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2318
 * 	L2_NORM = _Norm.L2_NORM
 * 	l1norm = L1_NORM # this + following added for backwards compatibility
 * 	l2norm = L2_NORM             # <<<<<<<<<<<<<<
 * 
 * class SinkHandling(object):
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_L2_NORM);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_L2_NORM);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_l2norm, __pyx_t_2) < 0) __PYX_ERR(0, 2318, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2314
 * 		DISTRIBUTE_SINKS,
 * 
 * class Norm(object):             # <<<<<<<<<<<<<<
 * 	L1_NORM = _Norm.L1_NORM
 * 	L2_NORM = _Norm.L2_NORM
*/
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Norm, __pyx_t_6, __pyx_t_7, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Norm, __pyx_t_2) < 0) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2320
 * 	l2norm = L2_NORM
 * 
 * class SinkHandling(object):             # <<<<<<<<<<<<<<
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
*/
  __pyx_t_6 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[18]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_SinkHandling, __pyx_mstate_global->__pyx_n_u_SinkHandling, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, (PyObject *) NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__pyx_t_6 != __pyx_mstate_global->__pyx_tuple[18]) {
    if (unlikely((PyDict_SetItemString(__pyx_t_7, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[18]) < 0))) __PYX_ERR(0, 2320, __pyx_L1_error)
  }

  /* "networkit/centrality.pyx":2321
 * 
 * class SinkHandling(object):
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING             # <<<<<<<<<<<<<<
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
 * 	NoSinkHandling = NO_SINK_HANDLING # this + following added for backwards compatibility
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(NetworKit::PageRank::NO_SINK_HANDLING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NO_SINK_HANDLING, __pyx_t_2) < 0) __PYX_ERR(0, 2321, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2322
 * class SinkHandling(object):
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS             # <<<<<<<<<<<<<<
 * 	NoSinkHandling = NO_SINK_HANDLING # this + following added for backwards compatibility
 * 	DistributeSinks = DISTRIBUTE_SINKS
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(NetworKit::PageRank::DISTRIBUTE_SINKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_L2_NORM, __pyx_t_2) < 0) __PYX_ERR(0, 2322, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2323
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
 * 	NoSinkHandling = NO_SINK_HANDLING # this + following added for backwards compatibility             # <<<<<<<<<<<<<<
 * 	DistributeSinks = DISTRIBUTE_SINKS
 * 
*/
  __pyx_t_2 = PyObject_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NO_SINK_HANDLING);
  if (unlikely(!__pyx_t_2)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NO_SINK_HANDLING);
  }
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2323, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_NoSinkHandling, __pyx_t_2) < 0) __PYX_ERR(0, 2323, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2324
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
 * 	NoSinkHandling = NO_SINK_HANDLING # this + following added for backwards compatibility
 * 	DistributeSinks = DISTRIBUTE_SINKS             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/PageRank.hpp>":
*/
  __pyx_t_2 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(NetworKit::PageRank::DISTRIBUTE_SINKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2324, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DistributeSinks, __pyx_t_2) < 0) __PYX_ERR(0, 2324, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "networkit/centrality.pyx":2320
 * 	l2norm = L2_NORM
 * 
 * class SinkHandling(object):             # <<<<<<<<<<<<<<
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
*/
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SinkHandling, __pyx_t_6, __pyx_t_7, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SinkHandling, __pyx_t_2) < 0) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2370
 * 	"""
 * 
 * 	def __cinit__(self, Graph G, double damp=0.85, double tol=1e-8, bool_t normalized=False, distributeSinks=SinkHandling.NO_SINK_HANDLING):             # <<<<<<<<<<<<<<
 * 		self._G = G
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SinkHandling); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_NO_SINK_HANDLING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_mstate_global->__pyx_k__4 = __pyx_t_4;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2374
 * 		self._this = new _PageRank(G._this, damp, tol, normalized, distributeSinks)
 * 
 * 	def numberOfIterations(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		numberOfIterations()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8PageRank_3numberOfIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PageRank_numberOfIterations, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_PageRank, __pyx_mstate_global->__pyx_n_u_numberOfIterations, __pyx_t_4) < 0) __PYX_ERR(0, 2374, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8PageRank_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PageRank___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8PageRank_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PageRank___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2447
 * 		self._this = new _SpanningEdgeCentrality(G._this, tol)
 * 
 * 	def runApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runApproximation()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_3runApproximation, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality_runApprox, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality, __pyx_mstate_global->__pyx_n_u_runApproximation, __pyx_t_4) < 0) __PYX_ERR(0, 2447, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2457
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runApproximation()
 * 
 * 	def runParallelApproximation(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		runParallelApproximation()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_5runParallelApproximation, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality_runParall, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality, __pyx_mstate_global->__pyx_n_u_runParallelApproximation, __pyx_t_4) < 0) __PYX_ERR(0, 2457, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2467
 * 		return (<_SpanningEdgeCentrality*>(self._this)).runParallelApproximation()
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_7scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_SpanningEdgeCentrality, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 2467, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality___reduce, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_22SpanningEdgeCentrality_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SpanningEdgeCentrality___setstat, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2515
 * 		self._this = new _ApproxElectricalCloseness(G._this, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_3getDiagonal, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxElectricalCloseness_getDia, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness, __pyx_mstate_global->__pyx_n_u_getDiagonal, __pyx_t_4) < 0) __PYX_ERR(0, 2515, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2528
 * 		return (<_ApproxElectricalCloseness*>self._this).getDiagonal()
 * 
 * 	def computeExactDiagonal(self, double tol = 1e-9):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeExactDiagonal(tol = 1e-9)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_5computeExactDiagonal, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxElectricalCloseness_comput, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2528, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[19]);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxElectricalCloseness, __pyx_mstate_global->__pyx_n_u_computeExactDiagonal, __pyx_t_4) < 0) __PYX_ERR(0, 2528, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxElectricalCloseness___redu, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_25ApproxElectricalCloseness_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxElectricalCloseness___sets, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2588
 * 		self._this = new _ForestCentrality(G._this, root, eps, kappa)
 * 
 * 	def getDiagonal(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getDiagonal()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_16ForestCentrality_3getDiagonal, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ForestCentrality_getDiagonal, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2588, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ForestCentrality, __pyx_mstate_global->__pyx_n_u_getDiagonal, __pyx_t_4) < 0) __PYX_ERR(0, 2588, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_16ForestCentrality_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ForestCentrality___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_16ForestCentrality_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ForestCentrality___setstate_cyth, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2628
 * 		self._this = new _ApproxSpanningEdge(G._this, eps)
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_3scores, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxSpanningEdge_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ApproxSpanningEdge, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 2628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxSpanningEdge___reduce_cyth, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18ApproxSpanningEdge_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ApproxSpanningEdge___setstate_cy, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2642
 * 		return (<_ApproxSpanningEdge*>(self._this)).scores();
 * 
 * def ranking(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	ranking(G, algorithm=networkit.centrality.Betweenness, normalized=False)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_1ranking, 0, __pyx_mstate_global->__pyx_n_u_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_9networkit_10centrality___pyx_defaults)) __PYX_ERR(0, 2642, __pyx_L1_error)
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_4)->arg0 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_9networkit_10centrality_10__defaults__);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_4) < 0) __PYX_ERR(0, 2642, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2667
 * 	return centrality.ranking()
 * 
 * def scores(G, algorithm=Betweenness, normalized=False):             # <<<<<<<<<<<<<<
 * 	"""
 * 	scores(G, algorithm=Betweenness, normalized=False)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_3scores, 0, __pyx_mstate_global->__pyx_n_u_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_9networkit_10centrality___pyx_defaults)) __PYX_ERR(0, 2667, __pyx_L1_error)
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_4)->arg0 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_Betweenness);
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_9networkit_10centrality_12__defaults__);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_4) < 0) __PYX_ERR(0, 2667, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2691
 * 	return centrality.scores()
 * 
 * def rankPerNode(ranking):             # <<<<<<<<<<<<<<
 * 	"""
 * 	rankPerNode(ranking)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_5rankPerNode, 0, __pyx_mstate_global->__pyx_n_u_rankPerNode, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2691, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_rankPerNode, __pyx_t_4) < 0) __PYX_ERR(0, 2691, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2720
 * 	return ranking_id
 * 
 * def relativeRankErrors(rx, ry):             # <<<<<<<<<<<<<<
 * 	"""
 * 	relativeRankErrors(rx, ry)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_7relativeRankErrors, 0, __pyx_mstate_global->__pyx_n_u_relativeRankErrors, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2720, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_relativeRankErrors, __pyx_t_4) < 0) __PYX_ERR(0, 2720, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2750
 * 	return diff
 * 
 * class SpectralCentrality:             # <<<<<<<<<<<<<<
 * 	"""
 * 	SpectralCentrality(G, normalized=False)
*/
  __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_SpectralCentrality, __pyx_mstate_global->__pyx_n_u_SpectralCentrality, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_kp_u_SpectralCentrality_G_normalized); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2750, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

  /* "networkit/centrality.pyx":2764
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SpectralCentrality, self).__init__()
 * 
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_1__init__, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality___init, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[153])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_6) < 0) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2774
 * 		self.evz = {}
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_3prepareSpectrum, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_prepareSpectr, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[154])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_prepareSpectrum, __pyx_t_6) < 0) __PYX_ERR(0, 2774, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2782
 * 		raise NotImplemented
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_5normFactor, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_normFactor, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[155])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_normFactor, __pyx_t_6) < 0) __PYX_ERR(0, 2782, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2790
 * 		raise NotImplemented
 * 
 * 	def run(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		run()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_7run, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_run, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[156])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2790, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_run, __pyx_t_6) < 0) __PYX_ERR(0, 2790, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2811
 * 		return self
 * 
 * 	def scores(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scores()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_9scores, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_scores, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[157])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2811, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_scores, __pyx_t_6) < 0) __PYX_ERR(0, 2811, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2827
 * 		return self.scoreList
 * 
 * 	def ranking(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		ranking()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_18SpectralCentrality_11ranking, 0, __pyx_mstate_global->__pyx_n_u_SpectralCentrality_ranking, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[158])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2827, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ranking, __pyx_t_6) < 0) __PYX_ERR(0, 2827, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2750
 * 	return diff
 * 
 * class SpectralCentrality:             # <<<<<<<<<<<<<<
 * 	"""
 * 	SpectralCentrality(G, normalized=False)
*/
  __pyx_t_6 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_SpectralCentrality, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2750, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SpectralCentrality, __pyx_t_6) < 0) __PYX_ERR(0, 2750, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2843
 * 
 * 
 * class SciPyEVZ(SpectralCentrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	SciPyEVZ(G, normalized=False)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SpectralCentrality); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_7, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_SciPyEVZ, __pyx_mstate_global->__pyx_n_u_SciPyEVZ, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_kp_u_SciPyEVZ_G_normalized_False_Com); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__pyx_t_4 != __pyx_t_6) {
    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_6) < 0))) __PYX_ERR(0, 2843, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2856
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, normalized=False):             # <<<<<<<<<<<<<<
 * 		if G.isDirected():
 * 			raise NotImplementedError("Not implemented for directed graphs; use centrality.EigenvectorCentrality instead")
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8SciPyEVZ_1__init__, 0, __pyx_mstate_global->__pyx_n_u_SciPyEVZ___init, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[6]);
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_6) < 0) __PYX_ERR(0, 2856, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2861
 * 		super(SciPyEVZ, self).__init__(G, normalized=normalized)
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		square = sum([val * val for val in vector])
 * 		return math.sqrt(square)
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8SciPyEVZ_3_length, 0, __pyx_mstate_global->__pyx_n_u_SciPyEVZ__length, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_length, __pyx_t_6) < 0) __PYX_ERR(0, 2861, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2865
 * 		return math.sqrt(square)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8SciPyEVZ_5normFactor, 0, __pyx_mstate_global->__pyx_n_u_SciPyEVZ_normFactor, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_normFactor, __pyx_t_6) < 0) __PYX_ERR(0, 2865, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2878
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_8SciPyEVZ_7prepareSpectrum, 0, __pyx_mstate_global->__pyx_n_u_SciPyEVZ_prepareSpectrum, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_prepareSpectrum, __pyx_t_6) < 0) __PYX_ERR(0, 2878, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

  /* "networkit/centrality.pyx":2843
 * 
 * 
 * class SciPyEVZ(SpectralCentrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	SciPyEVZ(G, normalized=False)
*/
  __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SciPyEVZ, __pyx_t_4, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SciPyEVZ, __pyx_t_6) < 0) __PYX_ERR(0, 2843, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2888
 * 		self.eigenvalue = spectrum[0]
 * 
 * class SciPyPageRank(SpectralCentrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	SciPyPageRank(G, damp=0.95, normalized=False)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SpectralCentrality); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_SciPyPageRank, __pyx_mstate_global->__pyx_n_u_SciPyPageRank, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_kp_u_SciPyPageRank_G_damp_0_95_norma); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (__pyx_t_4 != __pyx_t_7) {
    if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_t_7) < 0))) __PYX_ERR(0, 2888, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":2903
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, damp=0.95, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)
 * 
*/
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_13SciPyPageRank_1__init__, 0, __pyx_mstate_global->__pyx_n_u_SciPyPageRank___init, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_mstate_global->__pyx_tuple[20]);
  if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_7) < 0) __PYX_ERR(0, 2903, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":2908
 * 		self.damp = damp
 * 
 * 	def _length(self, vector):             # <<<<<<<<<<<<<<
 * 		return sum(vector)
 * 
*/
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_13SciPyPageRank_3_length, 0, __pyx_mstate_global->__pyx_n_u_SciPyPageRank__length, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2908, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_length, __pyx_t_7) < 0) __PYX_ERR(0, 2908, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":2911
 * 		return sum(vector)
 * 
 * 	def normFactor(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normFactor()
*/
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_13SciPyPageRank_5normFactor, 0, __pyx_mstate_global->__pyx_n_u_SciPyPageRank_normFactor, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_normFactor, __pyx_t_7) < 0) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":2924
 * 		return 1 / self._length(self.eigenvector)
 * 
 * 	def prepareSpectrum(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		prepareSpectrum()
*/
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_13SciPyPageRank_7prepareSpectrum, 0, __pyx_mstate_global->__pyx_n_u_SciPyPageRank_prepareSpectrum, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_prepareSpectrum, __pyx_t_7) < 0) __PYX_ERR(0, 2924, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

  /* "networkit/centrality.pyx":2888
 * 		self.eigenvalue = spectrum[0]
 * 
 * class SciPyPageRank(SpectralCentrality):             # <<<<<<<<<<<<<<
 * 	"""
 * 	SciPyPageRank(G, damp=0.95, normalized=False)
*/
  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SciPyPageRank, __pyx_t_4, __pyx_t_6, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SciPyPageRank, __pyx_t_7) < 0) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2943
 * 
 * cdef class ComplexPathMode(object):
 * 	SINGLE_NODE = _Mode.singleNode             # <<<<<<<<<<<<<<
 * 	ALL_NODES   = _Mode.allNodes
 * 
*/
  __pyx_t_4 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(NetworKit::ComplexPathAlgorithm::singleNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2943, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode, __pyx_mstate_global->__pyx_n_u_SINGLE_NODE, __pyx_t_4) < 0) __PYX_ERR(0, 2943, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2944
 * cdef class ComplexPathMode(object):
 * 	SINGLE_NODE = _Mode.singleNode
 * 	ALL_NODES   = _Mode.allNodes             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "<networkit/centrality/ComplexPaths.hpp>":
*/
  __pyx_t_4 = __Pyx_PyLong_From_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(NetworKit::ComplexPathAlgorithm::allNodes); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2944, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode, __pyx_mstate_global->__pyx_n_u_ALL_NODES, __pyx_t_4) < 0) __PYX_ERR(0, 2944, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     cdef tuple state
 *     cdef object _dict
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15ComplexPathMode_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPathMode___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[167])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":16
 *     else:
 *         return __pyx_unpickle_ComplexPathMode, (type(self), 0xe3b0c44, state)
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     __pyx_unpickle_ComplexPathMode__set_state(self, __pyx_state)
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_15ComplexPathMode_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPathMode___setstate_cytho, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[168])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPathMode, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2987
 * 	cdef Graph _G
 * 
 * 	def __cinit__(self, Graph G, threshold=3, mode="allNodes", start=_none):             # <<<<<<<<<<<<<<
 * 		if mode=="allNodes":
 * 			mode=ComplexPathMode.ALL_NODES
*/
  __pyx_t_4 = __Pyx_PyLong_From_uint64_t(NetworKit::none); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2987, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_mstate_global->__pyx_k__5 = __pyx_t_4;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":2995
 * 		self._this = new _ComplexPaths(G._this, threshold, mode, start)
 * 
 * 	def getPLci(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getPLci()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_3getPLci, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths_getPLci, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2995, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPaths, __pyx_mstate_global->__pyx_n_u_getPLci, __pyx_t_4) < 0) __PYX_ERR(0, 2995, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":3010
 * 		return (<_ComplexPaths*>(self._this)).getPLci()
 * 
 * 	def getComplexGraph(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getComplexGraph()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_5getComplexGraph, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths_getComplexGraph, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPaths, __pyx_mstate_global->__pyx_n_u_getComplexGraph, __pyx_t_4) < 0) __PYX_ERR(0, 3010, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":3023
 * 		return Graph().setThis((<_ComplexPaths*>(self._this)).getComplexGraph())
 * 
 * 	def getAdopters(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		getAdopters()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_7getAdopters, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths_getAdopters, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3023, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPaths, __pyx_mstate_global->__pyx_n_u_getAdopters, __pyx_t_4) < 0) __PYX_ERR(0, 3023, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":3038
 * 		return (<_ComplexPaths*>(self._this)).getAdopters()
 * 
 * 	def normalize(self):             # <<<<<<<<<<<<<<
 * 		"""
 * 		normalize()
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_9normalize, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths_normalize, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[172])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_9networkit_10centrality_ComplexPaths, __pyx_mstate_global->__pyx_n_u_normalize, __pyx_t_4) < 0) __PYX_ERR(0, 3038, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[173])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":3
 * def __reduce_cython__(self):
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
 * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
 *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_12ComplexPaths_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_ComplexPaths___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[174])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "(tree fragment)":1
 * def __pyx_unpickle_ComplexPathMode(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
*/
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9networkit_10centrality_9__pyx_unpickle_ComplexPathMode, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_ComplexPathMode, NULL, __pyx_mstate_global->__pyx_n_u_networkit_centrality, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[175])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_ComplexPathMode, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "networkit/centrality.pyx":1
 * # distutils: language=c++             # <<<<<<<<<<<<<<
 * 
 * from libc.stdint cimport uint64_t
*/
  __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  if (__pyx_m) {
    if (__pyx_mstate->__pyx_d && stringtab_initialized) {
      __Pyx_AddTraceback("init networkit.centrality", __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 networkit.centrality");
  }
  __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 ### */

typedef struct {
    const char *s;
#if 425 <= 65535
    const unsigned short n;
#elif 425 / 2 < INT_MAX
    const unsigned int n;
#elif 425 / 2 < LONG_MAX
    const unsigned long n;
#else
    const Py_ssize_t n;
#endif
#if 1 <= 31
    const unsigned int encoding : 5;
#elif 1 <= 255
    const unsigned char encoding;
#elif 1 <= 65535
    const unsigned short encoding;
#else
    const Py_ssize_t encoding;
#endif
    const unsigned int is_unicode : 1;
    const unsigned int intern : 1;
} __Pyx_StringTabEntry;
static const char * const __pyx_string_tab_encodings[] = { 0 };
static const __Pyx_StringTabEntry __pyx_string_tab[] = {
  {__pyx_k_ADAPTIVE_GEOMETRIC, sizeof(__pyx_k_ADAPTIVE_GEOMETRIC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADAPTIVE_GEOMETRIC */
  {__pyx_k_ALL_NODES, sizeof(__pyx_k_ALL_NODES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ALL_NODES */
  {__pyx_k_AdaptiveGeometric, sizeof(__pyx_k_AdaptiveGeometric), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AdaptiveGeometric */
  {__pyx_k_ApproxBetweenness, sizeof(__pyx_k_ApproxBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxBetweenness */
  {__pyx_k_ApproxBetweenness___reduce_cytho, sizeof(__pyx_k_ApproxBetweenness___reduce_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxBetweenness___reduce_cytho */
  {__pyx_k_ApproxBetweenness___setstate_cyt, sizeof(__pyx_k_ApproxBetweenness___setstate_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxBetweenness___setstate_cyt */
  {__pyx_k_ApproxBetweenness_numberOfSample, sizeof(__pyx_k_ApproxBetweenness_numberOfSample), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxBetweenness_numberOfSample */
  {__pyx_k_ApproxCloseness, sizeof(__pyx_k_ApproxCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxCloseness */
  {__pyx_k_ApproxCloseness___reduce_cython, sizeof(__pyx_k_ApproxCloseness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxCloseness___reduce_cython */
  {__pyx_k_ApproxCloseness___setstate_cytho, sizeof(__pyx_k_ApproxCloseness___setstate_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxCloseness___setstate_cytho */
  {__pyx_k_ApproxCloseness_getSquareErrorEs, sizeof(__pyx_k_ApproxCloseness_getSquareErrorEs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxCloseness_getSquareErrorEs */
  {__pyx_k_ApproxElectricalCloseness, sizeof(__pyx_k_ApproxElectricalCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxElectricalCloseness */
  {__pyx_k_ApproxElectricalCloseness___redu, sizeof(__pyx_k_ApproxElectricalCloseness___redu), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxElectricalCloseness___redu */
  {__pyx_k_ApproxElectricalCloseness___sets, sizeof(__pyx_k_ApproxElectricalCloseness___sets), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxElectricalCloseness___sets */
  {__pyx_k_ApproxElectricalCloseness_comput, sizeof(__pyx_k_ApproxElectricalCloseness_comput), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxElectricalCloseness_comput */
  {__pyx_k_ApproxElectricalCloseness_getDia, sizeof(__pyx_k_ApproxElectricalCloseness_getDia), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxElectricalCloseness_getDia */
  {__pyx_k_ApproxGroupBetweenness, sizeof(__pyx_k_ApproxGroupBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxGroupBetweenness */
  {__pyx_k_ApproxGroupBetweenness___reduce, sizeof(__pyx_k_ApproxGroupBetweenness___reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxGroupBetweenness___reduce */
  {__pyx_k_ApproxGroupBetweenness___setstat, sizeof(__pyx_k_ApproxGroupBetweenness___setstat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxGroupBetweenness___setstat */
  {__pyx_k_ApproxGroupBetweenness_groupMaxB, sizeof(__pyx_k_ApproxGroupBetweenness_groupMaxB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxGroupBetweenness_groupMaxB */
  {__pyx_k_ApproxGroupBetweenness_scoreOfGr, sizeof(__pyx_k_ApproxGroupBetweenness_scoreOfGr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxGroupBetweenness_scoreOfGr */
  {__pyx_k_ApproxSpanningEdge, sizeof(__pyx_k_ApproxSpanningEdge), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxSpanningEdge */
  {__pyx_k_ApproxSpanningEdge___reduce_cyth, sizeof(__pyx_k_ApproxSpanningEdge___reduce_cyth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxSpanningEdge___reduce_cyth */
  {__pyx_k_ApproxSpanningEdge___setstate_cy, sizeof(__pyx_k_ApproxSpanningEdge___setstate_cy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxSpanningEdge___setstate_cy */
  {__pyx_k_ApproxSpanningEdge_scores, sizeof(__pyx_k_ApproxSpanningEdge_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ApproxSpanningEdge_scores */
  {__pyx_k_Betweenness, sizeof(__pyx_k_Betweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Betweenness */
  {__pyx_k_Betweenness___reduce_cython, sizeof(__pyx_k_Betweenness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Betweenness___reduce_cython */
  {__pyx_k_Betweenness___setstate_cython, sizeof(__pyx_k_Betweenness___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Betweenness___setstate_cython */
  {__pyx_k_Betweenness_edgeScores, sizeof(__pyx_k_Betweenness_edgeScores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Betweenness_edgeScores */
  {__pyx_k_BoundStrategy, sizeof(__pyx_k_BoundStrategy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BoundStrategy */
  {__pyx_k_Centrality, sizeof(__pyx_k_Centrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality */
  {__pyx_k_Centrality___reduce_cython, sizeof(__pyx_k_Centrality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality___reduce_cython */
  {__pyx_k_Centrality___setstate_cython, sizeof(__pyx_k_Centrality___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality___setstate_cython */
  {__pyx_k_Centrality_centralization, sizeof(__pyx_k_Centrality_centralization), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality_centralization */
  {__pyx_k_Centrality_maximum, sizeof(__pyx_k_Centrality_maximum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality_maximum */
  {__pyx_k_Centrality_ranking, sizeof(__pyx_k_Centrality_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality_ranking */
  {__pyx_k_Centrality_score, sizeof(__pyx_k_Centrality_score), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality_score */
  {__pyx_k_Centrality_scores, sizeof(__pyx_k_Centrality_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Centrality_scores */
  {__pyx_k_Closeness, sizeof(__pyx_k_Closeness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Closeness */
  {__pyx_k_ClosenessType, sizeof(__pyx_k_ClosenessType), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ClosenessType */
  {__pyx_k_ClosenessVariant, sizeof(__pyx_k_ClosenessVariant), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ClosenessVariant */
  {__pyx_k_ClosenessVariant_2, sizeof(__pyx_k_ClosenessVariant_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ClosenessVariant_2 */
  {__pyx_k_Closeness___reduce_cython, sizeof(__pyx_k_Closeness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Closeness___reduce_cython */
  {__pyx_k_Closeness___setstate_cython, sizeof(__pyx_k_Closeness___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Closeness___setstate_cython */
  {__pyx_k_ComplexPathMode, sizeof(__pyx_k_ComplexPathMode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPathMode */
  {__pyx_k_ComplexPathMode___reduce_cython, sizeof(__pyx_k_ComplexPathMode___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPathMode___reduce_cython */
  {__pyx_k_ComplexPathMode___setstate_cytho, sizeof(__pyx_k_ComplexPathMode___setstate_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPathMode___setstate_cytho */
  {__pyx_k_ComplexPaths, sizeof(__pyx_k_ComplexPaths), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths */
  {__pyx_k_ComplexPaths___reduce_cython, sizeof(__pyx_k_ComplexPaths___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths___reduce_cython */
  {__pyx_k_ComplexPaths___setstate_cython, sizeof(__pyx_k_ComplexPaths___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths___setstate_cython */
  {__pyx_k_ComplexPaths_getAdopters, sizeof(__pyx_k_ComplexPaths_getAdopters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths_getAdopters */
  {__pyx_k_ComplexPaths_getComplexGraph, sizeof(__pyx_k_ComplexPaths_getComplexGraph), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths_getComplexGraph */
  {__pyx_k_ComplexPaths_getPLci, sizeof(__pyx_k_ComplexPaths_getPLci), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths_getPLci */
  {__pyx_k_ComplexPaths_normalize, sizeof(__pyx_k_ComplexPaths_normalize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ComplexPaths_normalize */
  {__pyx_k_CoreDecomposition, sizeof(__pyx_k_CoreDecomposition), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition */
  {__pyx_k_CoreDecomposition___reduce_cytho, sizeof(__pyx_k_CoreDecomposition___reduce_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition___reduce_cytho */
  {__pyx_k_CoreDecomposition___setstate_cyt, sizeof(__pyx_k_CoreDecomposition___setstate_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition___setstate_cyt */
  {__pyx_k_CoreDecomposition_getCover, sizeof(__pyx_k_CoreDecomposition_getCover), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition_getCover */
  {__pyx_k_CoreDecomposition_getNodeOrder, sizeof(__pyx_k_CoreDecomposition_getNodeOrder), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition_getNodeOrder */
  {__pyx_k_CoreDecomposition_getPartition, sizeof(__pyx_k_CoreDecomposition_getPartition), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition_getPartition */
  {__pyx_k_CoreDecomposition_maxCoreNumber, sizeof(__pyx_k_CoreDecomposition_maxCoreNumber), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CoreDecomposition_maxCoreNumber */
  {__pyx_k_DegreeCentrality, sizeof(__pyx_k_DegreeCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DegreeCentrality */
  {__pyx_k_DegreeCentrality___reduce_cython, sizeof(__pyx_k_DegreeCentrality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DegreeCentrality___reduce_cython */
  {__pyx_k_DegreeCentrality___setstate_cyth, sizeof(__pyx_k_DegreeCentrality___setstate_cyth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DegreeCentrality___setstate_cyth */
  {__pyx_k_DistributeSinks, sizeof(__pyx_k_DistributeSinks), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DistributeSinks */
  {__pyx_k_DynAlgorithm, sizeof(__pyx_k_DynAlgorithm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynAlgorithm */
  {__pyx_k_DynApproxBetweenness, sizeof(__pyx_k_DynApproxBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness */
  {__pyx_k_DynApproxBetweenness___reduce_cy, sizeof(__pyx_k_DynApproxBetweenness___reduce_cy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness___reduce_cy */
  {__pyx_k_DynApproxBetweenness___setstate, sizeof(__pyx_k_DynApproxBetweenness___setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness___setstate */
  {__pyx_k_DynApproxBetweenness_getNumberOf, sizeof(__pyx_k_DynApproxBetweenness_getNumberOf), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness_getNumberOf */
  {__pyx_k_DynApproxBetweenness_ranking, sizeof(__pyx_k_DynApproxBetweenness_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness_ranking */
  {__pyx_k_DynApproxBetweenness_score, sizeof(__pyx_k_DynApproxBetweenness_score), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness_score */
  {__pyx_k_DynApproxBetweenness_scores, sizeof(__pyx_k_DynApproxBetweenness_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynApproxBetweenness_scores */
  {__pyx_k_DynBetweenness, sizeof(__pyx_k_DynBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness */
  {__pyx_k_DynBetweennessOneNode, sizeof(__pyx_k_DynBetweennessOneNode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode */
  {__pyx_k_DynBetweennessOneNode___reduce_c, sizeof(__pyx_k_DynBetweennessOneNode___reduce_c), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode___reduce_c */
  {__pyx_k_DynBetweennessOneNode___setstate, sizeof(__pyx_k_DynBetweennessOneNode___setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode___setstate */
  {__pyx_k_DynBetweennessOneNode_getDistanc, sizeof(__pyx_k_DynBetweennessOneNode_getDistanc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode_getDistanc */
  {__pyx_k_DynBetweennessOneNode_getSigma, sizeof(__pyx_k_DynBetweennessOneNode_getSigma), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode_getSigma */
  {__pyx_k_DynBetweennessOneNode_getSigmax, sizeof(__pyx_k_DynBetweennessOneNode_getSigmax), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode_getSigmax */
  {__pyx_k_DynBetweennessOneNode_getbcx, sizeof(__pyx_k_DynBetweennessOneNode_getbcx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweennessOneNode_getbcx */
  {__pyx_k_DynBetweenness___reduce_cython, sizeof(__pyx_k_DynBetweenness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness___reduce_cython */
  {__pyx_k_DynBetweenness___setstate_cython, sizeof(__pyx_k_DynBetweenness___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness___setstate_cython */
  {__pyx_k_DynBetweenness_ranking, sizeof(__pyx_k_DynBetweenness_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness_ranking */
  {__pyx_k_DynBetweenness_score, sizeof(__pyx_k_DynBetweenness_score), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness_score */
  {__pyx_k_DynBetweenness_scores, sizeof(__pyx_k_DynBetweenness_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynBetweenness_scores */
  {__pyx_k_DynKatzCentrality, sizeof(__pyx_k_DynKatzCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality */
  {__pyx_k_DynKatzCentrality___reduce_cytho, sizeof(__pyx_k_DynKatzCentrality___reduce_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality___reduce_cytho */
  {__pyx_k_DynKatzCentrality___setstate_cyt, sizeof(__pyx_k_DynKatzCentrality___setstate_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality___setstate_cyt */
  {__pyx_k_DynKatzCentrality_areDistinguish, sizeof(__pyx_k_DynKatzCentrality_areDistinguish), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality_areDistinguish */
  {__pyx_k_DynKatzCentrality_bound, sizeof(__pyx_k_DynKatzCentrality_bound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality_bound */
  {__pyx_k_DynKatzCentrality_top, sizeof(__pyx_k_DynKatzCentrality_top), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynKatzCentrality_top */
  {__pyx_k_DynTopHarmonicCloseness, sizeof(__pyx_k_DynTopHarmonicCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness */
  {__pyx_k_DynTopHarmonicCloseness___reduce, sizeof(__pyx_k_DynTopHarmonicCloseness___reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness___reduce */
  {__pyx_k_DynTopHarmonicCloseness___setsta, sizeof(__pyx_k_DynTopHarmonicCloseness___setsta), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness___setsta */
  {__pyx_k_DynTopHarmonicCloseness_ranking, sizeof(__pyx_k_DynTopHarmonicCloseness_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness_ranking */
  {__pyx_k_DynTopHarmonicCloseness_topkNode, sizeof(__pyx_k_DynTopHarmonicCloseness_topkNode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness_topkNode */
  {__pyx_k_DynTopHarmonicCloseness_topkScor, sizeof(__pyx_k_DynTopHarmonicCloseness_topkScor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DynTopHarmonicCloseness_topkScor */
  {__pyx_k_EdgeDirection, sizeof(__pyx_k_EdgeDirection), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EdgeDirection */
  {__pyx_k_EigenvectorCentrality, sizeof(__pyx_k_EigenvectorCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EigenvectorCentrality */
  {__pyx_k_EigenvectorCentrality___reduce_c, sizeof(__pyx_k_EigenvectorCentrality___reduce_c), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EigenvectorCentrality___reduce_c */
  {__pyx_k_EigenvectorCentrality___setstate, sizeof(__pyx_k_EigenvectorCentrality___setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EigenvectorCentrality___setstate */
  {__pyx_k_Error_group_must_be_a_list_of_no, sizeof(__pyx_k_Error_group_must_be_a_list_of_no), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Error_group_must_be_a_list_of_no */
  {__pyx_k_Error_object_not_properly_initia, sizeof(__pyx_k_Error_object_not_properly_initia), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Error_object_not_properly_initia */
  {__pyx_k_Error_the_third_parameter_must_b, sizeof(__pyx_k_Error_the_third_parameter_must_b), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Error_the_third_parameter_must_b */
  {__pyx_k_Error_you_may_not_use_Centrality, sizeof(__pyx_k_Error_you_may_not_use_Centrality), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Error_you_may_not_use_Centrality */
  {__pyx_k_EstimateBetweenness, sizeof(__pyx_k_EstimateBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EstimateBetweenness */
  {__pyx_k_EstimateBetweenness___reduce_cyt, sizeof(__pyx_k_EstimateBetweenness___reduce_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EstimateBetweenness___reduce_cyt */
  {__pyx_k_EstimateBetweenness___setstate_c, sizeof(__pyx_k_EstimateBetweenness___setstate_c), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EstimateBetweenness___setstate_c */
  {__pyx_k_ForestCentrality, sizeof(__pyx_k_ForestCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ForestCentrality */
  {__pyx_k_ForestCentrality___reduce_cython, sizeof(__pyx_k_ForestCentrality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ForestCentrality___reduce_cython */
  {__pyx_k_ForestCentrality___setstate_cyth, sizeof(__pyx_k_ForestCentrality___setstate_cyth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ForestCentrality___setstate_cyth */
  {__pyx_k_ForestCentrality_getDiagonal, sizeof(__pyx_k_ForestCentrality_getDiagonal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ForestCentrality_getDiagonal */
  {__pyx_k_G, sizeof(__pyx_k_G), 0, 1, 1}, /* PyObject cname: __pyx_n_u_G */
  {__pyx_k_GENERALIZED, sizeof(__pyx_k_GENERALIZED), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GENERALIZED */
  {__pyx_k_GEOMETRIC, sizeof(__pyx_k_GEOMETRIC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GEOMETRIC */
  {__pyx_k_GedWalk, sizeof(__pyx_k_GedWalk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk */
  {__pyx_k_GedWalk___reduce_cython, sizeof(__pyx_k_GedWalk___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk___reduce_cython */
  {__pyx_k_GedWalk___setstate_cython, sizeof(__pyx_k_GedWalk___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk___setstate_cython */
  {__pyx_k_GedWalk_getApproximateScore, sizeof(__pyx_k_GedWalk_getApproximateScore), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk_getApproximateScore */
  {__pyx_k_GedWalk_groupMaxGedWalk, sizeof(__pyx_k_GedWalk_groupMaxGedWalk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk_groupMaxGedWalk */
  {__pyx_k_GedWalk_scoreOfGroup, sizeof(__pyx_k_GedWalk_scoreOfGroup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GedWalk_scoreOfGroup */
  {__pyx_k_Generalized, sizeof(__pyx_k_Generalized), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Generalized */
  {__pyx_k_Geometric, sizeof(__pyx_k_Geometric), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Geometric */
  {__pyx_k_GreedyStrategy, sizeof(__pyx_k_GreedyStrategy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GreedyStrategy */
  {__pyx_k_GroupCloseness, sizeof(__pyx_k_GroupCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness */
  {__pyx_k_GroupClosenessGrowShrink, sizeof(__pyx_k_GroupClosenessGrowShrink), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessGrowShrink */
  {__pyx_k_GroupClosenessGrowShrink___reduc, sizeof(__pyx_k_GroupClosenessGrowShrink___reduc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessGrowShrink___reduc */
  {__pyx_k_GroupClosenessGrowShrink___setst, sizeof(__pyx_k_GroupClosenessGrowShrink___setst), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessGrowShrink___setst */
  {__pyx_k_GroupClosenessGrowShrink_groupMa, sizeof(__pyx_k_GroupClosenessGrowShrink_groupMa), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessGrowShrink_groupMa */
  {__pyx_k_GroupClosenessGrowShrink_numberO, sizeof(__pyx_k_GroupClosenessGrowShrink_numberO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessGrowShrink_numberO */
  {__pyx_k_GroupClosenessLocalSearch, sizeof(__pyx_k_GroupClosenessLocalSearch), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSearch */
  {__pyx_k_GroupClosenessLocalSearch___redu, sizeof(__pyx_k_GroupClosenessLocalSearch___redu), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSearch___redu */
  {__pyx_k_GroupClosenessLocalSearch___sets, sizeof(__pyx_k_GroupClosenessLocalSearch___sets), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSearch___sets */
  {__pyx_k_GroupClosenessLocalSearch_groupM, sizeof(__pyx_k_GroupClosenessLocalSearch_groupM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSearch_groupM */
  {__pyx_k_GroupClosenessLocalSearch_number, sizeof(__pyx_k_GroupClosenessLocalSearch_number), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSearch_number */
  {__pyx_k_GroupClosenessLocalSwaps, sizeof(__pyx_k_GroupClosenessLocalSwaps), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSwaps */
  {__pyx_k_GroupClosenessLocalSwaps___reduc, sizeof(__pyx_k_GroupClosenessLocalSwaps___reduc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSwaps___reduc */
  {__pyx_k_GroupClosenessLocalSwaps___setst, sizeof(__pyx_k_GroupClosenessLocalSwaps___setst), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSwaps___setst */
  {__pyx_k_GroupClosenessLocalSwaps_groupMa, sizeof(__pyx_k_GroupClosenessLocalSwaps_groupMa), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSwaps_groupMa */
  {__pyx_k_GroupClosenessLocalSwaps_numberO, sizeof(__pyx_k_GroupClosenessLocalSwaps_numberO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupClosenessLocalSwaps_numberO */
  {__pyx_k_GroupCloseness___reduce_cython, sizeof(__pyx_k_GroupCloseness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness___reduce_cython */
  {__pyx_k_GroupCloseness___setstate_cython, sizeof(__pyx_k_GroupCloseness___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness___setstate_cython */
  {__pyx_k_GroupCloseness_computeFarness, sizeof(__pyx_k_GroupCloseness_computeFarness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness_computeFarness */
  {__pyx_k_GroupCloseness_groupMaxCloseness, sizeof(__pyx_k_GroupCloseness_groupMaxCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness_groupMaxCloseness */
  {__pyx_k_GroupCloseness_scoreOfGroup, sizeof(__pyx_k_GroupCloseness_scoreOfGroup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupCloseness_scoreOfGroup */
  {__pyx_k_GroupDegree, sizeof(__pyx_k_GroupDegree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree */
  {__pyx_k_GroupDegree___reduce_cython, sizeof(__pyx_k_GroupDegree___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree___reduce_cython */
  {__pyx_k_GroupDegree___setstate_cython, sizeof(__pyx_k_GroupDegree___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree___setstate_cython */
  {__pyx_k_GroupDegree_getScore, sizeof(__pyx_k_GroupDegree_getScore), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree_getScore */
  {__pyx_k_GroupDegree_groupMaxDegree, sizeof(__pyx_k_GroupDegree_groupMaxDegree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree_groupMaxDegree */
  {__pyx_k_GroupDegree_scoreOfGroup, sizeof(__pyx_k_GroupDegree_scoreOfGroup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupDegree_scoreOfGroup */
  {__pyx_k_GroupHarmonicCloseness, sizeof(__pyx_k_GroupHarmonicCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupHarmonicCloseness */
  {__pyx_k_GroupHarmonicCloseness___reduce, sizeof(__pyx_k_GroupHarmonicCloseness___reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupHarmonicCloseness___reduce */
  {__pyx_k_GroupHarmonicCloseness___setstat, sizeof(__pyx_k_GroupHarmonicCloseness___setstat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupHarmonicCloseness___setstat */
  {__pyx_k_GroupHarmonicCloseness_groupMaxH, sizeof(__pyx_k_GroupHarmonicCloseness_groupMaxH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupHarmonicCloseness_groupMaxH */
  {__pyx_k_GroupHarmonicCloseness_scoreOfGr, sizeof(__pyx_k_GroupHarmonicCloseness_scoreOfGr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_GroupHarmonicCloseness_scoreOfGr */
  {__pyx_k_H, sizeof(__pyx_k_H), 0, 1, 1}, /* PyObject cname: __pyx_n_u_H */
  {__pyx_k_HarmonicCloseness, sizeof(__pyx_k_HarmonicCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HarmonicCloseness */
  {__pyx_k_HarmonicCloseness___reduce_cytho, sizeof(__pyx_k_HarmonicCloseness___reduce_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HarmonicCloseness___reduce_cytho */
  {__pyx_k_HarmonicCloseness___setstate_cyt, sizeof(__pyx_k_HarmonicCloseness___setstate_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HarmonicCloseness___setstate_cyt */
  {__pyx_k_INBOUND, sizeof(__pyx_k_INBOUND), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INBOUND */
  {__pyx_k_IN_EDGES, sizeof(__pyx_k_IN_EDGES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IN_EDGES */
  {__pyx_k_Inbound, sizeof(__pyx_k_Inbound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Inbound */
  {__pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Incompatible_checksums_0x_x_vs_0 */
  {__pyx_k_IntEnum, sizeof(__pyx_k_IntEnum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IntEnum */
  {__pyx_k_IntFlag, sizeof(__pyx_k_IntFlag), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IntFlag */
  {__pyx_k_KPathCentrality, sizeof(__pyx_k_KPathCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KPathCentrality */
  {__pyx_k_KPathCentrality___reduce_cython, sizeof(__pyx_k_KPathCentrality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KPathCentrality___reduce_cython */
  {__pyx_k_KPathCentrality___setstate_cytho, sizeof(__pyx_k_KPathCentrality___setstate_cytho), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KPathCentrality___setstate_cytho */
  {__pyx_k_KadabraBetweenness, sizeof(__pyx_k_KadabraBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness */
  {__pyx_k_KadabraBetweenness___reduce_cyth, sizeof(__pyx_k_KadabraBetweenness___reduce_cyth), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness___reduce_cyth */
  {__pyx_k_KadabraBetweenness___setstate_cy, sizeof(__pyx_k_KadabraBetweenness___setstate_cy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness___setstate_cy */
  {__pyx_k_KadabraBetweenness_getNumberOfIt, sizeof(__pyx_k_KadabraBetweenness_getNumberOfIt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_getNumberOfIt */
  {__pyx_k_KadabraBetweenness_getOmega, sizeof(__pyx_k_KadabraBetweenness_getOmega), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_getOmega */
  {__pyx_k_KadabraBetweenness_ranking, sizeof(__pyx_k_KadabraBetweenness_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_ranking */
  {__pyx_k_KadabraBetweenness_scores, sizeof(__pyx_k_KadabraBetweenness_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_scores */
  {__pyx_k_KadabraBetweenness_topkNodesList, sizeof(__pyx_k_KadabraBetweenness_topkNodesList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_topkNodesList */
  {__pyx_k_KadabraBetweenness_topkScoresLis, sizeof(__pyx_k_KadabraBetweenness_topkScoresLis), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KadabraBetweenness_topkScoresLis */
  {__pyx_k_KatzCentrality, sizeof(__pyx_k_KatzCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KatzCentrality */
  {__pyx_k_KatzCentrality___reduce_cython, sizeof(__pyx_k_KatzCentrality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KatzCentrality___reduce_cython */
  {__pyx_k_KatzCentrality___setstate_cython, sizeof(__pyx_k_KatzCentrality___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KatzCentrality___setstate_cython */
  {__pyx_k_L1_NORM, sizeof(__pyx_k_L1_NORM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_L1_NORM */
  {__pyx_k_L2_NORM, sizeof(__pyx_k_L2_NORM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_L2_NORM */
  {__pyx_k_LAZY, sizeof(__pyx_k_LAZY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LAZY */
  {__pyx_k_LaplacianCentrality, sizeof(__pyx_k_LaplacianCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LaplacianCentrality */
  {__pyx_k_LaplacianCentrality___reduce_cyt, sizeof(__pyx_k_LaplacianCentrality___reduce_cyt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LaplacianCentrality___reduce_cyt */
  {__pyx_k_LaplacianCentrality___setstate_c, sizeof(__pyx_k_LaplacianCentrality___setstate_c), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LaplacianCentrality___setstate_c */
  {__pyx_k_Lazy, sizeof(__pyx_k_Lazy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Lazy */
  {__pyx_k_LocalClusteringCoefficient, sizeof(__pyx_k_LocalClusteringCoefficient), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalClusteringCoefficient */
  {__pyx_k_LocalClusteringCoefficient___red, sizeof(__pyx_k_LocalClusteringCoefficient___red), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalClusteringCoefficient___red */
  {__pyx_k_LocalClusteringCoefficient___set, sizeof(__pyx_k_LocalClusteringCoefficient___set), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalClusteringCoefficient___set */
  {__pyx_k_LocalPartitionCoverage, sizeof(__pyx_k_LocalPartitionCoverage), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalPartitionCoverage */
  {__pyx_k_LocalPartitionCoverage___reduce, sizeof(__pyx_k_LocalPartitionCoverage___reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalPartitionCoverage___reduce */
  {__pyx_k_LocalPartitionCoverage___setstat, sizeof(__pyx_k_LocalPartitionCoverage___setstat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalPartitionCoverage___setstat */
  {__pyx_k_LocalSquareClusteringCoefficient, sizeof(__pyx_k_LocalSquareClusteringCoefficient), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalSquareClusteringCoefficient */
  {__pyx_k_LocalSquareClusteringCoefficient_2, sizeof(__pyx_k_LocalSquareClusteringCoefficient_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalSquareClusteringCoefficient_2 */
  {__pyx_k_LocalSquareClusteringCoefficient_3, sizeof(__pyx_k_LocalSquareClusteringCoefficient_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LocalSquareClusteringCoefficient_3 */
  {__pyx_k_Max_iterations_cannot_be_a_negat, sizeof(__pyx_k_Max_iterations_cannot_be_a_negat), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Max_iterations_cannot_be_a_negat */
  {__pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MemoryError */
  {__pyx_k_NO, sizeof(__pyx_k_NO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NO */
  {__pyx_k_NO_SINK_HANDLING, sizeof(__pyx_k_NO_SINK_HANDLING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NO_SINK_HANDLING */
  {__pyx_k_No, sizeof(__pyx_k_No), 0, 1, 1}, /* PyObject cname: __pyx_n_u_No */
  {__pyx_k_NoSinkHandling, sizeof(__pyx_k_NoSinkHandling), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NoSinkHandling */
  {__pyx_k_Norm, sizeof(__pyx_k_Norm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Norm */
  {__pyx_k_NotImplemented, sizeof(__pyx_k_NotImplemented), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NotImplemented */
  {__pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NotImplementedError */
  {__pyx_k_Not_implemented_for_directed_gra, sizeof(__pyx_k_Not_implemented_for_directed_gra), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_implemented_for_directed_gra */
  {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */
  {__pyx_k_OUTBOUND, sizeof(__pyx_k_OUTBOUND), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OUTBOUND */
  {__pyx_k_OUT_EDGES, sizeof(__pyx_k_OUT_EDGES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OUT_EDGES */
  {__pyx_k_Outbound, sizeof(__pyx_k_Outbound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Outbound */
  {__pyx_k_P, sizeof(__pyx_k_P), 0, 1, 1}, /* PyObject cname: __pyx_n_u_P */
  {__pyx_k_PageRank, sizeof(__pyx_k_PageRank), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PageRank */
  {__pyx_k_PageRankMatrix, sizeof(__pyx_k_PageRankMatrix), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PageRankMatrix */
  {__pyx_k_PageRank___reduce_cython, sizeof(__pyx_k_PageRank___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PageRank___reduce_cython */
  {__pyx_k_PageRank___setstate_cython, sizeof(__pyx_k_PageRank___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PageRank___setstate_cython */
  {__pyx_k_PageRank_numberOfIterations, sizeof(__pyx_k_PageRank_numberOfIterations), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PageRank_numberOfIterations */
  {__pyx_k_PermanenceCentrality, sizeof(__pyx_k_PermanenceCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PermanenceCentrality */
  {__pyx_k_PermanenceCentrality___reduce_cy, sizeof(__pyx_k_PermanenceCentrality___reduce_cy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PermanenceCentrality___reduce_cy */
  {__pyx_k_PermanenceCentrality___setstate, sizeof(__pyx_k_PermanenceCentrality___setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PermanenceCentrality___setstate */
  {__pyx_k_PermanenceCentrality_getIntraClu, sizeof(__pyx_k_PermanenceCentrality_getIntraClu), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PermanenceCentrality_getIntraClu */
  {__pyx_k_PermanenceCentrality_getPermanen, sizeof(__pyx_k_PermanenceCentrality_getPermanen), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PermanenceCentrality_getPermanen */
  {__pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PickleError */
  {__pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RuntimeError */
  {__pyx_k_S, sizeof(__pyx_k_S), 0, 1, 1}, /* PyObject cname: __pyx_n_u_S */
  {__pyx_k_SINGLE_NODE, sizeof(__pyx_k_SINGLE_NODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SINGLE_NODE */
  {__pyx_k_SPECTRAL, sizeof(__pyx_k_SPECTRAL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SPECTRAL */
  {__pyx_k_STANDARD, sizeof(__pyx_k_STANDARD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STANDARD */
  {__pyx_k_STOCHASTIC, sizeof(__pyx_k_STOCHASTIC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCHASTIC */
  {__pyx_k_SUM, sizeof(__pyx_k_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SUM */
  {__pyx_k_SciPyEVZ, sizeof(__pyx_k_SciPyEVZ), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyEVZ */
  {__pyx_k_SciPyEVZ_G_normalized_False_Com, sizeof(__pyx_k_SciPyEVZ_G_normalized_False_Com), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_SciPyEVZ_G_normalized_False_Com */
  {__pyx_k_SciPyEVZ___init, sizeof(__pyx_k_SciPyEVZ___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyEVZ___init */
  {__pyx_k_SciPyEVZ__length, sizeof(__pyx_k_SciPyEVZ__length), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyEVZ__length */
  {__pyx_k_SciPyEVZ_normFactor, sizeof(__pyx_k_SciPyEVZ_normFactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyEVZ_normFactor */
  {__pyx_k_SciPyEVZ_prepareSpectrum, sizeof(__pyx_k_SciPyEVZ_prepareSpectrum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyEVZ_prepareSpectrum */
  {__pyx_k_SciPyPageRank, sizeof(__pyx_k_SciPyPageRank), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyPageRank */
  {__pyx_k_SciPyPageRank_G_damp_0_95_norma, sizeof(__pyx_k_SciPyPageRank_G_damp_0_95_norma), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_SciPyPageRank_G_damp_0_95_norma */
  {__pyx_k_SciPyPageRank___init, sizeof(__pyx_k_SciPyPageRank___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyPageRank___init */
  {__pyx_k_SciPyPageRank__length, sizeof(__pyx_k_SciPyPageRank__length), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyPageRank__length */
  {__pyx_k_SciPyPageRank_normFactor, sizeof(__pyx_k_SciPyPageRank_normFactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyPageRank_normFactor */
  {__pyx_k_SciPyPageRank_prepareSpectrum, sizeof(__pyx_k_SciPyPageRank_prepareSpectrum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SciPyPageRank_prepareSpectrum */
  {__pyx_k_Sfigality, sizeof(__pyx_k_Sfigality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Sfigality */
  {__pyx_k_Sfigality___reduce_cython, sizeof(__pyx_k_Sfigality___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Sfigality___reduce_cython */
  {__pyx_k_Sfigality___setstate_cython, sizeof(__pyx_k_Sfigality___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Sfigality___setstate_cython */
  {__pyx_k_SinkHandling, sizeof(__pyx_k_SinkHandling), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SinkHandling */
  {__pyx_k_SpanningEdgeCentrality, sizeof(__pyx_k_SpanningEdgeCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality */
  {__pyx_k_SpanningEdgeCentrality___reduce, sizeof(__pyx_k_SpanningEdgeCentrality___reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality___reduce */
  {__pyx_k_SpanningEdgeCentrality___setstat, sizeof(__pyx_k_SpanningEdgeCentrality___setstat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality___setstat */
  {__pyx_k_SpanningEdgeCentrality_runApprox, sizeof(__pyx_k_SpanningEdgeCentrality_runApprox), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality_runApprox */
  {__pyx_k_SpanningEdgeCentrality_runParall, sizeof(__pyx_k_SpanningEdgeCentrality_runParall), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality_runParall */
  {__pyx_k_SpanningEdgeCentrality_scores, sizeof(__pyx_k_SpanningEdgeCentrality_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpanningEdgeCentrality_scores */
  {__pyx_k_Spectral, sizeof(__pyx_k_Spectral), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Spectral */
  {__pyx_k_SpectralCentrality, sizeof(__pyx_k_SpectralCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality */
  {__pyx_k_SpectralCentrality_G_normalized, sizeof(__pyx_k_SpectralCentrality_G_normalized), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_SpectralCentrality_G_normalized */
  {__pyx_k_SpectralCentrality___init, sizeof(__pyx_k_SpectralCentrality___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality___init */
  {__pyx_k_SpectralCentrality_normFactor, sizeof(__pyx_k_SpectralCentrality_normFactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_normFactor */
  {__pyx_k_SpectralCentrality_prepareSpectr, sizeof(__pyx_k_SpectralCentrality_prepareSpectr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_prepareSpectr */
  {__pyx_k_SpectralCentrality_ranking, sizeof(__pyx_k_SpectralCentrality_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_ranking */
  {__pyx_k_SpectralCentrality_ranking_local, sizeof(__pyx_k_SpectralCentrality_ranking_local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_ranking_local */
  {__pyx_k_SpectralCentrality_run, sizeof(__pyx_k_SpectralCentrality_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_run */
  {__pyx_k_SpectralCentrality_scores, sizeof(__pyx_k_SpectralCentrality_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SpectralCentrality_scores */
  {__pyx_k_Standard, sizeof(__pyx_k_Standard), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Standard */
  {__pyx_k_Stochastic, sizeof(__pyx_k_Stochastic), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Stochastic */
  {__pyx_k_Sum, sizeof(__pyx_k_Sum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Sum */
  {__pyx_k_TopCloseness, sizeof(__pyx_k_TopCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness */
  {__pyx_k_TopCloseness___reduce_cython, sizeof(__pyx_k_TopCloseness___reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness___reduce_cython */
  {__pyx_k_TopCloseness___setstate_cython, sizeof(__pyx_k_TopCloseness___setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness___setstate_cython */
  {__pyx_k_TopCloseness_restrictTopKComputa, sizeof(__pyx_k_TopCloseness_restrictTopKComputa), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness_restrictTopKComputa */
  {__pyx_k_TopCloseness_topkNodesList, sizeof(__pyx_k_TopCloseness_topkNodesList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness_topkNodesList */
  {__pyx_k_TopCloseness_topkScoresList, sizeof(__pyx_k_TopCloseness_topkScoresList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopCloseness_topkScoresList */
  {__pyx_k_TopHarmonicCloseness, sizeof(__pyx_k_TopHarmonicCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness */
  {__pyx_k_TopHarmonicCloseness___reduce_cy, sizeof(__pyx_k_TopHarmonicCloseness___reduce_cy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness___reduce_cy */
  {__pyx_k_TopHarmonicCloseness___setstate, sizeof(__pyx_k_TopHarmonicCloseness___setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness___setstate */
  {__pyx_k_TopHarmonicCloseness_restrictTop, sizeof(__pyx_k_TopHarmonicCloseness_restrictTop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness_restrictTop */
  {__pyx_k_TopHarmonicCloseness_topkNodesLi, sizeof(__pyx_k_TopHarmonicCloseness_topkNodesLi), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness_topkNodesLi */
  {__pyx_k_TopHarmonicCloseness_topkScoresL, sizeof(__pyx_k_TopHarmonicCloseness_topkScoresL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TopHarmonicCloseness_topkScoresL */
  {__pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TypeError */
  {__pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__6 */
  {__pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__7 */
  {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */
  {__pyx_k_adjacencyEigenvector, sizeof(__pyx_k_adjacencyEigenvector), 0, 1, 1}, /* PyObject cname: __pyx_n_u_adjacencyEigenvector */
  {__pyx_k_algorithm, sizeof(__pyx_k_algorithm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_algorithm */
  {__pyx_k_allNodes, sizeof(__pyx_k_allNodes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_allNodes */
  {__pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 1, 1}, /* PyObject cname: __pyx_n_u_alpha */
  {__pyx_k_areDistinguished, sizeof(__pyx_k_areDistinguished), 0, 1, 1}, /* PyObject cname: __pyx_n_u_areDistinguished */
  {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */
  {__pyx_k_beta, sizeof(__pyx_k_beta), 0, 1, 1}, /* PyObject cname: __pyx_n_u_beta */
  {__pyx_k_bound, sizeof(__pyx_k_bound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_bound */
  {__pyx_k_bs, sizeof(__pyx_k_bs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_bs */
  {__pyx_k_centrality, sizeof(__pyx_k_centrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_centrality */
  {__pyx_k_centralization, sizeof(__pyx_k_centralization), 0, 1, 1}, /* PyObject cname: __pyx_n_u_centralization */
  {__pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_class_getitem */
  {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */
  {__pyx_k_computeEdgeCentrality, sizeof(__pyx_k_computeEdgeCentrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_computeEdgeCentrality */
  {__pyx_k_computeExactDiagonal, sizeof(__pyx_k_computeExactDiagonal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_computeExactDiagonal */
  {__pyx_k_computeFarness, sizeof(__pyx_k_computeFarness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_computeFarness */
  {__pyx_k_countGroupNodes, sizeof(__pyx_k_countGroupNodes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_countGroupNodes */
  {__pyx_k_cutoff, sizeof(__pyx_k_cutoff), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cutoff */
  {__pyx_k_damp, sizeof(__pyx_k_damp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_damp */
  {__pyx_k_delta, sizeof(__pyx_k_delta), 0, 1, 1}, /* PyObject cname: __pyx_n_u_delta */
  {__pyx_k_deterministic, sizeof(__pyx_k_deterministic), 0, 1, 1}, /* PyObject cname: __pyx_n_u_deterministic */
  {__pyx_k_dict, sizeof(__pyx_k_dict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dict */
  {__pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dict_2 */
  {__pyx_k_diff, sizeof(__pyx_k_diff), 0, 1, 1}, /* PyObject cname: __pyx_n_u_diff */
  {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */
  {__pyx_k_distributeSinks, sizeof(__pyx_k_distributeSinks), 0, 1, 1}, /* PyObject cname: __pyx_n_u_distributeSinks */
  {__pyx_k_doc, sizeof(__pyx_k_doc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_doc */
  {__pyx_k_dynbase, sizeof(__pyx_k_dynbase), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dynbase */
  {__pyx_k_edgeScores, sizeof(__pyx_k_edgeScores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_edgeScores */
  {__pyx_k_eigenvalue, sizeof(__pyx_k_eigenvalue), 0, 1, 1}, /* PyObject cname: __pyx_n_u_eigenvalue */
  {__pyx_k_eigenvector, sizeof(__pyx_k_eigenvector), 0, 1, 1}, /* PyObject cname: __pyx_n_u_eigenvector */
  {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */
  {__pyx_k_enforceBucketQueueAlgorithm, sizeof(__pyx_k_enforceBucketQueueAlgorithm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enforceBucketQueueAlgorithm */
  {__pyx_k_enum, sizeof(__pyx_k_enum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enum */
  {__pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enumerate */
  {__pyx_k_eps, sizeof(__pyx_k_eps), 0, 1, 1}, /* PyObject cname: __pyx_n_u_eps */
  {__pyx_k_epsilon, sizeof(__pyx_k_epsilon), 0, 1, 1}, /* PyObject cname: __pyx_n_u_epsilon */
  {__pyx_k_err, sizeof(__pyx_k_err), 0, 1, 1}, /* PyObject cname: __pyx_n_u_err */
  {__pyx_k_evz, sizeof(__pyx_k_evz), 0, 1, 1}, /* PyObject cname: __pyx_n_u_evz */
  {__pyx_k_extended, sizeof(__pyx_k_extended), 0, 1, 1}, /* PyObject cname: __pyx_n_u_extended */
  {__pyx_k_first_heu, sizeof(__pyx_k_first_heu), 0, 1, 1}, /* PyObject cname: __pyx_n_u_first_heu */
  {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */
  {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */
  {__pyx_k_get, sizeof(__pyx_k_get), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get */
  {__pyx_k_getAdopters, sizeof(__pyx_k_getAdopters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getAdopters */
  {__pyx_k_getApproximateScore, sizeof(__pyx_k_getApproximateScore), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getApproximateScore */
  {__pyx_k_getComplexGraph, sizeof(__pyx_k_getComplexGraph), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getComplexGraph */
  {__pyx_k_getCover, sizeof(__pyx_k_getCover), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getCover */
  {__pyx_k_getDiagonal, sizeof(__pyx_k_getDiagonal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getDiagonal */
  {__pyx_k_getDistance, sizeof(__pyx_k_getDistance), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getDistance */
  {__pyx_k_getIntraClustering, sizeof(__pyx_k_getIntraClustering), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getIntraClustering */
  {__pyx_k_getNodeOrder, sizeof(__pyx_k_getNodeOrder), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getNodeOrder */
  {__pyx_k_getNumberOfIterations, sizeof(__pyx_k_getNumberOfIterations), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getNumberOfIterations */
  {__pyx_k_getNumberOfSamples, sizeof(__pyx_k_getNumberOfSamples), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getNumberOfSamples */
  {__pyx_k_getOmega, sizeof(__pyx_k_getOmega), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getOmega */
  {__pyx_k_getPLci, sizeof(__pyx_k_getPLci), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getPLci */
  {__pyx_k_getPartition, sizeof(__pyx_k_getPartition), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getPartition */
  {__pyx_k_getPermanence, sizeof(__pyx_k_getPermanence), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getPermanence */
  {__pyx_k_getScore, sizeof(__pyx_k_getScore), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getScore */
  {__pyx_k_getSigma, sizeof(__pyx_k_getSigma), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getSigma */
  {__pyx_k_getSigmax, sizeof(__pyx_k_getSigmax), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getSigmax */
  {__pyx_k_getSquareErrorEstimates, sizeof(__pyx_k_getSquareErrorEstimates), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getSquareErrorEstimates */
  {__pyx_k_getbcx, sizeof(__pyx_k_getbcx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getbcx */
  {__pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getstate */
  {__pyx_k_graph, sizeof(__pyx_k_graph), 0, 1, 1}, /* PyObject cname: __pyx_n_u_graph */
  {__pyx_k_group, sizeof(__pyx_k_group), 0, 1, 1}, /* PyObject cname: __pyx_n_u_group */
  {__pyx_k_groupMaxBetweenness, sizeof(__pyx_k_groupMaxBetweenness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupMaxBetweenness */
  {__pyx_k_groupMaxCloseness, sizeof(__pyx_k_groupMaxCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupMaxCloseness */
  {__pyx_k_groupMaxDegree, sizeof(__pyx_k_groupMaxDegree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupMaxDegree */
  {__pyx_k_groupMaxGedWalk, sizeof(__pyx_k_groupMaxGedWalk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupMaxGedWalk */
  {__pyx_k_groupMaxHarmonicCloseness, sizeof(__pyx_k_groupMaxHarmonicCloseness), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupMaxHarmonicCloseness */
  {__pyx_k_groupOnly, sizeof(__pyx_k_groupOnly), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupOnly */
  {__pyx_k_groupSize, sizeof(__pyx_k_groupSize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupSize */
  {__pyx_k_groupVec, sizeof(__pyx_k_groupVec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groupVec */
  {__pyx_k_gs, sizeof(__pyx_k_gs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gs */
  {__pyx_k_i, sizeof(__pyx_k_i), 0, 1, 1}, /* PyObject cname: __pyx_n_u_i */
  {__pyx_k_ignoreSelfLoops, sizeof(__pyx_k_ignoreSelfLoops), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ignoreSelfLoops */
  {__pyx_k_inEdges, sizeof(__pyx_k_inEdges), 0, 1, 1}, /* PyObject cname: __pyx_n_u_inEdges */
  {__pyx_k_includeTrail, sizeof(__pyx_k_includeTrail), 0, 1, 1}, /* PyObject cname: __pyx_n_u_includeTrail */
  {__pyx_k_index, sizeof(__pyx_k_index), 0, 1, 1}, /* PyObject cname: __pyx_n_u_index */
  {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */
  {__pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_initializing */
  {__pyx_k_inputGroup, sizeof(__pyx_k_inputGroup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_inputGroup */
  {__pyx_k_insertions, sizeof(__pyx_k_insertions), 0, 1, 1}, /* PyObject cname: __pyx_n_u_insertions */
  {__pyx_k_isDirected, sizeof(__pyx_k_isDirected), 0, 1, 1}, /* PyObject cname: __pyx_n_u_isDirected */
  {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */
  {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */
  {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */
  {__pyx_k_iterNodes, sizeof(__pyx_k_iterNodes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_iterNodes */
  {__pyx_k_k, sizeof(__pyx_k_k), 0, 1, 1}, /* PyObject cname: __pyx_n_u_k */
  {__pyx_k_kappa, sizeof(__pyx_k_kappa), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kappa */
  {__pyx_k_key, sizeof(__pyx_k_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_key */
  {__pyx_k_l1norm, sizeof(__pyx_k_l1norm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_l1norm */
  {__pyx_k_l2norm, sizeof(__pyx_k_l2norm), 0, 1, 1}, /* PyObject cname: __pyx_n_u_l2norm */
  {__pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lambda */
  {__pyx_k_length, sizeof(__pyx_k_length), 0, 1, 1}, /* PyObject cname: __pyx_n_u_length */
  {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */
  {__pyx_k_math, sizeof(__pyx_k_math), 0, 1, 1}, /* PyObject cname: __pyx_n_u_math */
  {__pyx_k_maxCoreNumber, sizeof(__pyx_k_maxCoreNumber), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxCoreNumber */
  {__pyx_k_maxIterations, sizeof(__pyx_k_maxIterations), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxIterations */
  {__pyx_k_maxSwaps, sizeof(__pyx_k_maxSwaps), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxSwaps */
  {__pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maximum */
  {__pyx_k_member_names, sizeof(__pyx_k_member_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_member_names */
  {__pyx_k_members, sizeof(__pyx_k_members), 0, 1, 1}, /* PyObject cname: __pyx_n_u_members */
  {__pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 1, 1}, /* PyObject cname: __pyx_n_u_metaclass */
  {__pyx_k_mode, sizeof(__pyx_k_mode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mode */
  {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */
  {__pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module_2 */
  {__pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mro_entries */
  {__pyx_k_n, sizeof(__pyx_k_n), 0, 1, 1}, /* PyObject cname: __pyx_n_u_n */
  {__pyx_k_nSamples, sizeof(__pyx_k_nSamples), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nSamples */
  {__pyx_k_n_nodes, sizeof(__pyx_k_n_nodes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_n_nodes */
  {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */
  {__pyx_k_networkit_algebraic, sizeof(__pyx_k_networkit_algebraic), 0, 1, 1}, /* PyObject cname: __pyx_n_u_networkit_algebraic */
  {__pyx_k_networkit_centrality, sizeof(__pyx_k_networkit_centrality), 0, 1, 1}, /* PyObject cname: __pyx_n_u_networkit_centrality */
  {__pyx_k_networkit_centrality, sizeof(__pyx_k_networkit_centrality), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_networkit_centrality */
  {__pyx_k_networkit_centrality_pyx, sizeof(__pyx_k_networkit_centrality_pyx), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_networkit_centrality_pyx */
  {__pyx_k_new, sizeof(__pyx_k_new), 0, 1, 1}, /* PyObject cname: __pyx_n_u_new */
  {__pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_no_default___reduce___due_to_non */
  {__pyx_k_node, sizeof(__pyx_k_node), 0, 1, 1}, /* PyObject cname: __pyx_n_u_node */
  {__pyx_k_nodeList, sizeof(__pyx_k_nodeList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nodeList */
  {__pyx_k_normFactor, sizeof(__pyx_k_normFactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_normFactor */
  {__pyx_k_normalize, sizeof(__pyx_k_normalize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_normalize */
  {__pyx_k_normalized, sizeof(__pyx_k_normalized), 0, 1, 1}, /* PyObject cname: __pyx_n_u_normalized */
  {__pyx_k_numberOfIterations, sizeof(__pyx_k_numberOfIterations), 0, 1, 1}, /* PyObject cname: __pyx_n_u_numberOfIterations */
  {__pyx_k_numberOfSamples, sizeof(__pyx_k_numberOfSamples), 0, 1, 1}, /* PyObject cname: __pyx_n_u_numberOfSamples */
  {__pyx_k_numberOfSwaps, sizeof(__pyx_k_numberOfSwaps), 0, 1, 1}, /* PyObject cname: __pyx_n_u_numberOfSwaps */
  {__pyx_k_object, sizeof(__pyx_k_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_object */
  {__pyx_k_outDeg, sizeof(__pyx_k_outDeg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outDeg */
  {__pyx_k_outEdges, sizeof(__pyx_k_outEdges), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outEdges */
  {__pyx_k_pair, sizeof(__pyx_k_pair), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pair */
  {__pyx_k_parallel, sizeof(__pyx_k_parallel), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parallel */
  {__pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pickle */
  {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */
  {__pyx_k_prMatrix, sizeof(__pyx_k_prMatrix), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prMatrix */
  {__pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prepare */
  {__pyx_k_prepareSpectrum, sizeof(__pyx_k_prepareSpectrum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prepareSpectrum */
  {__pyx_k_prev_node, sizeof(__pyx_k_prev_node), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prev_node */
  {__pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_PickleError */
  {__pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_checksum */
  {__pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_result */
  {__pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_state */
  {__pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_type */
  {__pyx_k_pyx_unpickle_ComplexPathMode, sizeof(__pyx_k_pyx_unpickle_ComplexPathMode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_unpickle_ComplexPathMode */
  {__pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pyx_vtable */
  {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */
  {__pyx_k_range, sizeof(__pyx_k_range), 0, 1, 1}, /* PyObject cname: __pyx_n_u_range */
  {__pyx_k_rankList, sizeof(__pyx_k_rankList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rankList */
  {__pyx_k_rankPerNode, sizeof(__pyx_k_rankPerNode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rankPerNode */
  {__pyx_k_ranking, sizeof(__pyx_k_ranking), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ranking */
  {__pyx_k_ranking_id, sizeof(__pyx_k_ranking_id), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ranking_id */
  {__pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce */
  {__pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_cython */
  {__pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reduce_ex */
  {__pyx_k_relativeRankErrors, sizeof(__pyx_k_relativeRankErrors), 0, 1, 1}, /* PyObject cname: __pyx_n_u_relativeRankErrors */
  {__pyx_k_restrictTopKComputationToNodes, sizeof(__pyx_k_restrictTopKComputationToNodes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_restrictTopKComputationToNodes */
  {__pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reverse */
  {__pyx_k_rnode_x, sizeof(__pyx_k_rnode_x), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rnode_x */
  {__pyx_k_rnode_y, sizeof(__pyx_k_rnode_y), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rnode_y */
  {__pyx_k_root, sizeof(__pyx_k_root), 0, 1, 1}, /* PyObject cname: __pyx_n_u_root */
  {__pyx_k_run, sizeof(__pyx_k_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_run */
  {__pyx_k_runApproximation, sizeof(__pyx_k_runApproximation), 0, 1, 1}, /* PyObject cname: __pyx_n_u_runApproximation */
  {__pyx_k_runGrowShrink, sizeof(__pyx_k_runGrowShrink), 0, 1, 1}, /* PyObject cname: __pyx_n_u_runGrowShrink */
  {__pyx_k_runParallelApproximation, sizeof(__pyx_k_runParallelApproximation), 0, 1, 1}, /* PyObject cname: __pyx_n_u_runParallelApproximation */
  {__pyx_k_rx, sizeof(__pyx_k_rx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rx */
  {__pyx_k_ry, sizeof(__pyx_k_ry), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ry */
  {__pyx_k_score, sizeof(__pyx_k_score), 0, 1, 1}, /* PyObject cname: __pyx_n_u_score */
  {__pyx_k_scoreList, sizeof(__pyx_k_scoreList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_scoreList */
  {__pyx_k_scoreOfGroup, sizeof(__pyx_k_scoreOfGroup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_scoreOfGroup */
  {__pyx_k_scores, sizeof(__pyx_k_scores), 0, 1, 1}, /* PyObject cname: __pyx_n_u_scores */
  {__pyx_k_sec_heu, sizeof(__pyx_k_sec_heu), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sec_heu */
  {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */
  {__pyx_k_self__this_cannot_be_converted_t, sizeof(__pyx_k_self__this_cannot_be_converted_t), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_self__this_cannot_be_converted_t */
  {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */
  {__pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate */
  {__pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setstate_cython */
  {__pyx_k_singleNode, sizeof(__pyx_k_singleNode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_singleNode */
  {__pyx_k_sorted, sizeof(__pyx_k_sorted), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sorted */
  {__pyx_k_spec, sizeof(__pyx_k_spec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spec */
  {__pyx_k_spectralDelta, sizeof(__pyx_k_spectralDelta), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spectralDelta */
  {__pyx_k_spectrum, sizeof(__pyx_k_spectrum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spectrum */
  {__pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sqrt */
  {__pyx_k_square, sizeof(__pyx_k_square), 0, 1, 1}, /* PyObject cname: __pyx_n_u_square */
  {__pyx_k_start, sizeof(__pyx_k_start), 0, 1, 1}, /* PyObject cname: __pyx_n_u_start */
  {__pyx_k_startFactor, sizeof(__pyx_k_startFactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startFactor */
  {__pyx_k_state, sizeof(__pyx_k_state), 0, 1, 1}, /* PyObject cname: __pyx_n_u_state */
  {__pyx_k_staticmethod, sizeof(__pyx_k_staticmethod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_staticmethod */
  {__pyx_k_storeNodeOrder, sizeof(__pyx_k_storeNodeOrder), 0, 1, 1}, /* PyObject cname: __pyx_n_u_storeNodeOrder */
  {__pyx_k_storePredecessors, sizeof(__pyx_k_storePredecessors), 0, 1, 1}, /* PyObject cname: __pyx_n_u_storePredecessors */
  {__pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stringsource */
  {__pyx_k_sum, sizeof(__pyx_k_sum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sum */
  {__pyx_k_super, sizeof(__pyx_k_super), 0, 1, 1}, /* PyObject cname: __pyx_n_u_super */
  {__pyx_k_symmetricEigenvectors, sizeof(__pyx_k_symmetricEigenvectors), 0, 1, 1}, /* PyObject cname: __pyx_n_u_symmetricEigenvectors */
  {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */
  {__pyx_k_third, sizeof(__pyx_k_third), 0, 1, 1}, /* PyObject cname: __pyx_n_u_third */
  {__pyx_k_threshold, sizeof(__pyx_k_threshold), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threshold */
  {__pyx_k_tol, sizeof(__pyx_k_tol), 0, 1, 1}, /* PyObject cname: __pyx_n_u_tol */
  {__pyx_k_tolerance, sizeof(__pyx_k_tolerance), 0, 1, 1}, /* PyObject cname: __pyx_n_u_tolerance */
  {__pyx_k_top, sizeof(__pyx_k_top), 0, 1, 1}, /* PyObject cname: __pyx_n_u_top */
  {__pyx_k_topkNodesList, sizeof(__pyx_k_topkNodesList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_topkNodesList */
  {__pyx_k_topkScoresList, sizeof(__pyx_k_topkScoresList), 0, 1, 1}, /* PyObject cname: __pyx_n_u_topkScoresList */
  {__pyx_k_turbo, sizeof(__pyx_k_turbo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_turbo */
  {__pyx_k_type, sizeof(__pyx_k_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_type */
  {__pyx_k_u, sizeof(__pyx_k_u), 0, 1, 1}, /* PyObject cname: __pyx_n_u_u */
  {__pyx_k_unionSample, sizeof(__pyx_k_unionSample), 0, 1, 1}, /* PyObject cname: __pyx_n_u_unionSample */
  {__pyx_k_universalConstant, sizeof(__pyx_k_universalConstant), 0, 1, 1}, /* PyObject cname: __pyx_n_u_universalConstant */
  {__pyx_k_update, sizeof(__pyx_k_update), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update */
  {__pyx_k_useBFSbound, sizeof(__pyx_k_useBFSbound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_useBFSbound */
  {__pyx_k_useNBbound, sizeof(__pyx_k_useNBbound), 0, 1, 1}, /* PyObject cname: __pyx_n_u_useNBbound */
  {__pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_use_setstate */
  {__pyx_k_v, sizeof(__pyx_k_v), 0, 1, 1}, /* PyObject cname: __pyx_n_u_v */
  {__pyx_k_val, sizeof(__pyx_k_val), 0, 1, 1}, /* PyObject cname: __pyx_n_u_val */
  {__pyx_k_vector, sizeof(__pyx_k_vector), 0, 1, 1}, /* PyObject cname: __pyx_n_u_vector */
  {__pyx_k_x, sizeof(__pyx_k_x), 0, 1, 1}, /* PyObject cname: __pyx_n_u_x */
  {0, 0, 0, 0, 0}
};
/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names);

/* #### Code section: cached_builtins ### */

static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) {
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(0, 672, __pyx_L1_error)
  __pyx_builtin_staticmethod = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_staticmethod); if (!__pyx_builtin_staticmethod) __PYX_ERR(0, 1748, __pyx_L1_error)
  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 43, __pyx_L1_error)
  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 2709, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_range); if (!__pyx_builtin_range) __PYX_ERR(0, 2746, __pyx_L1_error)
  __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_super); if (!__pyx_builtin_super) __PYX_ERR(0, 2765, __pyx_L1_error)
  __pyx_builtin_NotImplemented = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_NotImplemented); if (!__pyx_builtin_NotImplemented) __PYX_ERR(0, 2780, __pyx_L1_error)
  __pyx_builtin_sorted = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_sorted); if (!__pyx_builtin_sorted) __PYX_ERR(0, 2839, __pyx_L1_error)
  __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 2858, __pyx_L1_error)
  __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 2862, __pyx_L1_error)
  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 79, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}
/* #### Code section: cached_constants ### */

static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "(tree fragment)":4
 *     cdef object __pyx_PickleError
 *     cdef object __pyx_result
 *     if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd):             # <<<<<<<<<<<<<<
 *         from pickle import PickleError as __pyx_PickleError
 *         raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum
*/
  __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_238750788, __pyx_mstate_global->__pyx_int_228825662, __pyx_mstate_global->__pyx_int_222419149); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(1, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);

  /* "EnumType":27
 *     ('GENERALIZED', __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(GENERALIZED)),
 * 
 * ], module=globals().get("__module__", 'networkit.centrality'))             # <<<<<<<<<<<<<<
 * 
 * if PY_VERSION_HEX >= 0x030B0000:
*/
  __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_module_2, __pyx_mstate_global->__pyx_kp_u_networkit_centrality); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(1, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]);

  /* "networkit/centrality.pyx":672
 * 		GENERALIZED
 * 
 * class ClosenessVariant(object):             # <<<<<<<<<<<<<<
 * 	STANDARD = _ClosenessVariant.STANDARD
 * 	GENERALIZED = _ClosenessVariant.GENERALIZED
*/
  __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);
  __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]);

  /* "networkit/centrality.pyx":734
 * 		SUM
 * 
 * class ClosenessType(object):             # <<<<<<<<<<<<<<
 * 	INBOUND = _ClosenessType.INBOUND
 * 	OUTBOUND = _ClosenessType.OUTBOUND
*/
  __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]);
  __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]);

  /* "networkit/centrality.pyx":906
 * 		self._this = new _TopCloseness(G._this, k, first_heu, sec_heu)
 * 
 * 	def topkNodesList(self, includeTrail=False):             # <<<<<<<<<<<<<<
 * 		"""
 * 		topkNodesList(includeTrail=False)
*/
  __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(1, Py_False); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(0, 906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]);

  /* "networkit/centrality.pyx":1301
 * 		STOCHASTIC
 * 
 * class BoundStrategy(object):             # <<<<<<<<<<<<<<
 * 	NO = _BoundStrategy.NO
 * 	SPECTRAL = _BoundStrategy.SPECTRAL
*/
  __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]);
  __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(0, 1301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]);

  /* "networkit/centrality.pyx":1311
 * 	AdaptiveGeometric = ADAPTIVE_GEOMETRIC
 * 
 * class GreedyStrategy(object):             # <<<<<<<<<<<<<<
 * 	LAZY = _GreedyStrategy.LAZY
 * 	STOCHASTIC = _GreedyStrategy.STOCHASTIC
*/
  __pyx_mstate_global->__pyx_tuple[9] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[9])) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[9]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[9]);
  __pyx_mstate_global->__pyx_tuple[10] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[10])) __PYX_ERR(0, 1311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[10]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[10]);

  /* "networkit/centrality.pyx":1406
 * 		return (<_GedWalk*>(self._this)).getApproximateScore()
 * 
 * 	def scoreOfGroup(self, group, epsilon = 0.1):             # <<<<<<<<<<<<<<
 * 		"""
 * 		scoreOfGroup(group, epsilon = 0.1)
*/
  __pyx_mstate_global->__pyx_tuple[11] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_float_0_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[11])) __PYX_ERR(0, 1406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[11]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[11]);

  /* "networkit/centrality.pyx":1539
 * 		return (<_GroupCloseness*>(self._this)).groupMaxCloseness()
 * 
 * 	def computeFarness(self, S, H=0):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeFarness(S, H=0)
*/
  __pyx_mstate_global->__pyx_tuple[12] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[12])) __PYX_ERR(0, 1539, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[12]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[12]);

  /* "networkit/centrality.pyx":1879
 * 		OUT_EDGES
 * 
 * class EdgeDirection(object):             # <<<<<<<<<<<<<<
 * 	IN_EDGES = _EdgeDirection.IN_EDGES,
 * 	OUT_EDGES = _EdgeDirection.OUT_EDGES,
*/
  __pyx_mstate_global->__pyx_tuple[13] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[13])) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[13]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[13]);
  __pyx_mstate_global->__pyx_tuple[14] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[14])) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[14]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[14]);

  /* "networkit/centrality.pyx":2314
 * 		DISTRIBUTE_SINKS,
 * 
 * class Norm(object):             # <<<<<<<<<<<<<<
 * 	L1_NORM = _Norm.L1_NORM
 * 	L2_NORM = _Norm.L2_NORM
*/
  __pyx_mstate_global->__pyx_tuple[15] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[15])) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[15]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[15]);
  __pyx_mstate_global->__pyx_tuple[16] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[16])) __PYX_ERR(0, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[16]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[16]);

  /* "networkit/centrality.pyx":2320
 * 	l2norm = L2_NORM
 * 
 * class SinkHandling(object):             # <<<<<<<<<<<<<<
 * 	NO_SINK_HANDLING = _SinkHandling.NO_SINK_HANDLING
 * 	L2_NORM = _SinkHandling.DISTRIBUTE_SINKS
*/
  __pyx_mstate_global->__pyx_tuple[17] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[17])) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[17]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[17]);
  __pyx_mstate_global->__pyx_tuple[18] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[18])) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[18]);

  /* "networkit/centrality.pyx":2528
 * 		return (<_ApproxElectricalCloseness*>self._this).getDiagonal()
 * 
 * 	def computeExactDiagonal(self, double tol = 1e-9):             # <<<<<<<<<<<<<<
 * 		"""
 * 		computeExactDiagonal(tol = 1e-9)
*/
  __pyx_mstate_global->__pyx_tuple[19] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_float_1eneg_9); if (unlikely(!__pyx_mstate_global->__pyx_tuple[19])) __PYX_ERR(0, 2528, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[19]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[19]);

  /* "networkit/centrality.pyx":2903
 * 		Whether to normalize the results or not. Default: False
 * 	"""
 * 	def __init__(self, G, damp=0.95, normalized=False):             # <<<<<<<<<<<<<<
 * 		super(SciPyPageRank, self).__init__(G, normalized=normalized)
 * 
*/
  __pyx_mstate_global->__pyx_tuple[20] = PyTuple_Pack(2, ((PyObject*)__pyx_mstate_global->__pyx_float_0_95), ((PyObject*)Py_False)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[20])) __PYX_ERR(0, 2903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[20]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[20]);
  __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);
  __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;
  if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_mstate->__pyx_float_0_1 = PyFloat_FromDouble(0.1); if (unlikely(!__pyx_mstate->__pyx_float_0_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_0_2 = PyFloat_FromDouble(0.2); if (unlikely(!__pyx_mstate->__pyx_float_0_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_mstate->__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_mstate->__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_mstate->__pyx_float_0_01)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_0_95 = PyFloat_FromDouble(0.95); if (unlikely(!__pyx_mstate->__pyx_float_0_95)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_1eneg_8 = PyFloat_FromDouble(1e-8); if (unlikely(!__pyx_mstate->__pyx_float_1eneg_8)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_1eneg_9 = PyFloat_FromDouble(1e-9); if (unlikely(!__pyx_mstate->__pyx_float_1eneg_9)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_float_neg_1_0 = PyFloat_FromDouble(-1.0); if (unlikely(!__pyx_mstate->__pyx_float_neg_1_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_3 = PyLong_FromLong(3); if (unlikely(!__pyx_mstate->__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_100 = PyLong_FromLong(100); if (unlikely(!__pyx_mstate->__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_222419149 = PyLong_FromLong(222419149L); if (unlikely(!__pyx_mstate->__pyx_int_222419149)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_228825662 = PyLong_FromLong(228825662L); if (unlikely(!__pyx_mstate->__pyx_int_228825662)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_int_238750788 = PyLong_FromLong(238750788L); if (unlikely(!__pyx_mstate->__pyx_int_238750788)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}
/* #### Code section: init_codeobjects ### */
\
        typedef struct {
            unsigned int argcount : 3;
            unsigned int num_posonly_args : 1;
            unsigned int num_kwonly_args : 1;
            unsigned int nlocals : 3;
            unsigned int flags : 10;
            unsigned int first_line : 12;
            unsigned int line_table_length : 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,
        const char *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 = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2839, 12};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_x};
    __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_lambda, __pyx_k_z_aq, 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), 48, 37};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_T_1_Qa_XWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 63, 39};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_score, __pyx_k_T_1_Qa_XV1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 83, 37};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_T_1_Qa_XXQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 98, 37};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_maximum, __pyx_k_T_1_Qa_XXQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113, 37};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_centralization, __pyx_k_T_1_Qa_X_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 163, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_edgeScores, __pyx_k_hk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 215, 17};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_numberOfSamples, __pyx_k_H_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 323, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_XXQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 337, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkNodesList, __pyx_k_X_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 352, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkScoresList, __pyx_k_X_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 366, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_XWA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 381, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getNumberOfIterations, __pyx_k_X_C1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 394, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getOmega, __pyx_k_HIQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 433, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 446, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_score, __pyx_k_T_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 464, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_T_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 520, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_4xwa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 533, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_score, __pyx_k_4xvQa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 551, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_4xxq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getNumberOfSamples, __pyx_k_4x_B, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 613, 22};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getDistance, __pyx_k_D_AS, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 626, 22};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getSigma, __pyx_k_D_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 639, 22};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getSigmax, __pyx_k_D_3a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 653, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getbcx, __pyx_k_D_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 786, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getSquareErrorEstimates, __pyx_k_d_B, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 906, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkNodesList, __pyx_k_a_4x_Qa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 928, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkScoresList, __pyx_k_q_4x_aq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 950, 21};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_nodeList};
    __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_restrictTopKComputationToNodes, __pyx_k_4x_Faq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1010, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[55] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkNodesList, __pyx_k_a_4x_Qa_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[55])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1032, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[56] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkScoresList, __pyx_k_q_4x_aq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[56])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1054, 21};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_nodeList};
    __pyx_mstate_global->__pyx_codeobj_tab[57] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_restrictTopKComputationToNodes, __pyx_k_4x_Naq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[57])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[58] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[58])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[59] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[59])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1111, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[60] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_d_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[60])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1133, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[61] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkNodesList, __pyx_k_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[61])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1155, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_includeTrail};
    __pyx_mstate_global->__pyx_codeobj_tab[62] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_topkScoresList, __pyx_k_d_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[62])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[63] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[63])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[64] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[64])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[65] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[65])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[66] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[66])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1242, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[67] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxDegree, __pyx_k_hoQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[67])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1255, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[68] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getScore, __pyx_k_hiq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[68])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1271, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_group};
    __pyx_mstate_global->__pyx_codeobj_tab[69] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scoreOfGroup, __pyx_k_hm1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[69])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[70] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[70])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[71] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[71])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1380, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[72] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxGedWalk, __pyx_k_d_2_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[72])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1393, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[73] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getApproximateScore, __pyx_k_d_6a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[73])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1406, 64};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_group, __pyx_mstate->__pyx_n_u_epsilon, __pyx_mstate->__pyx_n_u_groupVec};
    __pyx_mstate_global->__pyx_codeobj_tab[74] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scoreOfGroup, __pyx_k_oQ_Qa_d_FaxvUYYaaeeiij, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[74])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[75] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[75])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[76] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[76])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1462, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[77] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxBetweenness, __pyx_k_T_1EQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[77])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1476, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_group};
    __pyx_mstate_global->__pyx_codeobj_tab[78] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scoreOfGroup, __pyx_k_T_aq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[78])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[79] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[79])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[80] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[80])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1526, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[81] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxCloseness, __pyx_k_T_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[81])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1539, 25};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_S, __pyx_mstate->__pyx_n_u_H};
    __pyx_mstate_global->__pyx_codeobj_tab[82] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_computeFarness, __pyx_k_q_T_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[82])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1560, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_group};
    __pyx_mstate_global->__pyx_codeobj_tab[83] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scoreOfGroup, __pyx_k_T_aq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[83])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[84] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[84])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[85] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[85])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1615, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[86] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxCloseness, __pyx_k_t83EQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[86])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1628, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[87] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_numberOfIterations, __pyx_k_t83Fa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[87])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[88] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[88])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[89] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[89])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1672, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[90] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxCloseness, __pyx_k_t83EQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[90])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1685, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[91] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_numberOfSwaps, __pyx_k_t8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[91])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[92] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[92])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[93] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[93])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1735, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[94] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxHarmonicCloseness, __pyx_k_T_1K1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[94])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1748, 31};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_graph, __pyx_mstate->__pyx_n_u_inputGroup};
    __pyx_mstate_global->__pyx_codeobj_tab[95] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scoreOfGroup, __pyx_k_DA_6_Zt1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[95])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[96] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[96])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[97] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[97])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1820, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[98] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_groupMaxCloseness, __pyx_k_H4Fa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[98])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1833, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[99] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_numberOfIterations, __pyx_k_H4Gq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[99])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[100] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[100])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[101] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[101])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[102] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[102])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[103] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[103])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[104] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[104])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[105] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[105])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1963, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_n};
    __pyx_mstate_global->__pyx_codeobj_tab[106] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_top, __pyx_k_HD, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[106])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1981, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[107] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_bound, __pyx_k_HF_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[107])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1999, 23};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[108] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_areDistinguished, __pyx_k_H_Qc, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[108])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[109] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[109])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[110] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[110])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[111] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[111])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[112] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[112])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[113] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[113])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[114] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[114])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[115] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[115])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[116] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[116])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2126, 21};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u};
    __pyx_mstate_global->__pyx_codeobj_tab[117] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getIntraClustering, __pyx_k_4x_B_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[117])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2144, 20};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_u};
    __pyx_mstate_global->__pyx_codeobj_tab[118] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getPermanence, __pyx_k_4x_Qa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[118])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[119] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[119])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[120] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[120])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[121] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[121])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[122] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[122])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2226, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[123] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_maxCoreNumber, __pyx_k_HN, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[123])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2239, 26};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[124] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getCover, __pyx_k_b_0_HIQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[124])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2252, 26};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[125] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getPartition, __pyx_k_HB_4D_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[125])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2265, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[126] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getNodeOrder, __pyx_k_HM, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[126])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[127] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[127])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[128] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[128])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[129] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[129])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[130] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[130])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2374, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[131] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_numberOfIterations, __pyx_k_t8_6a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[131])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[132] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[132])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[133] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[133])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2447, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[134] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_runApproximation, __pyx_k_T_1B, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[134])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2457, 19};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[135] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_runParallelApproximation, __pyx_k_T_1J, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[135])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2467, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[136] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_T_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[136])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[137] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[137])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[138] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[138])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2515, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[139] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getDiagonal, __pyx_k_t7_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[139])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2528, 24};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_tol};
    __pyx_mstate_global->__pyx_codeobj_tab[140] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_computeExactDiagonal, __pyx_k_Q_t72Gq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[140])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[141] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[141])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[142] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[142])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2588, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[143] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getDiagonal, __pyx_k_d_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[143])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[144] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[144])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[145] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[145])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2628, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[146] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_XWA_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[146])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[147] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[147])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[148] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[148])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2642, 36};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_G, __pyx_mstate->__pyx_n_u_algorithm, __pyx_mstate->__pyx_n_u_normalized, __pyx_mstate->__pyx_n_u_centrality};
    __pyx_mstate_global->__pyx_codeobj_tab[149] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_a_iq_1_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[149])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2667, 36};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_G, __pyx_mstate->__pyx_n_u_algorithm, __pyx_mstate->__pyx_n_u_normalized, __pyx_mstate->__pyx_n_u_centrality};
    __pyx_mstate_global->__pyx_codeobj_tab[150] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_Q_iq_1_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[150])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2691, 139};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ranking, __pyx_mstate->__pyx_n_u_n_nodes, __pyx_mstate->__pyx_n_u_ranking_id, __pyx_mstate->__pyx_n_u_index, __pyx_mstate->__pyx_n_u_pair, __pyx_mstate->__pyx_n_u_prev_node};
    __pyx_mstate_global->__pyx_codeobj_tab[151] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_rankPerNode, __pyx_k_3aq_ar_WHIQa_AT_WHIQa_fCq_d_3c, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[151])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2720, 101};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_rx, __pyx_mstate->__pyx_n_u_ry, __pyx_mstate->__pyx_n_u_diff, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_rnode_x, __pyx_mstate->__pyx_n_u_rnode_y, __pyx_mstate->__pyx_n_u_i};
    __pyx_mstate_global->__pyx_codeobj_tab[152] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_relativeRankErrors, __pyx_k_S_D_S_aq_aq_U_q_gRwar_BgQb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[152])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2764, 54};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_G, __pyx_mstate->__pyx_n_u_normalized};
    __pyx_mstate_global->__pyx_codeobj_tab[153] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_q_q_E_iq_nA_m1_l_gQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[153])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2774, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[154] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_prepareSpectrum, __pyx_k__8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[154])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2782, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[155] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_normFactor, __pyx_k__8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[155])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2790, 93};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_normFactor, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[156] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_run, __pyx_k_a_m1_l_gQ_T_Kq_e4vZq_t1E_Rq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[156])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2811, 45};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_v};
    __pyx_mstate_global->__pyx_codeobj_tab[157] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_scores, __pyx_k_T_Cq_ARt2U_d_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[157])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2827, 48};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[158] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_ranking, __pyx_k_T_3a_6_d_4_Fha_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[158])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2856, 43};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_G, __pyx_mstate->__pyx_n_u_normalized};
    __pyx_mstate_global->__pyx_codeobj_tab[159] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_q_Qk_AQ_q_y_Kq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[159])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2861, 34};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_vector, __pyx_mstate->__pyx_n_u_square, __pyx_mstate->__pyx_n_u_val};
    __pyx_mstate_global->__pyx_codeobj_tab[160] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_length, __pyx_k_3aq_Bd_gQ_U_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[160])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2865, 21};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[161] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_normFactor, __pyx_k_2T_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[161])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2878, 42};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_spectrum};
    __pyx_mstate_global->__pyx_codeobj_tab[162] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_prepareSpectrum, __pyx_k_hb_oXQa_nHAQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[162])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2903, 33};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_G, __pyx_mstate->__pyx_n_u_damp, __pyx_mstate->__pyx_n_u_normalized};
    __pyx_mstate_global->__pyx_codeobj_tab[163] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_init, __pyx_k_q_uIQc_A_ha, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[163])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2908, 11};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_vector};
    __pyx_mstate_global->__pyx_codeobj_tab[164] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_length, __pyx_k_AQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[164])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2911, 21};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[165] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_normFactor, __pyx_k_2T_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[165])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2924, 67};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_prMatrix, __pyx_mstate->__pyx_n_u_spectrum};
    __pyx_mstate_global->__pyx_codeobj_tab[166] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_prepareSpectrum, __pyx_k_1D_A_WCxq_oXQb_nHARq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[166])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 85};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate};
    __pyx_mstate_global->__pyx_codeobj_tab[167] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_A_G1F_a_vWA_q_q_q_0_AWKwa_0_AWK, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[167])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16, 11};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[168] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[168])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2995, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[169] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getPLci, __pyx_k_4xxq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[169])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3010, 27};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[170] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getComplexGraph, __pyx_k_b_4x7Gq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[170])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3023, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[171] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_getAdopters, __pyx_k_4x_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[171])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3038, 18};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[172] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_networkit_centrality_pyx, __pyx_mstate->__pyx_n_u_normalize, __pyx_k_4xz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[172])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
    __pyx_mstate_global->__pyx_codeobj_tab[173] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[173])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3, 9};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state};
    __pyx_mstate_global->__pyx_codeobj_tab[174] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[174])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1, 77};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_PickleError, __pyx_mstate->__pyx_n_u_pyx_result};
    __pyx_mstate_global->__pyx_codeobj_tab[175] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_ComplexPathMode, __pyx_k_hk_A_1_kkmmn_1_7_1_2DNRS_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[175])) 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)

  /* 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)

  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 */
#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 */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
#if PY_VERSION_HEX >= 0x030C00A6
    PyObject *tmp_value;
    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
    if (value) {
        #if CYTHON_COMPILING_IN_CPYTHON
        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
        #endif
            PyException_SetTraceback(value, tb);
    }
    tmp_value = tstate->current_exception;
    tstate->current_exception = value;
    Py_XDECREF(tmp_value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
#else
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
#endif
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
#if PY_VERSION_HEX >= 0x030C00A6
    PyObject* exc_value;
    exc_value = tstate->current_exception;
    tstate->current_exception = 0;
    *value = exc_value;
    *type = NULL;
    *tb = NULL;
    if (exc_value) {
        *type = (PyObject*) Py_TYPE(exc_value);
        Py_INCREF(*type);
        #if CYTHON_COMPILING_IN_CPYTHON
        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
        Py_XINCREF(*tb);
        #else
        *tb = PyException_GetTraceback(exc_value);
        #endif
    }
#else
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
#endif
}
#endif

/* PyObjectGetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
    return PyObject_GetAttr(obj, attr_name);
}
#endif

/* PyObjectGetAttrStrNoError */
#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 */
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 */
#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);
}

/* PyFunctionFastCall */
#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *args, Py_ssize_t na,
                                               PyObject *globals) {
    PyFrameObject *f;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject **fastlocals;
    Py_ssize_t i;
    PyObject *result;
    assert(globals != NULL);
    /* XXX Perhaps we should create a specialized
       PyFrame_New() that doesn't take locals, but does
       take builtins without sanity checking them.
       */
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, NULL);
    if (f == NULL) {
        return NULL;
    }
    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
    for (i = 0; i < na; i++) {
        Py_INCREF(*args);
        fastlocals[i] = *args++;
    }
    result = PyEval_EvalFrameEx(f,0);
    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;
    return result;
}
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) {
    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
    PyObject *globals = PyFunction_GET_GLOBALS(func);
    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
    PyObject *closure;
    PyObject *kwdefs;
    PyObject *kwtuple, **k;
    PyObject **d;
    Py_ssize_t nd;
    Py_ssize_t nk;
    PyObject *result;
    assert(kwargs == NULL || PyDict_Check(kwargs));
    nk = kwargs ? PyDict_Size(kwargs) : 0;
    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
        return NULL;
    }
    if (
            co->co_kwonlyargcount == 0 &&
            likely(kwargs == NULL || nk == 0) &&
            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
        if (argdefs == NULL && co->co_argcount == nargs) {
            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
            goto done;
        }
        else if (nargs == 0 && argdefs != NULL
                 && co->co_argcount == Py_SIZE(argdefs)) {
            /* function called with no arguments, but all parameters have
               a default value: use default values as arguments .*/
            args = &PyTuple_GET_ITEM(argdefs, 0);
            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
            goto done;
        }
    }
    if (kwargs != NULL) {
        Py_ssize_t pos, i;
        kwtuple = PyTuple_New(2 * nk);
        if (kwtuple == NULL) {
            result = NULL;
            goto done;
        }
        k = &PyTuple_GET_ITEM(kwtuple, 0);
        pos = i = 0;
        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
            Py_INCREF(k[i]);
            Py_INCREF(k[i+1]);
            i += 2;
        }
        nk = i / 2;
    }
    else {
        kwtuple = NULL;
        k = NULL;
    }
    closure = PyFunction_GET_CLOSURE(func);
    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
    if (argdefs != NULL) {
        d = &PyTuple_GET_ITEM(argdefs, 0);
        nd = Py_SIZE(argdefs);
    }
    else {
        d = NULL;
        nd = 0;
    }
    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
                               args, (int)nargs,
                               k, (int)nk,
                               d, (int)nd, kwdefs, closure);
    Py_XDECREF(kwtuple);
done:
    Py_LeaveRecursiveCall();
    return result;
}
#endif

/* PyObjectCall */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = Py_TYPE(func)->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (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 */
#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 PY_VERSION_HEX < 0x030800B1
    #if CYTHON_FAST_PYCCALL
    if (PyCFunction_Check(func)) {
        if (kwargs) {
            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
        } else {
            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
        }
    }
    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
    }
    #endif
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
    }
    #endif
    #endif
    if (kwargs == NULL) {
        #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API
        vectorcallfunc f = __Pyx_PyVectorcall_Function(func);
        if (f) {
            return f(func, args, _nargs, NULL);
        }
        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
        if (__Pyx_CyFunction_CheckExact(func)) {
            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
            if (f) return f(func, args, _nargs, NULL);
        }
        #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL
        return PyObject_Vectorcall(func, args, _nargs, NULL);
        #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
}

/* TupleAndListFromArray */
#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 */
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 */
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

/* KeywordStringCheck */
static int __Pyx_CheckKeywordStrings(
    const char* function_name,
    PyObject *kw)
{
#if CYTHON_COMPILING_IN_PYPY && !defined(PyArg_ValidateKeywordArguments)
    CYTHON_UNUSED_VAR(function_name);
    CYTHON_UNUSED_VAR(kw);
    return 0;
#else
    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
#if PY_VERSION_HEX >= 0x03090000
        CYTHON_UNUSED_VAR(function_name);
#else
        Py_ssize_t kwsize;
        #if CYTHON_ASSUME_SAFE_SIZE
        kwsize = PyTuple_GET_SIZE(kw);
        #else
        kwsize = PyTuple_Size(kw);
        if (unlikely(kwsize < 0)) return -1;
        #endif
        for (Py_ssize_t pos = 0; pos < kwsize; pos++) {
            PyObject* key = NULL;
            #if CYTHON_ASSUME_SAFE_MACROS
            key = PyTuple_GET_ITEM(kw, pos);
            #else
            key = PyTuple_GetItem(kw, pos);
            if (unlikely(!key)) return -1;
            #endif
            if (unlikely(!PyUnicode_Check(key))) {
                PyErr_Format(PyExc_TypeError,
                    "%.200s() keywords must be strings", function_name);
                return -1;
            }
        }
#endif
    } else {
        if (unlikely(!PyArg_ValidateKeywordArguments(kw))) return -1;
    }
    return 0;
#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;
}

/* 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);
}

/* RejectKeywords */
static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) {
    PyObject *key = NULL;
    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) {
        key = __Pyx_PySequence_ITEM(kwds, 0);
    } else {
        Py_ssize_t pos = 0;
#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
        if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return;
#endif
        PyDict_Next(kwds, &pos, &key, NULL);
        Py_INCREF(key);
    }
    if (likely(key)) {
        PyErr_Format(PyExc_TypeError,
            "%s() got an unexpected keyword argument '%U'",
            function_name, key);
        Py_DECREF(key);
    }
}

/* RaiseDoubleKeywords */
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);
}

/* UnpackUnboundCMethod */
#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;
}

/* 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);
    }
}

/* 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)
{
    Py_ssize_t pos = 0;
    PyObject *key = NULL;
    __Pyx_BEGIN_CRITICAL_SECTION(kwds);
    while (PyDict_Next(kwds, &pos, &key, NULL)) {
        PyObject** const *name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (!*name) {
            #if CYTHON_AVOID_BORROWED_REFS
            Py_INCREF(key);
            #endif
            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();
    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;
}
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);
}

/* 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;
}

/* GetTopmostException */
#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
static _PyErr_StackItem *
__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
{
    _PyErr_StackItem *exc_info = tstate->exc_info;
    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
           exc_info->previous_item != NULL)
    {
        exc_info = exc_info->previous_item;
    }
    return exc_info;
}
#endif

/* SaveResetException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
    PyObject *exc_value = exc_info->exc_value;
    if (exc_value == NULL || exc_value == Py_None) {
        *value = NULL;
        *type = NULL;
        *tb = NULL;
    } else {
        *value = exc_value;
        Py_INCREF(*value);
        *type = (PyObject*) Py_TYPE(exc_value);
        Py_INCREF(*type);
        *tb = PyException_GetTraceback(exc_value);
    }
  #elif CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
    *type = exc_info->exc_type;
    *value = exc_info->exc_value;
    *tb = exc_info->exc_traceback;
    Py_XINCREF(*type);
    Py_XINCREF(*value);
    Py_XINCREF(*tb);
  #else
    *type = tstate->exc_type;
    *value = tstate->exc_value;
    *tb = tstate->exc_traceback;
    Py_XINCREF(*type);
    Py_XINCREF(*value);
    Py_XINCREF(*tb);
  #endif
}
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
    _PyErr_StackItem *exc_info = tstate->exc_info;
    PyObject *tmp_value = exc_info->exc_value;
    exc_info->exc_value = value;
    Py_XDECREF(tmp_value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
  #else
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    #if CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = tstate->exc_info;
    tmp_type = exc_info->exc_type;
    tmp_value = exc_info->exc_value;
    tmp_tb = exc_info->exc_traceback;
    exc_info->exc_type = type;
    exc_info->exc_value = value;
    exc_info->exc_traceback = tb;
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
    #endif
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
  #endif
}
#endif

/* GetException */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
#endif
{
    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
#if CYTHON_FAST_THREAD_STATE
    PyObject *tmp_type, *tmp_value, *tmp_tb;
  #if PY_VERSION_HEX >= 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
}

/* PyObjectFastCallMethod */
#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000
static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) {
    PyObject *result;
    PyObject *attr = PyObject_GetAttr(args[0], name);
    if (unlikely(!attr))
        return NULL;
    result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1);
    Py_DECREF(attr);
    return result;
}
#endif

/* PyLongBinop */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) {
    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
}
#if CYTHON_USE_PYLONG_INTERNALS
static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
    CYTHON_MAYBE_UNUSED_VAR(inplace);
    CYTHON_UNUSED_VAR(zerodivision_check);
    const long b = intval;
    long a, x;
#ifdef HAVE_LONG_LONG
    const PY_LONG_LONG llb = intval;
    PY_LONG_LONG lla, llx;
#endif
    if (unlikely(__Pyx_PyLong_IsZero(op1))) {
        return __Pyx_NewRef(op2);
    }
    if (likely(__Pyx_PyLong_IsCompact(op1))) {
        a = __Pyx_PyLong_CompactValue(op1);
    } else {
        const digit* digits = __Pyx_PyLong_Digits(op1);
        const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
        switch (size) {
            case -2:
                if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                    a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 2:
                if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                    a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case -3:
                if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                    a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 3:
                if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                    a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case -4:
                if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                    a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 4:
                if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                    a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
        }
    }
            x = a + b;
        return PyLong_FromLong(x);
#ifdef HAVE_LONG_LONG
    long_long:
            llx = lla + llb;
        return PyLong_FromLongLong(llx);
#endif
    return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace);
    
    
}
#endif
static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) {
    CYTHON_UNUSED_VAR(zerodivision_check);
    const long b = intval;
    double a = __Pyx_PyFloat_AS_DOUBLE(float_val);
        double result;
        
        result = ((double)a) + (double)b;
        return PyFloat_FromDouble(result);
}
static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
    CYTHON_MAYBE_UNUSED_VAR(intval);
    CYTHON_UNUSED_VAR(zerodivision_check);
    #if CYTHON_USE_PYLONG_INTERNALS
    if (likely(PyLong_CheckExact(op1))) {
        return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check);
    }
    #endif
    if (PyFloat_CheckExact(op1)) {
        return __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check);
    }
    return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace);
}
#endif

/* GetItemInt */
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (unlikely(!j)) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyList_GET_SIZE(o);
    }
    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyTuple_GET_SIZE(o);
    }
    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
                                                     CYTHON_NCP_UNUSED int wraparound,
                                                     CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
            return __Pyx_PyList_GetItemRef(o, n);
        }
    }
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    } else {
        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
        if (mm && mm->mp_subscript) {
            PyObject *r, *key = PyLong_FromSsize_t(i);
            if (unlikely(!key)) return NULL;
            r = mm->mp_subscript(o, key);
            Py_DECREF(key);
            return r;
        }
        if (likely(sm && sm->sq_item)) {
            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
                Py_ssize_t l = sm->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return NULL;
                    PyErr_Clear();
                }
            }
            return sm->sq_item(o, i);
        }
    }
#else
    if (is_list || !PyMapping_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
}

/* PyLongCompare */
static CYTHON_INLINE int __Pyx_PyLong_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) {
    CYTHON_MAYBE_UNUSED_VAR(intval);
    CYTHON_UNUSED_VAR(inplace);
    if (op1 == op2) {
        return 1;
    }
    #if CYTHON_USE_PYLONG_INTERNALS
    if (likely(PyLong_CheckExact(op1))) {
        int unequal;
        unsigned long uintval;
        Py_ssize_t size = __Pyx_PyLong_DigitCount(op1);
        const digit* digits = __Pyx_PyLong_Digits(op1);
        if (intval == 0) {
            return (__Pyx_PyLong_IsZero(op1) == 1);
        } else if (intval < 0) {
            if (__Pyx_PyLong_IsNonNeg(op1))
                return 0;
            intval = -intval;
        } else {
            if (__Pyx_PyLong_IsNeg(op1))
                return 0;
        }
        uintval = (unsigned long) intval;
#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
        if (uintval >> (PyLong_SHIFT * 4)) {
            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
        } else
#endif
#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
        if (uintval >> (PyLong_SHIFT * 3)) {
            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
        } else
#endif
#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
        if (uintval >> (PyLong_SHIFT * 2)) {
            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
        } else
#endif
#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
        if (uintval >> (PyLong_SHIFT * 1)) {
            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
        } else
#endif
            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
        return (unequal == 0);
    }
    #endif
    if (PyFloat_CheckExact(op1)) {
        const long b = intval;
        double a = __Pyx_PyFloat_AS_DOUBLE(op1);
        return ((double)a == (double)b);
    }
    return __Pyx_PyObject_IsTrueAndDecref(
        PyObject_RichCompare(op1, op2, Py_EQ));
}

/* PyLongBinop */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_Fallback___Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, int inplace) {
    return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2);
}
#if CYTHON_USE_PYLONG_INTERNALS
static PyObject* __Pyx_Unpacked___Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
    CYTHON_MAYBE_UNUSED_VAR(inplace);
    CYTHON_UNUSED_VAR(zerodivision_check);
    const long b = intval;
    long a, x;
#ifdef HAVE_LONG_LONG
    const PY_LONG_LONG llb = intval;
    PY_LONG_LONG lla, llx;
#endif
    if (unlikely(__Pyx_PyLong_IsZero(op1))) {
        return PyLong_FromLong(-intval);
    }
    if (likely(__Pyx_PyLong_IsCompact(op1))) {
        a = __Pyx_PyLong_CompactValue(op1);
    } else {
        const digit* digits = __Pyx_PyLong_Digits(op1);
        const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
        switch (size) {
            case -2:
                if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                    a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 2:
                if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                    a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case -3:
                if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                    a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 3:
                if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                    a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case -4:
                if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                    a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                    lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            case 4:
                if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                    a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                    break;
                #ifdef HAVE_LONG_LONG
                } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                    lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                    goto long_long;
                #endif
                }
                CYTHON_FALLTHROUGH;
            default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
        }
    }
            x = a - b;
        return PyLong_FromLong(x);
#ifdef HAVE_LONG_LONG
    long_long:
            llx = lla - llb;
        return PyLong_FromLongLong(llx);
#endif
    return __Pyx_Fallback___Pyx_PyLong_SubtractObjC(op1, op2, inplace);
    
    
}
#endif
static PyObject* __Pyx_Float___Pyx_PyLong_SubtractObjC(PyObject *float_val, long intval, int zerodivision_check) {
    CYTHON_UNUSED_VAR(zerodivision_check);
    const long b = intval;
    double a = __Pyx_PyFloat_AS_DOUBLE(float_val);
        double result;
        
        result = ((double)a) - (double)b;
        return PyFloat_FromDouble(result);
}
static CYTHON_INLINE PyObject* __Pyx_PyLong_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
    CYTHON_MAYBE_UNUSED_VAR(intval);
    CYTHON_UNUSED_VAR(zerodivision_check);
    #if CYTHON_USE_PYLONG_INTERNALS
    if (likely(PyLong_CheckExact(op1))) {
        return __Pyx_Unpacked___Pyx_PyLong_SubtractObjC(op1, op2, intval, inplace, zerodivision_check);
    }
    #endif
    if (PyFloat_CheckExact(op1)) {
        return __Pyx_Float___Pyx_PyLong_SubtractObjC(op1, intval, zerodivision_check);
    }
    return __Pyx_Fallback___Pyx_PyLong_SubtractObjC(op1, op2, inplace);
}
#endif

/* PyObjectCallOneArg */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *args[2] = {NULL, arg};
    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
}

/* ObjectGetItem */
#if CYTHON_USE_TYPE_SLOTS
static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) {
    PyObject *runerr = NULL;
    Py_ssize_t key_value;
    key_value = __Pyx_PyIndex_AsSsize_t(index);
    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
    }
    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
        __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index));
        PyErr_Clear();
        PyErr_Format(PyExc_IndexError,
            "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name);
        __Pyx_DECREF_TypeName(index_type_name);
    }
    return NULL;
}
static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) {
    __Pyx_TypeName obj_type_name;
    if (likely(PyType_Check(obj))) {
        PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem);
        if (!meth) {
            PyErr_Clear();
        } else {
            PyObject *result = __Pyx_PyObject_CallOneArg(meth, key);
            Py_DECREF(meth);
            return result;
        }
    }
    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
    PyErr_Format(PyExc_TypeError,
        "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name);
    __Pyx_DECREF_TypeName(obj_type_name);
    return NULL;
}
static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) {
    PyTypeObject *tp = Py_TYPE(obj);
    PyMappingMethods *mm = tp->tp_as_mapping;
    PySequenceMethods *sm = tp->tp_as_sequence;
    if (likely(mm && mm->mp_subscript)) {
        return mm->mp_subscript(obj, key);
    }
    if (likely(sm && sm->sq_item)) {
        return __Pyx_PyObject_GetIndex(obj, key);
    }
    return __Pyx_PyObject_GetItem_Slow(obj, key);
}
#endif

/* PyObjectSetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_setattro))
        return tp->tp_setattro(obj, attr_name, value);
    return PyObject_SetAttr(obj, attr_name, value);
}
#endif

/* IterFinish */
static CYTHON_INLINE int __Pyx_IterFinish(void) {
    PyObject* exc_type;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    exc_type = __Pyx_PyErr_CurrentExceptionType();
    if (unlikely(exc_type)) {
        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
            return -1;
        __Pyx_PyErr_Clear();
        return 0;
    }
    return 0;
}

/* PyObjectCallNoArg */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
    PyObject *arg[2] = {NULL, NULL};
    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
}

/* PyObjectGetMethod */
static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
    PyObject *attr;
#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
    __Pyx_TypeName type_name;
    PyTypeObject *tp = Py_TYPE(obj);
    PyObject *descr;
    descrgetfunc f = NULL;
    PyObject **dictptr, *dict;
    int meth_found = 0;
    assert (*method == NULL);
    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
        attr = __Pyx_PyObject_GetAttrStr(obj, name);
        goto try_unpack;
    }
    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
        return 0;
    }
    descr = _PyType_Lookup(tp, name);
    if (likely(descr != NULL)) {
        Py_INCREF(descr);
#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
#else
        #ifdef __Pyx_CyFunction_USED
        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
        #else
        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
        #endif
#endif
        {
            meth_found = 1;
        } else {
            f = Py_TYPE(descr)->tp_descr_get;
            if (f != NULL && PyDescr_IsData(descr)) {
                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
                Py_DECREF(descr);
                goto try_unpack;
            }
        }
    }
    dictptr = _PyObject_GetDictPtr(obj);
    if (dictptr != NULL && (dict = *dictptr) != NULL) {
        Py_INCREF(dict);
        attr = __Pyx_PyDict_GetItemStr(dict, name);
        if (attr != NULL) {
            Py_INCREF(attr);
            Py_DECREF(dict);
            Py_XDECREF(descr);
            goto try_unpack;
        }
        Py_DECREF(dict);
    }
    if (meth_found) {
        *method = descr;
        return 1;
    }
    if (f != NULL) {
        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
        Py_DECREF(descr);
        goto try_unpack;
    }
    if (likely(descr != NULL)) {
        *method = descr;
        return 0;
    }
    type_name = __Pyx_PyType_GetFullyQualifiedName(tp);
    PyErr_Format(PyExc_AttributeError,
                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
                 type_name, name);
    __Pyx_DECREF_TypeName(type_name);
    return 0;
#else
    attr = __Pyx_PyObject_GetAttrStr(obj, name);
    goto try_unpack;
#endif
try_unpack:
#if CYTHON_UNPACK_METHODS
    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
        PyObject *function = PyMethod_GET_FUNCTION(attr);
        Py_INCREF(function);
        Py_DECREF(attr);
        *method = function;
        return 1;
    }
#endif
    *method = attr;
    return 0;
}

/* PyObjectCallMethod0 */
static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
    PyObject *args[1] = {obj};
    (void) __Pyx_PyObject_GetMethod;
    (void) __Pyx_PyObject_CallOneArg;
    (void) __Pyx_PyObject_CallNoArg;
    return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
#else
    PyObject *method = NULL, *result = NULL;
    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
    if (likely(is_method)) {
        result = __Pyx_PyObject_CallOneArg(method, obj);
        Py_DECREF(method);
        return result;
    }
    if (unlikely(!method)) goto bad;
    result = __Pyx_PyObject_CallNoArg(method);
    Py_DECREF(method);
bad:
    return result;
#endif
}

/* RaiseNeedMoreValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* RaiseTooManyValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* UnpackItemEndCheck */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
        __Pyx_RaiseTooManyValuesError(expected);
        return -1;
    }
    return __Pyx_IterFinish();
}

/* RaiseNoneIterError */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/* UnpackTupleError */
static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
    if (t == Py_None) {
      __Pyx_RaiseNoneNotIterableError();
    } else {
      Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t);
 #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely(size < 0)) return;
 #endif
      if (size < index) {
        __Pyx_RaiseNeedMoreValuesError(size);
      } else {
        __Pyx_RaiseTooManyValuesError(index);
      }
    }
}

/* UnpackTuple2 */
static CYTHON_INLINE int __Pyx_unpack_tuple2(
        PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) {
    if (likely(is_tuple || PyTuple_Check(tuple))) {
        Py_ssize_t size;
        if (has_known_size) {
            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
        }
        size = __Pyx_PyTuple_GET_SIZE(tuple);
        if (likely(size == 2)) {
            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
        }
        if (size >= 0) {
            __Pyx_UnpackTupleError(tuple, 2);
        }
        return -1;
    } else {
        return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple);
    }
}
static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
    PyObject *value1 = NULL, *value2 = NULL;
#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
    value1 = __Pyx_PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
    value2 = __Pyx_PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
#else
    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
#endif
    if (decref_tuple) {
        Py_DECREF(tuple);
    }
    *pvalue1 = value1;
    *pvalue2 = value2;
    return 0;
#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
bad:
    Py_XDECREF(value1);
    Py_XDECREF(value2);
    if (decref_tuple) { Py_XDECREF(tuple); }
    return -1;
#endif
}
static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
                                       int has_known_size, int decref_tuple) {
    Py_ssize_t index;
    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
    iternextfunc iternext;
    iter = PyObject_GetIter(tuple);
    if (unlikely(!iter)) goto bad;
    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
    iternext = __Pyx_PyObject_GetIterNextFunc(iter);
    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
    Py_DECREF(iter);
    *pvalue1 = value1;
    *pvalue2 = value2;
    return 0;
unpacking_failed:
    if (!has_known_size && __Pyx_IterFinish() == 0)
        __Pyx_RaiseNeedMoreValuesError(index);
bad:
    Py_XDECREF(iter);
    Py_XDECREF(value1);
    Py_XDECREF(value2);
    if (decref_tuple) { Py_XDECREF(tuple); }
    return -1;
}

/* dict_iter */
#if CYTHON_COMPILING_IN_PYPY
#include <string.h>
#endif
static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
    *p_source_is_dict = is_dict;
    if (is_dict) {
#if !CYTHON_COMPILING_IN_PYPY
        *p_orig_length = PyDict_Size(iterable);
        Py_INCREF(iterable);
        return iterable;
#else
        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
        PyObject **pp = NULL;
        if (method_name) {
            const char *name = PyUnicode_AsUTF8(method_name);
            if (strcmp(name, "iteritems") == 0) pp = &py_items;
            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
            if (pp) {
                if (!*pp) {
                    *pp = PyUnicode_FromString(name + 4);
                    if (!*pp)
                        return NULL;
                }
                method_name = *pp;
            }
        }
#endif
    }
    *p_orig_length = 0;
    if (method_name) {
        PyObject* iter;
        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
        if (!iterable)
            return NULL;
#if !CYTHON_COMPILING_IN_PYPY
        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
            return iterable;
#endif
        iter = PyObject_GetIter(iterable);
        Py_DECREF(iterable);
        return iter;
    }
    return PyObject_GetIter(iterable);
}
#if !CYTHON_COMPILING_IN_PYPY
static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict(
        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
        PyObject** pkey, PyObject** pvalue, PyObject** pitem) {
    PyObject *key, *value;
    if (unlikely(orig_length != PyDict_Size(iter_obj))) {
        PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
        return -1;
    }
    if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
        return 0;
    }
    if (pitem) {
        PyObject* tuple = PyTuple_New(2);
        if (unlikely(!tuple)) {
            return -1;
        }
        Py_INCREF(key);
        Py_INCREF(value);
        #if CYTHON_ASSUME_SAFE_MACROS
        PyTuple_SET_ITEM(tuple, 0, key);
        PyTuple_SET_ITEM(tuple, 1, value);
        #else
        if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) {
            Py_DECREF(value);
            Py_DECREF(tuple);
            return -1;
        }
        if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) {
            Py_DECREF(tuple);
            return -1;
        }
        #endif
        *pitem = tuple;
    } else {
        if (pkey) {
            Py_INCREF(key);
            *pkey = key;
        }
        if (pvalue) {
            Py_INCREF(value);
            *pvalue = value;
        }
    }
    return 1;
}
#endif
static CYTHON_INLINE int __Pyx_dict_iter_next(
        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
    PyObject* next_item;
#if !CYTHON_COMPILING_IN_PYPY
    if (source_is_dict) {
        int result;
#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
        Py_BEGIN_CRITICAL_SECTION(iter_obj);
#endif
        result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem);
#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
        Py_END_CRITICAL_SECTION();
#endif
        return result;
    } else if (PyTuple_CheckExact(iter_obj)) {
        Py_ssize_t pos = *ppos;
        Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(tuple_size < 0)) return -1;
        #endif
        if (unlikely(pos >= tuple_size)) return 0;
        *ppos = pos + 1;
        #if CYTHON_ASSUME_SAFE_MACROS
        next_item = PyTuple_GET_ITEM(iter_obj, pos);
        #else
        next_item = PyTuple_GetItem(iter_obj, pos);
        if (unlikely(!next_item)) return -1;
        #endif
        Py_INCREF(next_item);
    } else if (PyList_CheckExact(iter_obj)) {
        Py_ssize_t pos = *ppos;
        Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(list_size < 0)) return -1;
        #endif
        if (unlikely(pos >= list_size)) return 0;
        *ppos = pos + 1;
        #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
        next_item = PyList_GetItemRef(iter_obj, pos);
        if (unlikely(!next_item)) return -1;
        #elif CYTHON_ASSUME_SAFE_MACROS
        next_item = PyList_GET_ITEM(iter_obj, pos);
        Py_INCREF(next_item);
        #else
        next_item = PyList_GetItem(iter_obj, pos);
        if (unlikely(!next_item)) return -1;
        Py_INCREF(next_item);
        #endif
    } else
#endif
    {
        next_item = PyIter_Next(iter_obj);
        if (unlikely(!next_item)) {
            return __Pyx_IterFinish();
        }
    }
    if (pitem) {
        *pitem = next_item;
    } else if (pkey && pvalue) {
        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
            return -1;
    } else if (pkey) {
        *pkey = next_item;
    } else {
        *pvalue = next_item;
    }
    return 1;
}

/* pybytes_as_double */
static double __Pyx_SlowPyString_AsDouble(PyObject *obj) {
    PyObject *float_value = PyFloat_FromString(obj);
    if (likely(float_value)) {
        double value = __Pyx_PyFloat_AS_DOUBLE(float_value);
        Py_DECREF(float_value);
        return value;
    }
    return (double)-1;
}
static const char* __Pyx__PyBytes_AsDouble_Copy(const char* start, char* buffer, Py_ssize_t length) {
    int last_was_punctuation = 1;
    int parse_error_found = 0;
    Py_ssize_t i;
    for (i=0; i < length; i++) {
        char chr = start[i];
        int is_punctuation = (chr == '_') | (chr == '.') | (chr == 'e') | (chr == 'E');
        *buffer = chr;
        buffer += (chr != '_');
        parse_error_found |= last_was_punctuation & is_punctuation;
        last_was_punctuation = is_punctuation;
    }
    parse_error_found |= last_was_punctuation;
    *buffer = '\0';
    return unlikely(parse_error_found) ? NULL : buffer;
}
static double __Pyx__PyBytes_AsDouble_inf_nan(const char* start, Py_ssize_t length) {
    int matches = 1;
    char sign = start[0];
    int is_signed = (sign == '+') | (sign == '-');
    start += is_signed;
    length -= is_signed;
    switch (start[0]) {
        #ifdef Py_NAN
        case 'n':
        case 'N':
            if (unlikely(length != 3)) goto parse_failure;
            matches &= (start[1] == 'a' || start[1] == 'A');
            matches &= (start[2] == 'n' || start[2] == 'N');
            if (unlikely(!matches)) goto parse_failure;
            return (sign == '-') ? -Py_NAN : Py_NAN;
        #endif
        case 'i':
        case 'I':
            if (unlikely(length < 3)) goto parse_failure;
            matches &= (start[1] == 'n' || start[1] == 'N');
            matches &= (start[2] == 'f' || start[2] == 'F');
            if (likely(length == 3 && matches))
                return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
            if (unlikely(length != 8)) goto parse_failure;
            matches &= (start[3] == 'i' || start[3] == 'I');
            matches &= (start[4] == 'n' || start[4] == 'N');
            matches &= (start[5] == 'i' || start[5] == 'I');
            matches &= (start[6] == 't' || start[6] == 'T');
            matches &= (start[7] == 'y' || start[7] == 'Y');
            if (unlikely(!matches)) goto parse_failure;
            return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
        case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            break;
        default:
            goto parse_failure;
    }
    return 0.0;
parse_failure:
    return -1.0;
}
static CYTHON_INLINE int __Pyx__PyBytes_AsDouble_IsSpace(char ch) {
    return (ch == 0x20) | !((ch < 0x9) | (ch > 0xd));
}
CYTHON_UNUSED static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length) {
    double value;
    Py_ssize_t i, digits;
    const char *last = start + length;
    char *end;
    while (__Pyx__PyBytes_AsDouble_IsSpace(*start))
        start++;
    while (start < last - 1 && __Pyx__PyBytes_AsDouble_IsSpace(last[-1]))
        last--;
    length = last - start;
    if (unlikely(length <= 0)) goto fallback;
    value = __Pyx__PyBytes_AsDouble_inf_nan(start, length);
    if (unlikely(value == -1.0)) goto fallback;
    if (value != 0.0) return value;
    digits = 0;
    for (i=0; i < length; digits += start[i++] != '_');
    if (likely(digits == length)) {
        value = PyOS_string_to_double(start, &end, NULL);
    } else if (digits < 40) {
        char number[40];
        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
        if (unlikely(!last)) goto fallback;
        value = PyOS_string_to_double(number, &end, NULL);
    } else {
        char *number = (char*) PyMem_Malloc((digits + 1) * sizeof(char));
        if (unlikely(!number)) goto fallback;
        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
        if (unlikely(!last)) {
            PyMem_Free(number);
            goto fallback;
        }
        value = PyOS_string_to_double(number, &end, NULL);
        PyMem_Free(number);
    }
    if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) {
        return value;
    }
fallback:
    return __Pyx_SlowPyString_AsDouble(obj);
}

/* pynumber_float */
static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj) {
    double val;
    if (PyLong_CheckExact(obj)) {
#if CYTHON_USE_PYLONG_INTERNALS
        if (likely(__Pyx_PyLong_IsCompact(obj))) {
            val = (double) __Pyx_PyLong_CompactValue(obj);
            goto no_error;
        }
#endif
        val = PyLong_AsDouble(obj);
    } else if (PyUnicode_CheckExact(obj)) {
        val = __Pyx_PyUnicode_AsDouble(obj);
    } else if (PyBytes_CheckExact(obj)) {
        val = __Pyx_PyBytes_AsDouble(obj);
    } else if (PyByteArray_CheckExact(obj)) {
        val = __Pyx_PyByteArray_AsDouble(obj);
    } else {
        return PyNumber_Float(obj);
    }
    if (unlikely(val == -1 && PyErr_Occurred())) {
        return NULL;
    }
#if CYTHON_USE_PYLONG_INTERNALS
no_error:
#endif
    return PyFloat_FromDouble(val);
}

/* LimitedApiGetTypeDict */
#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 */
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 */
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);
#if PY_VERSION_HEX >= 0x030800b4
                    type->tp_vectorcall_offset = memb->offset;
#else
                    type->tp_print = (printfunc) memb->offset;
#endif
                    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;
        }
    }
#endif  // !CYTHON_COMPILING_IN_PYPY
    if (changed)
        PyType_Modified(type);
#endif  // PY_VERSION_HEX > 0x030900B1
    return 0;
}

/* FetchSharedCythonModule */
static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
    return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);
}

/* dict_setdefault */
static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value,
                                                       int is_safe_type) {
    PyObject* value;
    CYTHON_MAYBE_UNUSED_VAR(is_safe_type);
#if CYTHON_COMPILING_IN_LIMITED_API
    value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value);
#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;
}

/* FetchCommonType */
#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;
    }
    CYTHON_UNUSED_VAR(module);
    cached_type = __Pyx_PyType_FromMetaclass(metaclass, 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, 1);
    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 */
static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
    return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
}
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},
    {0, 0}
};
static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
    __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
    0,
    0,
#if PY_VERSION_HEX >= 0x030A0000
    Py_TPFLAGS_IMMUTABLETYPE |
    Py_TPFLAGS_DISALLOW_INSTANTIATION |
#endif
    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 */
#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 */
#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 */
#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_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, pos;
    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 = i = 0;
    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
    while (PyDict_Next(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
        Py_INCREF(key);
        Py_INCREF(value);
        #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:
    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 */
#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;
}
static PyObject *
__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op)
{
    if (unlikely(op->func_dict == NULL)) {
        op->func_dict = PyDict_New();
        if (unlikely(op->func_dict == NULL))
            return NULL;
    }
    Py_INCREF(op->func_dict);
    return op->func_dict;
}
static PyObject *
__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(context);
    PyObject *result;
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_dict_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
{
    CYTHON_UNUSED_VAR(context);
    if (unlikely(value == NULL)) {
        PyErr_SetString(PyExc_TypeError,
               "function's dictionary may not be deleted");
        return -1;
    }
    if (unlikely(!PyDict_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
               "setting function's dictionary to a non-dict");
        return -1;
    }
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->func_dict, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(op->func_globals);
    return op->func_globals;
}
static PyObject *
__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(op);
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject *
__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
{
    PyObject* result = (op->func_code) ? op->func_code : Py_None;
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(result);
    return result;
}
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
    int result = 0;
    PyObject *res = op->defaults_getter((PyObject *) op);
    if (unlikely(!res))
        return -1;
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
    Py_INCREF(op->defaults_tuple);
    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
    Py_INCREF(op->defaults_kwdict);
    #else
    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
    if (unlikely(!op->defaults_tuple)) result = -1;
    else {
        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
        if (unlikely(!op->defaults_kwdict)) result = -1;
    }
    #endif
    Py_DECREF(res);
    return result;
}
static int
__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
    CYTHON_UNUSED_VAR(context);
    if (!value) {
        value = Py_None;
    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__defaults__ must be set to a tuple object");
        return -1;
    }
    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
                 "currently affect the values used in function calls", 1);
    Py_INCREF(value);
    __Pyx_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},
    {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
    {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
    {"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
    {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
#if CYTHON_METH_FASTCALL
#if CYTHON_BACKPORT_VECTORCALL || 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
    op->func_dict = NULL;
    op->func_name = NULL;
    Py_INCREF(qualname);
    op->func_qualname = qualname;
    op->func_doc = NULL;
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
    op->func_classobj = NULL;
#else
    ((PyCMethodObject*)op)->mm_class = NULL;
#endif
    op->func_globals = globals;
    Py_INCREF(op->func_globals);
    Py_XINCREF(code);
    op->func_code = code;
    op->defaults = NULL;
    op->defaults_tuple = NULL;
    op->defaults_kwdict = NULL;
    op->defaults_getter = NULL;
    op->func_annotations = NULL;
    op->func_is_coroutine = NULL;
#if CYTHON_METH_FASTCALL
    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
    case METH_NOARGS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
        break;
    case METH_O:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
        break;
    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
        break;
    case METH_FASTCALL | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
        break;
    case METH_VARARGS | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = NULL;
        break;
    default:
        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
        Py_DECREF(op);
        return NULL;
    }
#endif
    return (PyObject *) op;
}
static int
__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
{
    Py_CLEAR(m->func_closure);
#if CYTHON_COMPILING_IN_LIMITED_API
    Py_CLEAR(m->func);
#else
    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
#endif
    Py_CLEAR(m->func_dict);
    Py_CLEAR(m->func_name);
    Py_CLEAR(m->func_qualname);
    Py_CLEAR(m->func_doc);
    Py_CLEAR(m->func_globals);
    Py_CLEAR(m->func_code);
#if !CYTHON_COMPILING_IN_LIMITED_API
#if PY_VERSION_HEX < 0x030900B1
    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
#else
    {
        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
        ((PyCMethodObject *) (m))->mm_class = NULL;
        Py_XDECREF(cls);
    }
#endif
#endif
    Py_CLEAR(m->defaults_tuple);
    Py_CLEAR(m->defaults_kwdict);
    Py_CLEAR(m->func_annotations);
    Py_CLEAR(m->func_is_coroutine);
    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
    Py_VISIT(m->func_dict);
    __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 || CYTHON_BACKPORT_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 || CYTHON_BACKPORT_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;
#if CYTHON_BACKPORT_VECTORCALL
    Py_ssize_t nargs = (Py_ssize_t)nargsf;
#else
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
#endif
    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;
#if CYTHON_BACKPORT_VECTORCALL
    Py_ssize_t nargs = (Py_ssize_t)nargsf;
#else
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
#endif
    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;
#if CYTHON_BACKPORT_VECTORCALL
    Py_ssize_t nargs = (Py_ssize_t)nargsf;
#else
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
#endif
    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);
#if CYTHON_BACKPORT_VECTORCALL
    Py_ssize_t nargs = (Py_ssize_t)nargsf;
#else
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
#endif
    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_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, 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 >= 0x030A0000
    Py_TPFLAGS_IMMUTABLETYPE |
#endif
    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;
}

/* PyObjectVectorCallKwBuilder */
#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

/* PyObjectVectorCallMethodKwBuilder */
#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000
static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames) {
    PyObject *result;
    PyObject *obj = PyObject_GetAttr(args[0], name);
    if (unlikely(!obj))
        return NULL;
    result = __Pyx_Object_Vectorcall_CallFromBuilder(obj, args+1, nargsf-1, kwnames);
    Py_DECREF(obj);
    return result;
}
#endif

/* GetAttr3 */
#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
        return NULL;
    __Pyx_PyErr_Clear();
    Py_INCREF(d);
    return d;
}
#endif
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
    PyObject *r;
#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
    int res = PyObject_GetOptionalAttr(o, n, &r);
    return (res != 0) ? r : __Pyx_NewRef(d);
#else
  #if CYTHON_USE_TYPE_SLOTS
    if (likely(PyUnicode_Check(n))) {
        r = __Pyx_PyObject_GetAttrStrNoError(o, n);
        if (unlikely(!r) && likely(!PyErr_Occurred())) {
            r = __Pyx_NewRef(d);
        }
        return r;
    }
  #endif
    r = PyObject_GetAttr(o, n);
    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
#endif
}

/* RaiseUnexpectedTypeError */
static int
__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
{
    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
                 expected, obj_type_name);
    __Pyx_DECREF_TypeName(obj_type_name);
    return 0;
}

/* Import */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *module = 0;
    PyObject *empty_dict = 0;
    PyObject *empty_list = 0;
    empty_dict = PyDict_New();
    if (unlikely(!empty_dict))
        goto bad;
    if (level == -1) {
        const char* package_sep = strchr(__Pyx_MODULE_NAME, '.');
        if (package_sep != (0)) {
            module = PyImport_ImportModuleLevelObject(
                name, __pyx_mstate_global->__pyx_d, 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, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level);
    }
bad:
    Py_XDECREF(empty_dict);
    Py_XDECREF(empty_list);
    return module;
}

/* ImportFrom */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
        const char* module_name_str = 0;
        PyObject* module_name = 0;
        PyObject* module_dot = 0;
        PyObject* full_name = 0;
        PyErr_Clear();
        module_name_str = PyModule_GetName(module);
        if (unlikely(!module_name_str)) { goto modbad; }
        module_name = PyUnicode_FromString(module_name_str);
        if (unlikely(!module_name)) { goto modbad; }
        module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__6);
        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;
}

/* HasAttr */
#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

/* CallNextTpDealloc */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) {
    PyTypeObject* type = Py_TYPE(obj);
    destructor tp_dealloc = NULL;
    while (type && __Pyx_PyType_GetSlot(type, tp_dealloc, destructor) != current_tp_dealloc)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    while (type && (tp_dealloc = __Pyx_PyType_GetSlot(type, tp_dealloc, destructor)) == current_tp_dealloc)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    if (type)
        tp_dealloc(obj);
}

/* CallNextTpTraverse */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) {
    PyTypeObject* type = Py_TYPE(obj);
    traverseproc tp_traverse = NULL;
    while (type && __Pyx_PyType_GetSlot(type, tp_traverse, traverseproc) != current_tp_traverse)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    while (type && (tp_traverse = __Pyx_PyType_GetSlot(type, tp_traverse, traverseproc)) == current_tp_traverse)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    if (type && tp_traverse)
        return tp_traverse(obj, v, a);
    return 0;
}

/* CallNextTpClear */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) {
    PyTypeObject* type = Py_TYPE(obj);
    inquiry tp_clear = NULL;
    while (type && __Pyx_PyType_GetSlot(type, tp_clear, inquiry) != current_tp_clear)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    while (type && (tp_clear = __Pyx_PyType_GetSlot(type, tp_clear, inquiry)) == current_tp_clear)
        type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*);
    if (type && tp_clear)
        tp_clear(obj);
}

/* TypeImport */
#ifndef __PYX_HAVE_RT_ImportType_3_1_4
#define __PYX_HAVE_RT_ImportType_3_1_4
static PyTypeObject *__Pyx_ImportType_3_1_4(PyObject *module, const char *module_name, const char *class_name,
    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_4 check_size)
{
    PyObject *result = 0;
    Py_ssize_t basicsize;
    Py_ssize_t itemsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
    PyObject *py_itemsize;
#endif
    result = PyObject_GetAttrString(module, class_name);
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%.200s.%.200s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
    itemsize = ((PyTypeObject *)result)->tp_itemsize;
#else
    if (size == 0) {
        return (PyTypeObject *)result;
    }
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
    if (!py_itemsize)
        goto bad;
    itemsize = PyLong_AsSsize_t(py_itemsize);
    Py_DECREF(py_itemsize);
    py_itemsize = 0;
    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if (itemsize) {
        if (size % alignment) {
            alignment = size % alignment;
        }
        if (itemsize < (Py_ssize_t)alignment)
            itemsize = (Py_ssize_t)alignment;
    }
    if ((size_t)(basicsize + itemsize) < size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s size changed, may indicate binary incompatibility. "
            "Expected %zd from C header, got %zd from PyObject",
            module_name, class_name, size, basicsize+itemsize);
        goto bad;
    }
    if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_4 &&
            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s size changed, may indicate binary incompatibility. "
            "Expected %zd from C header, got %zd-%zd from PyObject",
            module_name, class_name, size, basicsize, basicsize+itemsize);
        goto bad;
    }
    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_4 && (size_t)basicsize > size) {
        if (PyErr_WarnFormat(NULL, 0,
                "%.200s.%.200s size changed, may indicate binary incompatibility. "
                "Expected %zd from C header, got %zd from PyObject",
                module_name, class_name, size, basicsize) < 0) {
            goto bad;
        }
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(result);
    return NULL;
}
#endif

/* ValidateBasesTuple */
#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
    Py_ssize_t i, n;
#if CYTHON_ASSUME_SAFE_SIZE
    n = PyTuple_GET_SIZE(bases);
#else
    n = PyTuple_Size(bases);
    if (unlikely(n < 0)) return -1;
#endif
    for (i = 1; i < n; i++)
    {
        PyTypeObject *b;
#if CYTHON_AVOID_BORROWED_REFS
        PyObject *b0 = PySequence_GetItem(bases, i);
        if (!b0) return -1;
#elif CYTHON_ASSUME_SAFE_MACROS
        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
#else
        PyObject *b0 = PyTuple_GetItem(bases, i);
        if (!b0) return -1;
#endif
        b = (PyTypeObject*) b0;
        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
        {
            __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b);
            PyErr_Format(PyExc_TypeError,
                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
            __Pyx_DECREF_TypeName(b_name);
#if CYTHON_AVOID_BORROWED_REFS
            Py_DECREF(b0);
#endif
            return -1;
        }
        if (dictoffset == 0)
        {
            Py_ssize_t b_dictoffset = 0;
#if CYTHON_USE_TYPE_SLOTS
            b_dictoffset = b->tp_dictoffset;
#else
            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
            if (!py_b_dictoffset) goto dictoffset_return;
            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
            Py_DECREF(py_b_dictoffset);
            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
#endif
            if (b_dictoffset) {
                {
                    __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b);
                    PyErr_Format(PyExc_TypeError,
                        "extension type '%.200s' has no __dict__ slot, "
                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
                        "either add 'cdef dict __dict__' to the extension type "
                        "or add '__slots__ = [...]' to the base type",
                        type_name, b_name);
                    __Pyx_DECREF_TypeName(b_name);
                }
#if !CYTHON_USE_TYPE_SLOTS
              dictoffset_return:
#endif
#if CYTHON_AVOID_BORROWED_REFS
                Py_DECREF(b0);
#endif
                return -1;
            }
        }
#if CYTHON_AVOID_BORROWED_REFS
        Py_DECREF(b0);
#endif
    }
    return 0;
}
#endif

/* PyType_Ready */
CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) {
    while (t) {
        PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
        if (bases) {
            return 1;
        }
        t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*);
    }
    return 0;
}
static int __Pyx_PyType_Ready(PyTypeObject *t) {
#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION)
    (void)__Pyx_PyObject_CallMethod0;
#if CYTHON_USE_TYPE_SPECS
    (void)__Pyx_validate_bases_tuple;
#endif
    return PyType_Ready(t);
#else
    int r;
    if (!__Pyx_PyType_HasMultipleInheritance(t)) {
        return PyType_Ready(t);
    }
    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
        return -1;
#if !defined(PYSTON_MAJOR_VERSION)
    {
        int gc_was_enabled;
    #if PY_VERSION_HEX >= 0x030A00b1
        gc_was_enabled = PyGC_Disable();
        (void)__Pyx_PyObject_CallMethod0;
    #else
        PyObject *ret, *py_status;
        PyObject *gc = NULL;
        #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\
                !CYTHON_COMPILING_IN_GRAAL
        gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc);
        #endif
        if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc);
        if (unlikely(!gc)) return -1;
        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled);
        if (unlikely(!py_status)) {
            Py_DECREF(gc);
            return -1;
        }
        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
        Py_DECREF(py_status);
        if (gc_was_enabled > 0) {
            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable);
            if (unlikely(!ret)) {
                Py_DECREF(gc);
                return -1;
            }
            Py_DECREF(ret);
        } else if (unlikely(gc_was_enabled == -1)) {
            Py_DECREF(gc);
            return -1;
        }
    #endif
        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
#if PY_VERSION_HEX >= 0x030A0000
        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
#endif
#else
        (void)__Pyx_PyObject_CallMethod0;
#endif
    r = PyType_Ready(t);
#if !defined(PYSTON_MAJOR_VERSION)
        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
    #if PY_VERSION_HEX >= 0x030A00b1
        if (gc_was_enabled)
            PyGC_Enable();
    #else
        if (gc_was_enabled) {
            PyObject *tp, *v, *tb;
            PyErr_Fetch(&tp, &v, &tb);
            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable);
            if (likely(ret || r == -1)) {
                Py_XDECREF(ret);
                PyErr_Restore(tp, v, tb);
            } else {
                Py_XDECREF(tp);
                Py_XDECREF(v);
                Py_XDECREF(tb);
                r = -1;
            }
        }
        Py_DECREF(gc);
    #endif
    }
#endif
    return r;
#endif
}

/* DelItemOnTypeDict */
static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) {
    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_DelItem(tp_dict, k);
    if (likely(!result)) PyType_Modified(tp);
    return result;
}

/* SetupReduce */
static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
  int ret;
  PyObject *name_attr;
  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name);
  if (likely(name_attr)) {
      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
  } else {
      ret = -1;
  }
  if (unlikely(ret < 0)) {
      PyErr_Clear();
      ret = 0;
  }
  Py_XDECREF(name_attr);
  return ret;
}
static int __Pyx_setup_reduce(PyObject* type_obj) {
    int ret = 0;
    PyObject *object_reduce = NULL;
    PyObject *object_getstate = NULL;
    PyObject *object_reduce_ex = NULL;
    PyObject *reduce = NULL;
    PyObject *reduce_ex = NULL;
    PyObject *reduce_cython = NULL;
    PyObject *setstate = NULL;
    PyObject *setstate_cython = NULL;
    PyObject *getstate = NULL;
#if CYTHON_USE_PYTYPE_LOOKUP
    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_getstate);
#else
    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate);
    if (!getstate && PyErr_Occurred()) {
        goto __PYX_BAD;
    }
#endif
    if (getstate) {
#if CYTHON_USE_PYTYPE_LOOKUP
        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate);
#else
        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate);
        if (!object_getstate && PyErr_Occurred()) {
            goto __PYX_BAD;
        }
#endif
        if (object_getstate != getstate) {
            goto __PYX_GOOD;
        }
    }
#if CYTHON_USE_PYTYPE_LOOKUP
    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
#else
    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
#endif
    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
    if (reduce_ex == object_reduce_ex) {
#if CYTHON_USE_PYTYPE_LOOKUP
        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD;
#else
        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD;
#endif
        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) {
            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython);
            if (likely(reduce_cython)) {
                ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
                ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
            } else if (reduce == object_reduce || PyErr_Occurred()) {
                goto __PYX_BAD;
            }
            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate);
            if (!setstate) PyErr_Clear();
            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) {
                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython);
                if (likely(setstate_cython)) {
                    ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
                    ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
                } else if (!setstate || PyErr_Occurred()) {
                    goto __PYX_BAD;
                }
            }
            PyType_Modified((PyTypeObject*)type_obj);
        }
    }
    goto __PYX_GOOD;
__PYX_BAD:
    if (!PyErr_Occurred()) {
        __Pyx_TypeName type_obj_name =
            __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj);
        PyErr_Format(PyExc_RuntimeError,
            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
        __Pyx_DECREF_TypeName(type_obj_name);
    }
    ret = -1;
__PYX_GOOD:
#if !CYTHON_USE_PYTYPE_LOOKUP
    Py_XDECREF(object_reduce);
    Py_XDECREF(object_reduce_ex);
    Py_XDECREF(object_getstate);
    Py_XDECREF(getstate);
#endif
    Py_XDECREF(reduce);
    Py_XDECREF(reduce_ex);
    Py_XDECREF(reduce_cython);
    Py_XDECREF(setstate);
    Py_XDECREF(setstate_cython);
    return ret;
}

/* GetVTable */
static void* __Pyx_GetVtable(PyTypeObject *type) {
    void* ptr;
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable);
#else
    PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable);
#endif
    if (!ob)
        goto bad;
    ptr = PyCapsule_GetPointer(ob, 0);
    if (!ptr && !PyErr_Occurred())
        PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
    Py_DECREF(ob);
    return ptr;
bad:
    Py_XDECREF(ob);
    return NULL;
}

/* ListPack */
static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) {
    va_list va;
    PyObject *l = PyList_New(n);
    va_start(va, n);
    if (unlikely(!l)) goto end;
    for (Py_ssize_t i=0; i<n; ++i) {
        PyObject *arg = va_arg(va, PyObject*);
        Py_INCREF(arg);
        if (__Pyx_PyList_SET_ITEM(l, i, arg) != (0)) {
            Py_CLEAR(l);
            goto end;
        }
    }
    end:
    va_end(va);
    return l;
}

/* GetAttr */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
#if CYTHON_USE_TYPE_SLOTS
    if (likely(PyUnicode_Check(n)))
        return __Pyx_PyObject_GetAttrStr(o, n);
#endif
    return PyObject_GetAttr(o, n);
}

/* Globals */
static PyObject* __Pyx_Globals(void) {
    return __Pyx_NewRef(__pyx_mstate_global->__pyx_d);
}

/* ImportDottedModule */
static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) {
    PyObject *partial_name = NULL, *slice = NULL, *sep = NULL;
    Py_ssize_t size;
    if (unlikely(PyErr_Occurred())) {
        PyErr_Clear();
    }
#if CYTHON_ASSUME_SAFE_SIZE
    size = PyTuple_GET_SIZE(parts_tuple);
#else
    size = PyTuple_Size(parts_tuple);
    if (size < 0) goto bad;
#endif
    if (likely(size == count)) {
        partial_name = name;
    } else {
        slice = PySequence_GetSlice(parts_tuple, 0, count);
        if (unlikely(!slice))
            goto bad;
        sep = PyUnicode_FromStringAndSize(".", 1);
        if (unlikely(!sep))
            goto bad;
        partial_name = PyUnicode_Join(sep, slice);
    }
    PyErr_Format(
        PyExc_ModuleNotFoundError,
        "No module named '%U'", partial_name);
bad:
    Py_XDECREF(sep);
    Py_XDECREF(slice);
    Py_XDECREF(partial_name);
    return NULL;
}
static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) {
    PyObject *imported_module;
#if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400) ||\
        CYTHON_COMPILING_IN_GRAAL
    PyObject *modules = PyImport_GetModuleDict();
    if (unlikely(!modules))
        return NULL;
    imported_module = __Pyx_PyDict_GetItemStr(modules, name);
    Py_XINCREF(imported_module);
#else
    imported_module = PyImport_GetModule(name);
#endif
    return imported_module;
}
static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) {
    Py_ssize_t i, nparts;
#if CYTHON_ASSUME_SAFE_SIZE
    nparts = PyTuple_GET_SIZE(parts_tuple);
#else
    nparts = PyTuple_Size(parts_tuple);
    if (nparts < 0) return NULL;
#endif
    for (i=1; i < nparts && module; i++) {
        PyObject *part, *submodule;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        part = PyTuple_GET_ITEM(parts_tuple, i);
#else
        part = __Pyx_PySequence_ITEM(parts_tuple, i);
        if (!part) return NULL;
#endif
        submodule = __Pyx_PyObject_GetAttrStrNoError(module, part);
#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
        Py_DECREF(part);
#endif
        Py_DECREF(module);
        module = submodule;
    }
    if (unlikely(!module)) {
        return __Pyx__ImportDottedModule_Error(name, parts_tuple, i);
    }
    return module;
}
static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
    PyObject *imported_module;
    PyObject *module = __Pyx_Import(name, NULL, 0);
    if (!parts_tuple || unlikely(!module))
        return module;
    imported_module = __Pyx__ImportDottedModule_Lookup(name);
    if (likely(imported_module)) {
        Py_DECREF(module);
        return imported_module;
    }
    PyErr_Clear();
    return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple);
}
static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
#if CYTHON_COMPILING_IN_CPYTHON
    PyObject *module = __Pyx__ImportDottedModule_Lookup(name);
    if (likely(module)) {
        PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_mstate_global->__pyx_n_u_spec);
        if (likely(spec)) {
            PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_mstate_global->__pyx_n_u_initializing);
            if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) {
                Py_DECREF(spec);
                spec = NULL;
            }
            Py_XDECREF(unsafe);
        }
        if (likely(!spec)) {
            PyErr_Clear();
            return module;
        }
        Py_DECREF(spec);
        Py_DECREF(module);
    } else if (PyErr_Occurred()) {
        PyErr_Clear();
    }
#endif
    return __Pyx__ImportDottedModule(name, parts_tuple);
}

/* Py3UpdateBases */
static PyObject*
__Pyx_PEP560_update_bases(PyObject *bases)
{
    Py_ssize_t i, j, size_bases;
    PyObject *base = NULL, *meth, *new_base, *result, *new_bases = NULL;
#if CYTHON_ASSUME_SAFE_SIZE
    size_bases = PyTuple_GET_SIZE(bases);
#else
    size_bases = PyTuple_Size(bases);
    if (size_bases < 0) return NULL;
#endif
    for (i = 0; i < size_bases; i++) {
#if CYTHON_AVOID_BORROWED_REFS
        Py_CLEAR(base);
#endif
#if CYTHON_ASSUME_SAFE_MACROS
        base = PyTuple_GET_ITEM(bases, i);
#else
        base = PyTuple_GetItem(bases, i);
        if (!base) goto error;
#endif
#if CYTHON_AVOID_BORROWED_REFS
        Py_INCREF(base);
#endif
        if (PyType_Check(base)) {
            if (new_bases) {
                if (PyList_Append(new_bases, base) < 0) {
                    goto error;
                }
            }
            continue;
        }
        meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_mstate_global->__pyx_n_u_mro_entries);
        if (!meth && PyErr_Occurred()) {
            goto error;
        }
        if (!meth) {
            if (new_bases) {
                if (PyList_Append(new_bases, base) < 0) {
                    goto error;
                }
            }
            continue;
        }
        new_base = __Pyx_PyObject_CallOneArg(meth, bases);
        Py_DECREF(meth);
        if (!new_base) {
            goto error;
        }
        if (!PyTuple_Check(new_base)) {
            PyErr_SetString(PyExc_TypeError,
                            "__mro_entries__ must return a tuple");
            Py_DECREF(new_base);
            goto error;
        }
        if (!new_bases) {
            if (!(new_bases = PyList_New(i))) {
                goto error;
            }
            for (j = 0; j < i; j++) {
                PyObject *base_from_list;
#if CYTHON_ASSUME_SAFE_MACROS
                base_from_list = PyTuple_GET_ITEM(bases, j);
                PyList_SET_ITEM(new_bases, j, base_from_list);
                Py_INCREF(base_from_list);
#else
                base_from_list = PyTuple_GetItem(bases, j);
                if (!base_from_list) goto error;
                Py_INCREF(base_from_list);
                if (PyList_SetItem(new_bases, j, base_from_list) < 0) goto error;
#endif
            }
        }
#if CYTHON_ASSUME_SAFE_SIZE
        j = PyList_GET_SIZE(new_bases);
#else
        j = PyList_Size(new_bases);
        if (j < 0) goto error;
#endif
        if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {
            goto error;
        }
        Py_DECREF(new_base);
    }
    if (!new_bases) {
        Py_INCREF(bases);
        return bases;
    }
    result = PyList_AsTuple(new_bases);
    Py_DECREF(new_bases);
#if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(base);
#endif
    return result;
error:
    Py_XDECREF(new_bases);
#if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(base);
#endif
    return NULL;
}

/* CalculateMetaclass */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
    Py_ssize_t i, nbases;
#if CYTHON_ASSUME_SAFE_SIZE
    nbases = PyTuple_GET_SIZE(bases);
#else
    nbases = PyTuple_Size(bases);
    if (nbases < 0) return NULL;
#endif
    for (i=0; i < nbases; i++) {
        PyTypeObject *tmptype;
#if CYTHON_ASSUME_SAFE_MACROS
        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
#else
        PyObject *tmp = PyTuple_GetItem(bases, i);
        if (!tmp) return NULL;
#endif
        tmptype = Py_TYPE(tmp);
        if (!metaclass) {
            metaclass = tmptype;
            continue;
        }
        if (PyType_IsSubtype(metaclass, tmptype))
            continue;
        if (PyType_IsSubtype(tmptype, metaclass)) {
            metaclass = tmptype;
            continue;
        }
        PyErr_SetString(PyExc_TypeError,
                        "metaclass conflict: "
                        "the metaclass of a derived class "
                        "must be a (non-strict) subclass "
                        "of the metaclasses of all its bases");
        return NULL;
    }
    if (!metaclass) {
        metaclass = &PyType_Type;
    }
    Py_INCREF((PyObject*) metaclass);
    return (PyObject*) metaclass;
}

/* PyObjectCall2Args */
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
    PyObject *args[3] = {NULL, arg1, arg2};
    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
}

/* PyObjectLookupSpecial */
#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) {
    PyObject *res;
    PyTypeObject *tp = Py_TYPE(obj);
    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

/* Py3ClassCreate */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
    PyObject *ns;
    if (metaclass) {
        PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_mstate_global->__pyx_n_u_prepare);
        if (prep) {
            PyObject *pargs[3] = {NULL, name, bases};
            ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
            Py_DECREF(prep);
        } else {
            if (unlikely(PyErr_Occurred()))
                return NULL;
            ns = PyDict_New();
        }
    } else {
        ns = PyDict_New();
    }
    if (unlikely(!ns))
        return NULL;
    if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_module_2, modname) < 0)) goto bad;
    if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_qualname, qualname) < 0)) goto bad;
    if (unlikely(doc && PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_doc, doc) < 0)) goto bad;
    return ns;
bad:
    Py_DECREF(ns);
    return NULL;
}
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                      PyObject *dict, PyObject *mkw,
                                      int calculate_metaclass, int allow_py2_metaclass) {
    PyObject *result;
    PyObject *owned_metaclass = NULL;
    PyObject *margs[4] = {NULL, name, bases, dict};
    if (allow_py2_metaclass) {
        owned_metaclass = PyObject_GetItem(dict, __pyx_mstate_global->__pyx_n_u_metaclass);
        if (owned_metaclass) {
            metaclass = owned_metaclass;
        } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
            PyErr_Clear();
        } else {
            return NULL;
        }
    }
    if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
        metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
        Py_XDECREF(owned_metaclass);
        if (unlikely(!metaclass))
            return NULL;
        owned_metaclass = metaclass;
    }
    result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
    Py_XDECREF(owned_metaclass);
    return result;
}

/* GetNameInClass */
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) {
    PyObject *result;
    PyObject *dict;
    assert(PyType_Check(nmspace));
#if CYTHON_USE_TYPE_SLOTS
    dict = ((PyTypeObject*)nmspace)->tp_dict;
    Py_XINCREF(dict);
#else
    dict = PyObject_GetAttr(nmspace, __pyx_mstate_global->__pyx_n_u_dict);
#endif
    if (likely(dict)) {
        result = PyObject_GetItem(dict, name);
        Py_DECREF(dict);
        if (result) {
            return result;
        }
    }
    PyErr_Clear();
    __Pyx_GetModuleGlobalNameUncached(result, name);
    return result;
}

/* CLineInTraceback */
#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
    PyObject *use_cline;
    PyObject *ptype, *pvalue, *ptraceback;
#if CYTHON_COMPILING_IN_CPYTHON
    PyObject **cython_runtime_dict;
#endif
    CYTHON_MAYBE_UNUSED_VAR(tstate);
    if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) {
        return c_line;
    }
    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
#if CYTHON_COMPILING_IN_CPYTHON
    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime);
    if (likely(cython_runtime_dict)) {
        __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict);
        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
            use_cline, *cython_runtime_dict,
            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback))
        Py_XINCREF(use_cline);
        __Pyx_END_CRITICAL_SECTION();
    } else
#endif
    {
      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback);
      if (use_cline_obj) {
        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
        Py_INCREF(use_cline);
        Py_DECREF(use_cline_obj);
      } else {
        PyErr_Clear();
        use_cline = NULL;
      }
    }
    if (!use_cline) {
        c_line = 0;
        (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False);
    }
    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
        c_line = 0;
    }
    Py_XDECREF(use_cline);
    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
    return c_line;
}
#endif

/* CodeObjectCache */
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static __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) {
        (void) __pyx_cfilenm;
        (void) __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;
        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

/* CIntFromPyVerify */
#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(enum NetworKit::ApproxCloseness::ClosenessType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ApproxCloseness::ClosenessType neg_one = (enum NetworKit::ApproxCloseness::ClosenessType) -1, const_zero = (enum NetworKit::ApproxCloseness::ClosenessType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::ApproxCloseness::ClosenessType) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::ApproxCloseness::ClosenessType),
                                     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(enum NetworKit::ApproxCloseness::ClosenessType));
        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
    }
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::ApproxCloseness::ClosenessType __Pyx_PyLong_As_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ApproxCloseness::ClosenessType neg_one = (enum NetworKit::ApproxCloseness::ClosenessType) -1, const_zero = (enum NetworKit::ApproxCloseness::ClosenessType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::ApproxCloseness::ClosenessType val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::ApproxCloseness::ClosenessType) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_ApproxCloseness_3a__3a_ClosenessType(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(enum NetworKit::ApproxCloseness::ClosenessType, __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(enum NetworKit::ApproxCloseness::ClosenessType) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((((enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, 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(enum NetworKit::ApproxCloseness::ClosenessType) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)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 (enum NetworKit::ApproxCloseness::ClosenessType) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ApproxCloseness::ClosenessType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ApproxCloseness::ClosenessType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, __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(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((enum NetworKit::ApproxCloseness::ClosenessType)-1)*(((((enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) ((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((enum NetworKit::ApproxCloseness::ClosenessType)-1)*(((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) ((((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, 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(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) (((enum NetworKit::ApproxCloseness::ClosenessType)-1)*(((((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ApproxCloseness::ClosenessType) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ApproxCloseness::ClosenessType, 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(enum NetworKit::ApproxCloseness::ClosenessType) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ApproxCloseness::ClosenessType) ((((((((((enum NetworKit::ApproxCloseness::ClosenessType)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ApproxCloseness::ClosenessType)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ApproxCloseness::ClosenessType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ApproxCloseness::ClosenessType) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ApproxCloseness::ClosenessType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::ApproxCloseness::ClosenessType 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::ApproxCloseness::ClosenessType) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::ApproxCloseness::ClosenessType) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::ApproxCloseness::ClosenessType");
    return (enum NetworKit::ApproxCloseness::ClosenessType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::ApproxCloseness::ClosenessType");
    return (enum NetworKit::ApproxCloseness::ClosenessType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE uint64_t __Pyx_PyLong_As_uint64_t(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        uint64_t val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (uint64_t) -1;
        val = __Pyx_PyLong_As_uint64_t(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(uint64_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_DigitCount(x)) {
                case 2:
                    if ((8 * sizeof(uint64_t) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT)) {
                            return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(uint64_t) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT)) {
                            return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(uint64_t) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) >= 4 * PyLong_SHIFT)) {
                            return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
                        }
                    }
                    break;
            }
        }
#endif
#if CYTHON_COMPILING_IN_CPYTHON && 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 (uint64_t) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(uint64_t) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(uint64_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                case -2:
                    if ((8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                            return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(uint64_t) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                            return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                            return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(uint64_t) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                            return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                            return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(uint64_t) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                            return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(uint64_t) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(uint64_t) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        uint64_t val;
        int ret = -1;
#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
        if (unlikely(bytes_copied == -1)) {
        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
            goto raise_overflow;
        } else {
            ret = 0;
        }
#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
        int one = 1; int is_little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&val;
        ret = _PyLong_AsByteArray((PyLongObject *)x,
                                    bytes, sizeof(val),
                                    is_little, !is_unsigned);
#else
        PyObject *v;
        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
        int bits, remaining_bits, is_negative = 0;
        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
        if (likely(PyLong_CheckExact(x))) {
            v = __Pyx_NewRef(x);
        } else {
            v = PyNumber_Long(x);
            if (unlikely(!v)) return (uint64_t) -1;
            assert(PyLong_CheckExact(v));
        }
        {
            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
            if (unlikely(result < 0)) {
                Py_DECREF(v);
                return (uint64_t) -1;
            }
            is_negative = result == 1;
        }
        if (is_unsigned && unlikely(is_negative)) {
            Py_DECREF(v);
            goto raise_neg_overflow;
        } else if (is_negative) {
            stepval = PyNumber_Invert(v);
            Py_DECREF(v);
            if (unlikely(!stepval))
                return (uint64_t) -1;
        } else {
            stepval = v;
        }
        v = NULL;
        val = (uint64_t) 0;
        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
        for (bits = 0; bits < (int) sizeof(uint64_t) * 8 - chunk_size; bits += chunk_size) {
            PyObject *tmp, *digit;
            long idigit;
            digit = PyNumber_And(stepval, mask);
            if (unlikely(!digit)) goto done;
            idigit = PyLong_AsLong(digit);
            Py_DECREF(digit);
            if (unlikely(idigit < 0)) goto done;
            val |= ((uint64_t) idigit) << bits;
            tmp = PyNumber_Rshift(stepval, shift);
            if (unlikely(!tmp)) goto done;
            Py_DECREF(stepval); stepval = tmp;
        }
        Py_DECREF(shift); shift = NULL;
        Py_DECREF(mask); mask = NULL;
        {
            long idigit = PyLong_AsLong(stepval);
            if (unlikely(idigit < 0)) goto done;
            remaining_bits = ((int) sizeof(uint64_t) * 8) - bits - (is_unsigned ? 0 : 1);
            if (unlikely(idigit >= (1L << remaining_bits)))
                goto raise_overflow;
            val |= ((uint64_t) idigit) << bits;
        }
        if (!is_unsigned) {
            if (unlikely(val & (((uint64_t) 1) << (sizeof(uint64_t) * 8 - 1))))
                goto raise_overflow;
            if (is_negative)
                val = ~val;
        }
        ret = 0;
    done:
        Py_XDECREF(shift);
        Py_XDECREF(mask);
        Py_XDECREF(stepval);
#endif
        if (unlikely(ret))
            return (uint64_t) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to uint64_t");
    return (uint64_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to uint64_t");
    return (uint64_t) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(enum NetworKit::GedWalk::BoundStrategy value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::GedWalk::BoundStrategy neg_one = (enum NetworKit::GedWalk::BoundStrategy) -1, const_zero = (enum NetworKit::GedWalk::BoundStrategy) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::GedWalk::BoundStrategy) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::GedWalk::BoundStrategy),
                                     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(enum NetworKit::GedWalk::BoundStrategy));
        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
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(enum NetworKit::GedWalk::GreedyStrategy value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::GedWalk::GreedyStrategy neg_one = (enum NetworKit::GedWalk::GreedyStrategy) -1, const_zero = (enum NetworKit::GedWalk::GreedyStrategy) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::GedWalk::GreedyStrategy) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::GedWalk::GreedyStrategy),
                                     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(enum NetworKit::GedWalk::GreedyStrategy));
        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
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_EdgeDirection(enum NetworKit::EdgeDirection value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::EdgeDirection neg_one = (enum NetworKit::EdgeDirection) -1, const_zero = (enum NetworKit::EdgeDirection) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::EdgeDirection) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::EdgeDirection) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::EdgeDirection) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::EdgeDirection) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::EdgeDirection) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::EdgeDirection),
                                     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(enum NetworKit::EdgeDirection));
        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
    }
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::EdgeDirection __Pyx_PyLong_As_enum__NetworKit_3a__3a_EdgeDirection(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::EdgeDirection neg_one = (enum NetworKit::EdgeDirection) -1, const_zero = (enum NetworKit::EdgeDirection) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::EdgeDirection val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::EdgeDirection) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_EdgeDirection(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(enum NetworKit::EdgeDirection, __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(enum NetworKit::EdgeDirection) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((((enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((((((enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, 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(enum NetworKit::EdgeDirection) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((((((((enum NetworKit::EdgeDirection)digits[3]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)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 (enum NetworKit::EdgeDirection) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::EdgeDirection) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::EdgeDirection, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::EdgeDirection) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::EdgeDirection, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, __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(enum NetworKit::EdgeDirection) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((enum NetworKit::EdgeDirection)-1)*(((((enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) ((((((enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((enum NetworKit::EdgeDirection)-1)*(((((((enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) ((((((((enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, 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(enum NetworKit::EdgeDirection) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) (((enum NetworKit::EdgeDirection)-1)*(((((((((enum NetworKit::EdgeDirection)digits[3]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::EdgeDirection) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::EdgeDirection, 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(enum NetworKit::EdgeDirection) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::EdgeDirection) ((((((((((enum NetworKit::EdgeDirection)digits[3]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[2]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[1]) << PyLong_SHIFT) | (enum NetworKit::EdgeDirection)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::EdgeDirection) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::EdgeDirection, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::EdgeDirection) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::EdgeDirection, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::EdgeDirection 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::EdgeDirection) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::EdgeDirection) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::EdgeDirection");
    return (enum NetworKit::EdgeDirection) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::EdgeDirection");
    return (enum NetworKit::EdgeDirection) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(enum NetworKit::PageRank::Norm value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::PageRank::Norm neg_one = (enum NetworKit::PageRank::Norm) -1, const_zero = (enum NetworKit::PageRank::Norm) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::PageRank::Norm) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::PageRank::Norm) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::PageRank::Norm) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::PageRank::Norm) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::PageRank::Norm) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::PageRank::Norm),
                                     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(enum NetworKit::PageRank::Norm));
        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
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(enum NetworKit::PageRank::SinkHandling value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::PageRank::SinkHandling neg_one = (enum NetworKit::PageRank::SinkHandling) -1, const_zero = (enum NetworKit::PageRank::SinkHandling) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::PageRank::SinkHandling) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::PageRank::SinkHandling),
                                     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(enum NetworKit::PageRank::SinkHandling));
        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
    }
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::PageRank::Norm __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::PageRank::Norm neg_one = (enum NetworKit::PageRank::Norm) -1, const_zero = (enum NetworKit::PageRank::Norm) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::PageRank::Norm val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::PageRank::Norm) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_Norm(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(enum NetworKit::PageRank::Norm, __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(enum NetworKit::PageRank::Norm) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((((enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((((((enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, 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(enum NetworKit::PageRank::Norm) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((((((((enum NetworKit::PageRank::Norm)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)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 (enum NetworKit::PageRank::Norm) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::PageRank::Norm) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::Norm, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::PageRank::Norm) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::Norm, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, __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(enum NetworKit::PageRank::Norm) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((enum NetworKit::PageRank::Norm)-1)*(((((enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) ((((((enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((enum NetworKit::PageRank::Norm)-1)*(((((((enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) ((((((((enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, 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(enum NetworKit::PageRank::Norm) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) (((enum NetworKit::PageRank::Norm)-1)*(((((((((enum NetworKit::PageRank::Norm)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::PageRank::Norm) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::Norm, 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(enum NetworKit::PageRank::Norm) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::Norm) ((((((((((enum NetworKit::PageRank::Norm)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::Norm)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::PageRank::Norm) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::Norm, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::PageRank::Norm) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::Norm, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::PageRank::Norm 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::PageRank::Norm) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::PageRank::Norm) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::PageRank::Norm");
    return (enum NetworKit::PageRank::Norm) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::PageRank::Norm");
    return (enum NetworKit::PageRank::Norm) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(enum NetworKit::ComplexPathAlgorithm::Mode value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ComplexPathAlgorithm::Mode neg_one = (enum NetworKit::ComplexPathAlgorithm::Mode) -1, const_zero = (enum NetworKit::ComplexPathAlgorithm::Mode) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::ComplexPathAlgorithm::Mode),
                                     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(enum NetworKit::ComplexPathAlgorithm::Mode));
        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
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_uint64_t(uint64_t value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(uint64_t) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(uint64_t) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(uint64_t) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(uint64_t),
                                     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(uint64_t));
        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
    }
}

/* 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))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        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))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        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 enum NetworKit::ClosenessVariant __Pyx_PyLong_As_enum__NetworKit_3a__3a_ClosenessVariant(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ClosenessVariant neg_one = (enum NetworKit::ClosenessVariant) -1, const_zero = (enum NetworKit::ClosenessVariant) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::ClosenessVariant val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::ClosenessVariant) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_ClosenessVariant(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(enum NetworKit::ClosenessVariant, __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(enum NetworKit::ClosenessVariant) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((((enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((((((enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, 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(enum NetworKit::ClosenessVariant) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((((((((enum NetworKit::ClosenessVariant)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)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 (enum NetworKit::ClosenessVariant) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::ClosenessVariant) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ClosenessVariant, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ClosenessVariant) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ClosenessVariant, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, __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(enum NetworKit::ClosenessVariant) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((enum NetworKit::ClosenessVariant)-1)*(((((enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) ((((((enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((enum NetworKit::ClosenessVariant)-1)*(((((((enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) ((((((((enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, 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(enum NetworKit::ClosenessVariant) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) (((enum NetworKit::ClosenessVariant)-1)*(((((((((enum NetworKit::ClosenessVariant)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ClosenessVariant) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ClosenessVariant, 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(enum NetworKit::ClosenessVariant) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ClosenessVariant) ((((((((((enum NetworKit::ClosenessVariant)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ClosenessVariant)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::ClosenessVariant) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ClosenessVariant, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ClosenessVariant) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ClosenessVariant, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::ClosenessVariant 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::ClosenessVariant) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::ClosenessVariant) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::ClosenessVariant");
    return (enum NetworKit::ClosenessVariant) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::ClosenessVariant");
    return (enum NetworKit::ClosenessVariant) -1;
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::GedWalk::BoundStrategy __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::GedWalk::BoundStrategy neg_one = (enum NetworKit::GedWalk::BoundStrategy) -1, const_zero = (enum NetworKit::GedWalk::BoundStrategy) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::GedWalk::BoundStrategy val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::GedWalk::BoundStrategy) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_BoundStrategy(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(enum NetworKit::GedWalk::BoundStrategy, __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(enum NetworKit::GedWalk::BoundStrategy) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((((enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((((((enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, 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(enum NetworKit::GedWalk::BoundStrategy) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((((((((enum NetworKit::GedWalk::BoundStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)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 (enum NetworKit::GedWalk::BoundStrategy) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::BoundStrategy, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::BoundStrategy, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, __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(enum NetworKit::GedWalk::BoundStrategy) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((enum NetworKit::GedWalk::BoundStrategy)-1)*(((((enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) ((((((enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((enum NetworKit::GedWalk::BoundStrategy)-1)*(((((((enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) ((((((((enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, 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(enum NetworKit::GedWalk::BoundStrategy) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) (((enum NetworKit::GedWalk::BoundStrategy)-1)*(((((((((enum NetworKit::GedWalk::BoundStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::BoundStrategy) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::BoundStrategy, 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(enum NetworKit::GedWalk::BoundStrategy) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::BoundStrategy) ((((((((((enum NetworKit::GedWalk::BoundStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::BoundStrategy)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::BoundStrategy, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::GedWalk::BoundStrategy) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::BoundStrategy, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::GedWalk::BoundStrategy 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::GedWalk::BoundStrategy) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::GedWalk::BoundStrategy) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::GedWalk::BoundStrategy");
    return (enum NetworKit::GedWalk::BoundStrategy) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::GedWalk::BoundStrategy");
    return (enum NetworKit::GedWalk::BoundStrategy) -1;
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::GedWalk::GreedyStrategy __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::GedWalk::GreedyStrategy neg_one = (enum NetworKit::GedWalk::GreedyStrategy) -1, const_zero = (enum NetworKit::GedWalk::GreedyStrategy) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::GedWalk::GreedyStrategy val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::GedWalk::GreedyStrategy) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_GedWalk_3a__3a_GreedyStrategy(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(enum NetworKit::GedWalk::GreedyStrategy, __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(enum NetworKit::GedWalk::GreedyStrategy) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((((enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((((((enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, 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(enum NetworKit::GedWalk::GreedyStrategy) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((((((((enum NetworKit::GedWalk::GreedyStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)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 (enum NetworKit::GedWalk::GreedyStrategy) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::GreedyStrategy, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::GreedyStrategy, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, __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(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((enum NetworKit::GedWalk::GreedyStrategy)-1)*(((((enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) ((((((enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((enum NetworKit::GedWalk::GreedyStrategy)-1)*(((((((enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) ((((((((enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, 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(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) (((enum NetworKit::GedWalk::GreedyStrategy)-1)*(((((((((enum NetworKit::GedWalk::GreedyStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::GedWalk::GreedyStrategy) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::GedWalk::GreedyStrategy, 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(enum NetworKit::GedWalk::GreedyStrategy) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::GedWalk::GreedyStrategy) ((((((((((enum NetworKit::GedWalk::GreedyStrategy)digits[3]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[2]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[1]) << PyLong_SHIFT) | (enum NetworKit::GedWalk::GreedyStrategy)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::GreedyStrategy, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::GedWalk::GreedyStrategy) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::GedWalk::GreedyStrategy, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::GedWalk::GreedyStrategy 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::GedWalk::GreedyStrategy) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::GedWalk::GreedyStrategy) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::GedWalk::GreedyStrategy");
    return (enum NetworKit::GedWalk::GreedyStrategy) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::GedWalk::GreedyStrategy");
    return (enum NetworKit::GedWalk::GreedyStrategy) -1;
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::PageRank::SinkHandling __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::PageRank::SinkHandling neg_one = (enum NetworKit::PageRank::SinkHandling) -1, const_zero = (enum NetworKit::PageRank::SinkHandling) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::PageRank::SinkHandling val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::PageRank::SinkHandling) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_PageRank_3a__3a_SinkHandling(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(enum NetworKit::PageRank::SinkHandling, __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(enum NetworKit::PageRank::SinkHandling) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((((enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((((((enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, 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(enum NetworKit::PageRank::SinkHandling) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((((((((enum NetworKit::PageRank::SinkHandling)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)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 (enum NetworKit::PageRank::SinkHandling) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::SinkHandling, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::SinkHandling, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, __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(enum NetworKit::PageRank::SinkHandling) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((enum NetworKit::PageRank::SinkHandling)-1)*(((((enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) ((((((enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((enum NetworKit::PageRank::SinkHandling)-1)*(((((((enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) ((((((((enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, 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(enum NetworKit::PageRank::SinkHandling) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) (((enum NetworKit::PageRank::SinkHandling)-1)*(((((((((enum NetworKit::PageRank::SinkHandling)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::PageRank::SinkHandling) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::PageRank::SinkHandling, 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(enum NetworKit::PageRank::SinkHandling) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::PageRank::SinkHandling) ((((((((((enum NetworKit::PageRank::SinkHandling)digits[3]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[2]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[1]) << PyLong_SHIFT) | (enum NetworKit::PageRank::SinkHandling)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::SinkHandling, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::PageRank::SinkHandling) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::PageRank::SinkHandling, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::PageRank::SinkHandling 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::PageRank::SinkHandling) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::PageRank::SinkHandling) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::PageRank::SinkHandling");
    return (enum NetworKit::PageRank::SinkHandling) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::PageRank::SinkHandling");
    return (enum NetworKit::PageRank::SinkHandling) -1;
}

/* 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 defined(HAVE_LONG_LONG) && !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);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(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
    }
}

/* CIntFromPy */
static CYTHON_INLINE enum NetworKit::ComplexPathAlgorithm::Mode __Pyx_PyLong_As_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ComplexPathAlgorithm::Mode neg_one = (enum NetworKit::ComplexPathAlgorithm::Mode) -1, const_zero = (enum NetworKit::ComplexPathAlgorithm::Mode) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        enum NetworKit::ComplexPathAlgorithm::Mode val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
        val = __Pyx_PyLong_As_enum__NetworKit_3a__3a_ComplexPathAlgorithm_3a__3a_Mode(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(enum NetworKit::ComplexPathAlgorithm::Mode, __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(enum NetworKit::ComplexPathAlgorithm::Mode) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) >= 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) >= 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, 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(enum NetworKit::ComplexPathAlgorithm::Mode) >= 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)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 (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, __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(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((enum NetworKit::ComplexPathAlgorithm::Mode)-1)*(((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 2 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) ((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((enum NetworKit::ComplexPathAlgorithm::Mode)-1)*(((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 3 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) ((((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, 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(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) (((enum NetworKit::ComplexPathAlgorithm::Mode)-1)*(((((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(enum NetworKit::ComplexPathAlgorithm::Mode, 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(enum NetworKit::ComplexPathAlgorithm::Mode) - 1 > 4 * PyLong_SHIFT)) {
                            return (enum NetworKit::ComplexPathAlgorithm::Mode) ((((((((((enum NetworKit::ComplexPathAlgorithm::Mode)digits[3]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[2]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[1]) << PyLong_SHIFT) | (enum NetworKit::ComplexPathAlgorithm::Mode)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ComplexPathAlgorithm::Mode, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(enum NetworKit::ComplexPathAlgorithm::Mode) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(enum NetworKit::ComplexPathAlgorithm::Mode, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        enum NetworKit::ComplexPathAlgorithm::Mode 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
        PyErr_SetString(PyExc_RuntimeError,
                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
        val = (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
#endif
        if (unlikely(ret))
            return (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to enum NetworKit::ComplexPathAlgorithm::Mode");
    return (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to enum NetworKit::ComplexPathAlgorithm::Mode");
    return (enum NetworKit::ComplexPathAlgorithm::Mode) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_enum__NetworKit_3a__3a_ClosenessVariant(enum NetworKit::ClosenessVariant value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const enum NetworKit::ClosenessVariant neg_one = (enum NetworKit::ClosenessVariant) -1, const_zero = (enum NetworKit::ClosenessVariant) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NetworKit::ClosenessVariant) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(enum NetworKit::ClosenessVariant) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(enum NetworKit::ClosenessVariant) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(enum NetworKit::ClosenessVariant) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(enum NetworKit::ClosenessVariant) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(enum NetworKit::ClosenessVariant),
                                     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(enum NetworKit::ClosenessVariant));
        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
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(int) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(int),
                                     little, !is_unsigned);
#else
        int one = 1; int little = (int)*(unsigned char *)&one;
        PyObject *from_bytes, *result = NULL, *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(int));
        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
    }
}

/* 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_2);
    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__7);
    }
    goto done;
}
#endif

/* 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))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        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))
#ifdef HAVE_LONG_LONG
        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
        }
    }
    {
        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 */
static unsigned long __Pyx_get_runtime_version(void) {
#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
    return Py_Version & ~0xFFUL;
#else
    static unsigned long __Pyx_cached_runtime_version = 0;
    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;
    }
    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 PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#else
  #define __Pyx__PyCode_New(a, 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,
        const char *line_table,
        PyObject *tuple_dedup_map
) {
    PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_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) {
        line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length);
        if (unlikely(!line_table_bytes)) goto done;
        Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3;
        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_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes
    );
done:
    Py_XDECREF(code_bytes);
    Py_XDECREF(line_table_bytes);
    #if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(varnames_tuple_dedup);
    #endif
    Py_DECREF(varnames_tuple);
    return code_obj;
}

/* InitStrings */
static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) {
    while (t->s) {
        PyObject *str;
        if (t->is_unicode) {
            if (t->intern) {
                str = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL);
            } else {
                str = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            str = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        if (!str)
            return -1;
        *target = str;
        if (PyObject_Hash(str) == -1)
            return -1;
        ++t;
        ++target;
    }
    return 0;
}

#include <string.h>
static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
    size_t len = strlen(s);
    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
        return -1;
    }
    return (Py_ssize_t) len;
}
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    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 b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(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 */
