From 48e5c1792fe5c9220fa28c6a98a876d4df6a79e6 Mon Sep 17 00:00:00 2001 From: Nabil Ghodbane Date: Thu, 15 Dec 2022 16:02:12 +0100 Subject: [PATCH] bos #33210: support Fedora 37 --- applications/SALOME-9.10.0-native.pyconf | 6 +- applications/SALOME-master-native.pyconf | 6 +- products/CONFIGURATION.pyconf | 5 + products/ParaView.pyconf | 25 + products/SHAPER.pyconf | 5 + products/compil_scripts/numpy-1.22.2.sh | 24 +- products/patches/SPNS-29988-numpy-1.22.patch | 20 + .../SPNS-32377-CONFIGURATION-V9_10_0.patch | 13 + .../SPNS-32377-SHAPER-V9_10_0-FD37.patch | 13 + .../paraview-5.11.0.p007-mpi4py-FD37.patch | 1781 +++++++++++++++++ 10 files changed, 1890 insertions(+), 8 deletions(-) create mode 100644 products/patches/SPNS-32377-CONFIGURATION-V9_10_0.patch create mode 100644 products/patches/SPNS-32377-SHAPER-V9_10_0-FD37.patch create mode 100644 products/patches/paraview-5.11.0.p007-mpi4py-FD37.patch diff --git a/applications/SALOME-9.10.0-native.pyconf b/applications/SALOME-9.10.0-native.pyconf index 34c2fc7..257a020 100644 --- a/applications/SALOME-9.10.0-native.pyconf +++ b/applications/SALOME-9.10.0-native.pyconf @@ -300,6 +300,8 @@ __overwrite__ : { __condition__ : "VARS.dist in ['FD37']" + 'APPLICATION.rm_products' : ['root', 'URANIE'] + 'APPLICATION.products.cmake' : 'native' 'APPLICATION.products.opencv' : {tag: '3.2.0', base: 'no', section: 'version_3_2_0_FD37' } 'APPLICATION.products.omniORB' : '4.2.5' 'APPLICATION.products.omniORBpy' : '4.2.5' @@ -308,8 +310,10 @@ __overwrite__ : 'APPLICATION.products.netcdf' : '4.6.2' 'APPLICATION.products.numpy' : {tag: '1.22.2', base: 'no', section: 'version_1_22_2' } 'APPLICATION.products.PyFMI' : {tag: '2.6', base: 'no', section: 'version_2_6_no_pip' } - 'APPLICATION.products.root' : {tag: '6.22.02', base: 'no', section: 'version_6_22_02_FD37' } 'APPLICATION.products.medfile' : {tag: '4.1.1', base: 'no', section: 'version_4_1_1_FD37' } 'APPLICATION.products.StaticMeshPlugin' : {tag:'5.11.0', base: 'no', section: 'version_5_11_0_FD37' } + 'APPLICATION.products.ParaView' : {tag: '5.11.0', base: 'no', section: 'version_5_11_0_MPI_FD37', hpc: 'yes'} + 'APPLICATION.products.CONFIGURATION' : {tag:'V9_10_0', base: 'no', section: 'version_V9_10_0_FD37' } + 'APPLICATION.products.SHAPER' : {tag:'V9_10_0', base: 'no', section: 'version_V9_10_0_FD37', hpc: 'no' } } ] diff --git a/applications/SALOME-master-native.pyconf b/applications/SALOME-master-native.pyconf index 29be0be..a97dcf0 100644 --- a/applications/SALOME-master-native.pyconf +++ b/applications/SALOME-master-native.pyconf @@ -300,6 +300,8 @@ __overwrite__ : { __condition__ : "VARS.dist in ['FD37']" + 'APPLICATION.rm_products' : ['root', 'URANIE'] + 'APPLICATION.products.cmake' : 'native' 'APPLICATION.products.opencv' : {tag: '3.2.0', base: 'no', section: 'version_3_2_0_FD37' } 'APPLICATION.products.omniORB' : '4.2.5' 'APPLICATION.products.omniORBpy' : '4.2.5' @@ -308,8 +310,10 @@ __overwrite__ : 'APPLICATION.products.netcdf' : '4.6.2' 'APPLICATION.products.numpy' : {tag: '1.22.2', base: 'no', section: 'version_1_22_2' } 'APPLICATION.products.PyFMI' : {tag: '2.6', base: 'no', section: 'version_2_6_no_pip' } - 'APPLICATION.products.root' : {tag: '6.22.02', base: 'no', section: 'version_6_22_02_FD37' } 'APPLICATION.products.medfile' : {tag: '4.1.1', base: 'no', section: 'version_4_1_1_FD37' } 'APPLICATION.products.StaticMeshPlugin' : {tag:'5.11.0', base: 'no', section: 'version_5_11_0_FD37' } + 'APPLICATION.products.ParaView' : {tag: '5.11.0', base: 'no', section: 'version_5_11_0_MPI_FD37', hpc: 'yes'} + 'APPLICATION.products.CONFIGURATION' : {tag:'master', base: 'no', section: 'version_V9_10_0_FD37' } + 'APPLICATION.products.SHAPER' : {tag:'master', base: 'no', section: 'version_V9_10_0_FD37', hpc: 'no' } } ] diff --git a/products/CONFIGURATION.pyconf b/products/CONFIGURATION.pyconf index fc66527..4040516 100755 --- a/products/CONFIGURATION.pyconf +++ b/products/CONFIGURATION.pyconf @@ -21,6 +21,11 @@ default : patches : [] } +version_V9_10_0_FD37 : +{ + patches: ['SPNS-32377-CONFIGURATION-V9_10_0.patch'] +} + version_V9_9_0_FD36 : { patches: ['SPNS-29988-CONFIGURATION-V9_9_0.patch'] diff --git a/products/ParaView.pyconf b/products/ParaView.pyconf index 3884c77..39e046e 100755 --- a/products/ParaView.pyconf +++ b/products/ParaView.pyconf @@ -214,6 +214,31 @@ version_5_11_0_MPI_CO8 : opt_depend : ['openmpi', 'ospray','tbb', 'openturns', 'gdal', 'netcdf', 'catalyst'] } +version_5_11_0_MPI_FD37 : +{ + compil_script : 'ParaView-5.11.0.sh' + archive_info : {archive_name : "ParaView-5.11.0.tar.gz"} + patches : ['paraview-5.11.0.p001-FindCGNS.patch', + 'paraview-5.11.0.p002-FindMPI.patch', + 'paraview-5.11.0.p006-GIL.patch', + 'paraview-5.11.0.p007-mpi4py-FD37.patch' + ] + depend : [ + 'Python', + 'hdf5', + 'qt', + 'PyQt', + 'sip', + 'boost', + 'libxml2', + 'freetype', + 'matplotlib', + 'cgns', + 'Pygments' + ] + opt_depend : ['openmpi', 'ospray','tbb', 'openturns', 'gdal', 'netcdf', 'catalyst'] +} + version_5_9_0 : { opt_depend : ['openmpi', 'ospray','tbb', 'openturns', 'gdal', 'netcdf'] diff --git a/products/SHAPER.pyconf b/products/SHAPER.pyconf index f347e95..6439a82 100644 --- a/products/SHAPER.pyconf +++ b/products/SHAPER.pyconf @@ -53,6 +53,11 @@ default_win : cmake_options : " -DNO_SolveSpace=TRUE -DSWIG_EXECUTABLE=%SWIG_ROOT_DIR:\=/%/bin/swig.exe " } +version_V9_10_0_FD37: +{ + patches : ['SPNS-32377-SHAPER-V9_10_0-FD37.patch'] +} + version_V9_9_0_UB22_04: { patches : ['SPNS-29880-SHAPER-V9_9_0.patch'] diff --git a/products/compil_scripts/numpy-1.22.2.sh b/products/compil_scripts/numpy-1.22.2.sh index 8ed3974..3e8e7ae 100755 --- a/products/compil_scripts/numpy-1.22.2.sh +++ b/products/compil_scripts/numpy-1.22.2.sh @@ -36,12 +36,24 @@ fi # the embedded versioneer.py fails to retrieve the correct version - presumably because of missing .git information # let's fix this once for all - prevents openturns from not building. cd ${NUMPY_INSTALL} -EGG_OLD=$(ls ) -EGG_DIR=numpy-$VERSION-py${PYTHON_VERSION}-linux-x86_64.egg -echo "====> $EGG_DIR" -mv numpy*-linux-x86_64.egg $EGG_DIR -ln -sf $EGG_DIR/numpy numpy -sed -i "s/0+unknown/$VERSION/g" $EGG_DIR/numpy/_version.py +if [ -f numpy/_version.py ]; then + echo "INFO: ensure that version is consistently set. In principle patches " + sed -i "s/0+unknown/$VERSION/g" numpy/_version.py +else + f=$(find . -type d -name "numpy-$VERSION-py${PYTHON_VERSION}-*x86_64.egg") + if [ $? -eq 0 ]; then + EGG_DIR=$(ls numpy-$VERSION-py${PYTHON_VERSION}-*-x86_64.egg) + echo "INFO: Found $EGG_DIR" + if [ ! -d $EGG_DIR/numpy ]; then + ln -sf $EGG_DIR/numpy + sed -i "s/0+unknown/$VERSION/g" $EGG_DIR/numpy/_version.py + else + echo "WARNING: could not find $EGG_DIR/numpy" + fi + else + echo "WARNING: could not find egg directory with name: numpy-$VERSION-py${PYTHON_VERSION}-*-x86_64.egg" + fi +fi if [ -d ${PRODUCT_INSTALL}/local/bin ]; then mv ${PRODUCT_INSTALL}/local/bin ${PRODUCT_INSTALL}/bin diff --git a/products/patches/SPNS-29988-numpy-1.22.patch b/products/patches/SPNS-29988-numpy-1.22.patch index 11b5223..05860ca 100644 --- a/products/patches/SPNS-29988-numpy-1.22.patch +++ b/products/patches/SPNS-29988-numpy-1.22.patch @@ -10,3 +10,23 @@ diff -Naur numpy-1.22.2_ref/setup.py numpy-1.22.2_dev/setup.py # Capture the version string: # 1.22.0.dev0+ ... -> ISRELEASED == False, VERSION == 1.22.0 +--- numpy-1.22.2-ref/versioneer.py 2022-09-06 12:16:20.000000000 +0200 ++++ numpy-1.22.2-dev/versioneer.py 2022-12-15 15:34:37.857751459 +0100 +@@ -1019,7 +1019,7 @@ + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") +- return {"version": "0+unknown", ++ return {"version": "1.22.0", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} + +@@ -1470,7 +1470,7 @@ + if verbose: + print("unable to compute version") + +- return {"version": "0+unknown", "full-revisionid": None, ++ return {"version": "1.22.0", "full-revisionid": None, + "dirty": None, "error": "unable to compute version", + "date": None} + diff --git a/products/patches/SPNS-32377-CONFIGURATION-V9_10_0.patch b/products/patches/SPNS-32377-CONFIGURATION-V9_10_0.patch new file mode 100644 index 0000000..f8ce73e --- /dev/null +++ b/products/patches/SPNS-32377-CONFIGURATION-V9_10_0.patch @@ -0,0 +1,13 @@ +diff --git a/cmake/FindPyQt5.cmake b/cmake/FindPyQt5.cmake +index c64900f..cd0a504 100644 +--- a/cmake/FindPyQt5.cmake ++++ b/cmake/FindPyQt5.cmake +@@ -56,7 +56,7 @@ GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH) + # - /usr/share/sip/PyQt5/QtCore, for a system install + # - or /sip/QtCore, for a custom install + # - or /share/sip/QtCore, for a custom install +-FIND_FILE(PYQT_SIP_MAIN_FILE qobject.sip PATH_SUFFIXES share/sip/QtCore sip/QtCore share/sip/PyQt5/QtCore lib/python3/dist-packages/PyQt5/bindings/QtCore lib64/python3.10/site-packages/PyQt5/bindings/QtCore) ++FIND_FILE(PYQT_SIP_MAIN_FILE qobject.sip PATH_SUFFIXES share/sip/QtCore sip/QtCore share/sip/PyQt5/QtCore lib/python3/dist-packages/PyQt5/bindings/QtCore lib64/python3.10/site-packages/PyQt5/bindings/QtCore lib64/python3.11/site-packages/PyQt5/bindings/QtCore) + + IF(PYQT_SIP_MAIN_FILE) + GET_FILENAME_COMPONENT(PYQT_SIPS_DIR "${PYQT_SIP_MAIN_FILE}" PATH) diff --git a/products/patches/SPNS-32377-SHAPER-V9_10_0-FD37.patch b/products/patches/SPNS-32377-SHAPER-V9_10_0-FD37.patch new file mode 100644 index 0000000..e33715d --- /dev/null +++ b/products/patches/SPNS-32377-SHAPER-V9_10_0-FD37.patch @@ -0,0 +1,13 @@ +diff --git a/src/InitializationPlugin/InitializationPlugin_PyInterp.cpp b/src/InitializationPlugin/InitializationPlugin_PyInterp.cpp +index 0aab9a2c7..40fb8fb82 100644 +--- a/src/InitializationPlugin/InitializationPlugin_PyInterp.cpp ++++ b/src/InitializationPlugin/InitializationPlugin_PyInterp.cpp +@@ -118,7 +118,7 @@ std::list InitializationPlugin_PyInterp::compile(const std::wstrin + } + + PyCodeObject* aCodeObj = (PyCodeObject*) aCodePyObj; +- std::string aCodeName(PyBytes_AsString(aCodeObj->co_code)); ++ std::string aCodeName(PyBytes_AsString(aCodeObj->_co_code)); + // co_names should be tuple, but can be changed in modern versions of python (>2.7.3) + if(!PyTuple_Check(aCodeObj->co_names)) { + return aResult; diff --git a/products/patches/paraview-5.11.0.p007-mpi4py-FD37.patch b/products/patches/paraview-5.11.0.p007-mpi4py-FD37.patch new file mode 100644 index 0000000..77e5c1c --- /dev/null +++ b/products/patches/paraview-5.11.0.p007-mpi4py-FD37.patch @@ -0,0 +1,1781 @@ +--- ParaView-5.11.0-ref/VTK/ThirdParty/mpi4py/vtkmpi4py/src/mpi4py.MPI.c 2022-11-18 15:26:55.000000000 +0100 ++++ ParaView-5.11.0-dev/VTK/ThirdParty/mpi4py/vtkmpi4py/src/mpi4py.MPI.c 2022-12-01 14:27:19.715849691 +0100 +@@ -1,14 +1,16 @@ +-/* Generated by Cython 0.29.21 */ ++/* Generated by Cython 0.29.32 */ + ++#ifndef PY_SSIZE_T_CLEAN + #define PY_SSIZE_T_CLEAN ++#endif /* PY_SSIZE_T_CLEAN */ + #include "Python.h" + #ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. + #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. + #else +-#define CYTHON_ABI "0_29_21" +-#define CYTHON_HEX_VERSION 0x001D15F0 ++#define CYTHON_ABI "0_29_32" ++#define CYTHON_HEX_VERSION 0x001D20F0 + #define CYTHON_FUTURE_DIVISION 0 + #include + #ifndef offsetof +@@ -47,6 +49,7 @@ + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 ++ #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP +@@ -83,10 +86,14 @@ + #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_HEX >= 0x07030900) ++ #endif + #elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 ++ #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif +@@ -124,10 +131,59 @@ + #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 ++#elif defined(PY_NOGIL) ++ #define CYTHON_COMPILING_IN_PYPY 0 ++ #define CYTHON_COMPILING_IN_PYSTON 0 ++ #define CYTHON_COMPILING_IN_CPYTHON 0 ++ #define CYTHON_COMPILING_IN_NOGIL 1 ++ #ifndef CYTHON_USE_TYPE_SLOTS ++ #define CYTHON_USE_TYPE_SLOTS 1 ++ #endif ++ #undef CYTHON_USE_PYTYPE_LOOKUP ++ #define CYTHON_USE_PYTYPE_LOOKUP 0 ++ #ifndef CYTHON_USE_ASYNC_SLOTS ++ #define CYTHON_USE_ASYNC_SLOTS 1 ++ #endif ++ #undef CYTHON_USE_PYLIST_INTERNALS ++ #define CYTHON_USE_PYLIST_INTERNALS 0 ++ #ifndef CYTHON_USE_UNICODE_INTERNALS ++ #define CYTHON_USE_UNICODE_INTERNALS 1 ++ #endif ++ #undef CYTHON_USE_UNICODE_WRITER ++ #define CYTHON_USE_UNICODE_WRITER 0 ++ #undef CYTHON_USE_PYLONG_INTERNALS ++ #define CYTHON_USE_PYLONG_INTERNALS 0 ++ #ifndef CYTHON_AVOID_BORROWED_REFS ++ #define CYTHON_AVOID_BORROWED_REFS 0 ++ #endif ++ #ifndef CYTHON_ASSUME_SAFE_MACROS ++ #define CYTHON_ASSUME_SAFE_MACROS 1 ++ #endif ++ #ifndef CYTHON_UNPACK_METHODS ++ #define CYTHON_UNPACK_METHODS 1 ++ #endif ++ #undef CYTHON_FAST_THREAD_STATE ++ #define CYTHON_FAST_THREAD_STATE 0 ++ #undef CYTHON_FAST_PYCALL ++ #define CYTHON_FAST_PYCALL 0 ++ #ifndef CYTHON_PEP489_MULTI_PHASE_INIT ++ #define CYTHON_PEP489_MULTI_PHASE_INIT 1 ++ #endif ++ #ifndef CYTHON_USE_TP_FINALIZE ++ #define CYTHON_USE_TP_FINALIZE 1 ++ #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 + #else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 ++ #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif +@@ -155,7 +211,7 @@ + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif +- #if PY_VERSION_HEX < 0x030300F0 ++ #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) +@@ -170,11 +226,14 @@ + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif +- #ifndef CYTHON_FAST_THREAD_STATE ++ #if PY_VERSION_HEX >= 0x030B00A4 ++ #undef CYTHON_FAST_THREAD_STATE ++ #define CYTHON_FAST_THREAD_STATE 0 ++ #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL +- #define CYTHON_FAST_PYCALL 1 ++ #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) +@@ -185,15 +244,23 @@ + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif +- #ifndef CYTHON_USE_EXC_INFO_STACK ++ #if PY_VERSION_HEX >= 0x030B00A4 ++ #undef CYTHON_USE_EXC_INFO_STACK ++ #define CYTHON_USE_EXC_INFO_STACK 0 ++ #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif ++ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC ++ #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 ++ #endif + #endif + #if !defined(CYTHON_FAST_PYCCALL) + #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) + #endif + #if CYTHON_USE_PYLONG_INTERNALS +- #include "longintrepr.h" ++ #if PY_MAJOR_VERSION < 3 ++ #include "longintrepr.h" ++ #endif + #undef SHIFT + #undef BASE + #undef MASK +@@ -310,9 +377,68 @@ + #define __Pyx_DefaultClassType PyClass_Type + #else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +-#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 +- #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ +- PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) ++ #define __Pyx_DefaultClassType PyType_Type ++#if PY_VERSION_HEX >= 0x030B00A1 ++ static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, ++ PyObject *code, PyObject *c, PyObject* n, PyObject *v, ++ PyObject *fv, PyObject *cell, PyObject* fn, ++ PyObject *name, int fline, PyObject *lnos) { ++ PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; ++ PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; ++ const char *fn_cstr=NULL; ++ const char *name_cstr=NULL; ++ PyCodeObject* co=NULL; ++ PyObject *type, *value, *traceback; ++ PyErr_Fetch(&type, &value, &traceback); ++ if (!(kwds=PyDict_New())) goto end; ++ if (!(argcount=PyLong_FromLong(a))) goto end; ++ if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; ++ if (!(posonlyargcount=PyLong_FromLong(0))) goto end; ++ if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; ++ if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; ++ if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; ++ if (!(nlocals=PyLong_FromLong(l))) goto end; ++ if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; ++ if (!(stacksize=PyLong_FromLong(s))) goto end; ++ if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; ++ if (!(flags=PyLong_FromLong(f))) goto end; ++ if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; ++ if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; ++ if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; ++ if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; ++ if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; ++ if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; ++ if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here ++ if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; ++ Py_XDECREF((PyObject*)co); ++ co = (PyCodeObject*)call_result; ++ call_result = NULL; ++ if (0) { ++ cleanup_code_too: ++ Py_XDECREF((PyObject*)co); ++ co = NULL; ++ } ++ end: ++ Py_XDECREF(kwds); ++ Py_XDECREF(argcount); ++ Py_XDECREF(posonlyargcount); ++ Py_XDECREF(kwonlyargcount); ++ Py_XDECREF(nlocals); ++ Py_XDECREF(stacksize); ++ Py_XDECREF(replace); ++ Py_XDECREF(call_result); ++ Py_XDECREF(empty); ++ if (type) { ++ PyErr_Restore(type, value, traceback); ++ } ++ return co; ++ } + #else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +@@ -426,8 +552,12 @@ + #endif + #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 ++ #if defined(PyUnicode_IS_READY) + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) ++ #else ++ #define __Pyx_PyUnicode_READY(op) (0) ++ #endif + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) +@@ -436,7 +566,11 @@ + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) ++ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 ++ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) ++ #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) ++ #endif + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +@@ -542,10 +676,10 @@ + #if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong +- #define __Pyx_PyInt_AsHash_t PyInt_AsLong ++ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t + #else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t +- #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t ++ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t + #endif + #if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +@@ -570,8 +704,10 @@ + } __Pyx_PyAsyncMethodsStruct; + #endif + +-#if defined(WIN32) || defined(MS_WINDOWS) +- #define _USE_MATH_DEFINES ++#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) ++ #if !defined(_USE_MATH_DEFINES) ++ #define _USE_MATH_DEFINES ++ #endif + #endif + #include + #ifdef NAN +@@ -703,6 +839,7 @@ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) + static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); + static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); ++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)) + #else +@@ -1747,13 +1884,21 @@ + #ifndef Py_MEMBER_SIZE + #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) + #endif ++#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" ++#if PY_VERSION_HEX >= 0x030b00a6 ++ #ifndef Py_BUILD_CORE ++ #define Py_BUILD_CORE 1 ++ #endif ++ #include "internal/pycore_frame.h" ++#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) ++#endif // CYTHON_FAST_PYCALL + #endif + + /* PyObjectCall.proto */ +@@ -2340,26 +2485,19 @@ + static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +-/* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Aint(MPI_Aint value); +- +-/* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +- +-/* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); ++/* GCCDiagnostics.proto */ ++#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) ++#define __Pyx_HAS_GCC_DIAGNOSTIC ++#endif + +-/* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Offset(MPI_Offset value); ++/* CIntFromPy.proto */ ++static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + + /* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Fint(MPI_Fint value); ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Aint(MPI_Aint value); + + /* CIntToPy.proto */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Count(MPI_Count value); +- +-/* CIntFromPy.proto */ +-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + + /* CIntFromPy.proto */ + static CYTHON_INLINE MPI_Aint __Pyx_PyInt_As_MPI_Aint(PyObject *); +@@ -2370,12 +2508,24 @@ + /* CIntFromPy.proto */ + static CYTHON_INLINE MPI_Offset __Pyx_PyInt_As_MPI_Offset(PyObject *); + ++/* CIntToPy.proto */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); ++ + /* CIntFromPy.proto */ + static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *); + ++/* CIntToPy.proto */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Offset(MPI_Offset value); ++ ++/* CIntToPy.proto */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Fint(MPI_Fint value); ++ + /* CIntFromPy.proto */ + static CYTHON_INLINE MPI_Fint __Pyx_PyInt_As_MPI_Fint(PyObject *); + ++/* CIntToPy.proto */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Count(MPI_Count value); ++ + /* CIntFromPy.proto */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +@@ -16973,7 +17123,8 @@ + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; +- MPI_Status __pyx_t_5; ++ PyObject *__pyx_t_5 = NULL; ++ MPI_Status __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; +@@ -17073,10 +17224,13 @@ + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(13, 79, __pyx_L1_error) + } +- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_self->query_fn, __pyx_t_1, __pyx_v_self->kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 79, __pyx_L1_error) ++ __pyx_t_2 = PyDict_Copy(__pyx_v_self->kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); ++ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_self->query_fn, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 79, __pyx_L1_error) ++ __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; ++ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "mpi4py/MPI/reqimpl.pxi":80 + * sts.ob_mpi = status[0] +@@ -17085,8 +17239,8 @@ + * if self.cancel_fn is None: + * MPI_Status_set_cancelled(status, 0) + */ +- __pyx_t_5 = __pyx_v_sts->ob_mpi; +- (__pyx_v_status[0]) = __pyx_t_5; ++ __pyx_t_6 = __pyx_v_sts->ob_mpi; ++ (__pyx_v_status[0]) = __pyx_t_6; + + /* "mpi4py/MPI/reqimpl.pxi":81 + * self.query_fn(sts, *self.args, **self.kargs) +@@ -17148,6 +17302,7 @@ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); ++ __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mpi4py.MPI._p_greq.query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; +@@ -17170,6 +17325,7 @@ + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; ++ PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; +@@ -17201,9 +17357,12 @@ + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(13, 87, __pyx_L1_error) + } +- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_self->free_fn, __pyx_v_self->args, __pyx_v_self->kargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 87, __pyx_L1_error) ++ __pyx_t_3 = PyDict_Copy(__pyx_v_self->kargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); ++ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_self->free_fn, __pyx_v_self->args, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 87, __pyx_L1_error) ++ __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; ++ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mpi4py/MPI/reqimpl.pxi":86 + * +@@ -17235,6 +17394,7 @@ + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); ++ __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("mpi4py.MPI._p_greq.free", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; +@@ -17257,6 +17417,7 @@ + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; ++ PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; +@@ -17298,10 +17459,13 @@ + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(13, 92, __pyx_L1_error) + } +- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_self->cancel_fn, __pyx_t_3, __pyx_v_self->kargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 92, __pyx_L1_error) ++ __pyx_t_4 = PyDict_Copy(__pyx_v_self->kargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); ++ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_self->cancel_fn, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 92, __pyx_L1_error) ++ __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; ++ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "mpi4py/MPI/reqimpl.pxi":91 + * +@@ -17334,6 +17498,7 @@ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); ++ __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mpi4py.MPI._p_greq.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; +@@ -157790,12 +157955,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Datatype(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158075,12 +158243,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Request(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158285,12 +158456,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Prequest(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158370,12 +158544,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Grequest(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158455,12 +158632,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Message(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158656,12 +158836,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Op(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -158843,12 +159026,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Group(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159039,12 +159225,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Info(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159258,12 +159447,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Errhandler(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159428,12 +159620,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Comm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159770,12 +159965,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Intracomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159870,12 +160068,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Topocomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -159999,12 +160200,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Cartcomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -160122,12 +160326,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Graphcomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -160253,12 +160460,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Distgraphcomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -160338,12 +160548,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Intercomm(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -160438,12 +160651,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_Win(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -160749,12 +160965,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_File(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -161025,12 +161244,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI_memory(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { +@@ -161201,12 +161423,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI__p_mem(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { +@@ -161297,12 +161522,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_greq __pyx_vtable_6mpi4py_3MPI__p_greq; + +@@ -161443,12 +161671,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_datarep __pyx_vtable_6mpi4py_3MPI__p_datarep; + +@@ -161573,12 +161804,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI__p_keyval(PyTypeObject *t, PyObject *a, PyObject *k) { +@@ -161740,12 +161974,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyObject *__pyx_tp_new_6mpi4py_3MPI__p_message(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { +@@ -161868,12 +162105,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_msg_p2p __pyx_vtable_6mpi4py_3MPI__p_msg_p2p; + +@@ -161982,12 +162222,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_msg_cco __pyx_vtable_6mpi4py_3MPI__p_msg_cco; + +@@ -162112,12 +162355,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_msg_ccow __pyx_vtable_6mpi4py_3MPI__p_msg_ccow; + +@@ -162234,12 +162480,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_msg_rma __pyx_vtable_6mpi4py_3MPI__p_msg_rma; + +@@ -162372,12 +162621,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI__p_msg_io __pyx_vtable_6mpi4py_3MPI__p_msg_io; + +@@ -162486,12 +162738,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + static struct __pyx_vtabstruct_6mpi4py_3MPI_Pickle __pyx_vtable_6mpi4py_3MPI_Pickle; + +@@ -162637,12 +162892,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +- #if PY_VERSION_HEX >= 0x030800b1 ++ #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif ++ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, /*tp_pypy_flags*/ ++ #endif + }; + + static PyMethodDef __pyx_methods[] = { +@@ -165349,11 +165607,9 @@ + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ +- #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS +- #ifdef WITH_THREAD /* Python build with threading support? */ ++ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif +- #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; +@@ -177405,7 +177661,7 @@ + #if CYTHON_COMPILING_IN_CPYTHON + static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; +- ternaryfunc call = func->ob_type->tp_call; ++ ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) +@@ -177492,7 +177748,7 @@ + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + #if CYTHON_FAST_PYCCALL +- } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { ++ } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); + #endif + } +@@ -177684,7 +177940,7 @@ + return (equals == Py_EQ); + } else { + int result; +-#if CYTHON_USE_UNICODE_INTERNALS ++#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; +@@ -179668,7 +179924,8 @@ + __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) + { + #if PY_MAJOR_VERSION >= 3 +- return PyUnicode_FromString(m->func.m_ml->ml_name); ++ Py_INCREF(m->func_qualname); ++ return m->func_qualname; + #else + return PyString_FromString(m->func.m_ml->ml_name); + #endif +@@ -179871,6 +180128,9 @@ + 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); +@@ -179939,12 +180199,15 @@ + #if PY_VERSION_HEX >= 0x030400a1 + 0, + #endif +-#if PY_VERSION_HEX >= 0x030800b1 ++#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, + #endif ++#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 ++ 0, ++#endif + }; + static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +@@ -180194,7 +180457,7 @@ + } + if (!use_cline) { + c_line = 0; +- PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); ++ (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; +@@ -180288,33 +180551,40 @@ + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" ++#if PY_VERSION_HEX >= 0x030b00a6 ++ #ifndef Py_BUILD_CORE ++ #define Py_BUILD_CORE 1 ++ #endif ++ #include "internal/pycore_frame.h" ++#endif + static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { +- PyCodeObject *py_code = 0; +- PyObject *py_srcfile = 0; +- PyObject *py_funcname = 0; ++ PyCodeObject *py_code = NULL; ++ PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 ++ PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); +- #else +- py_srcfile = PyUnicode_FromString(filename); +- #endif + if (!py_srcfile) goto bad; ++ #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); ++ if (!py_funcname) goto bad; + #else + 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; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); +- #else +- py_funcname = PyUnicode_FromString(funcname); ++ if (!py_funcname) goto bad; + #endif + } +- if (!py_funcname) goto bad; ++ #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, +@@ -180333,11 +180603,16 @@ + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); +- Py_DECREF(py_funcname); ++ #else ++ py_code = PyCode_NewEmpty(filename, funcname, py_line); ++ #endif ++ Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; + bad: +- Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); ++ #if PY_MAJOR_VERSION < 3 ++ Py_XDECREF(py_srcfile); ++ #endif + return NULL; + } + static void __Pyx_AddTraceback(const char *funcname, int c_line, +@@ -180345,14 +180620,24 @@ + 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) goto bad; ++ 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( +@@ -180391,195 +180676,16 @@ + return (target_type) value;\ + } + +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Aint(MPI_Aint value) { +- const MPI_Aint neg_one = (MPI_Aint) ((MPI_Aint) 0 - (MPI_Aint) 1), const_zero = (MPI_Aint) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(MPI_Aint) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(MPI_Aint) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Aint) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(MPI_Aint) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Aint) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(MPI_Aint), +- little, !is_unsigned); +- } +-} +- +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +- const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(int) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(int) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(int) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(int), +- little, !is_unsigned); +- } +-} +- +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +- const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(long) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(long) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(long) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(long), +- little, !is_unsigned); +- } +-} +- +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Offset(MPI_Offset value) { +- const MPI_Offset neg_one = (MPI_Offset) ((MPI_Offset) 0 - (MPI_Offset) 1), const_zero = (MPI_Offset) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(MPI_Offset) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(MPI_Offset) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Offset) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(MPI_Offset) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Offset) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(MPI_Offset), +- little, !is_unsigned); +- } +-} +- +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Fint(MPI_Fint value) { +- const MPI_Fint neg_one = (MPI_Fint) ((MPI_Fint) 0 - (MPI_Fint) 1), const_zero = (MPI_Fint) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(MPI_Fint) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(MPI_Fint) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Fint) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(MPI_Fint) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Fint) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(MPI_Fint), +- little, !is_unsigned); +- } +-} +- +-/* CIntToPy */ +-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Count(MPI_Count value) { +- const MPI_Count neg_one = (MPI_Count) ((MPI_Count) 0 - (MPI_Count) 1), const_zero = (MPI_Count) 0; +- const int is_unsigned = neg_one > const_zero; +- if (is_unsigned) { +- if (sizeof(MPI_Count) < sizeof(long)) { +- return PyInt_FromLong((long) value); +- } else if (sizeof(MPI_Count) <= sizeof(unsigned long)) { +- return PyLong_FromUnsignedLong((unsigned long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Count) <= sizeof(unsigned PY_LONG_LONG)) { +- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +-#endif +- } +- } else { +- if (sizeof(MPI_Count) <= sizeof(long)) { +- return PyInt_FromLong((long) value); +-#ifdef HAVE_LONG_LONG +- } else if (sizeof(MPI_Count) <= sizeof(PY_LONG_LONG)) { +- return PyLong_FromLongLong((PY_LONG_LONG) value); +-#endif +- } +- } +- { +- int one = 1; int little = (int)*(unsigned char *)&one; +- unsigned char *bytes = (unsigned char *)&value; +- return _PyLong_FromByteArray(bytes, sizeof(MPI_Count), +- little, !is_unsigned); +- } +-} +- + /* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +- const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const int neg_one = (int) -1, const_zero = (int) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -180766,9 +180872,92 @@ + return (int) -1; + } + ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Aint(MPI_Aint value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Aint neg_one = (MPI_Aint) -1, const_zero = (MPI_Aint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(MPI_Aint) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(MPI_Aint) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Aint) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(MPI_Aint) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Aint) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(MPI_Aint), ++ little, !is_unsigned); ++ } ++} ++ ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const int neg_one = (int) -1, const_zero = (int) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(int) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(int) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(int) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(int), ++ little, !is_unsigned); ++ } ++} ++ + /* CIntFromPy */ + static CYTHON_INLINE MPI_Aint __Pyx_PyInt_As_MPI_Aint(PyObject *x) { +- const MPI_Aint neg_one = (MPI_Aint) ((MPI_Aint) 0 - (MPI_Aint) 1), const_zero = (MPI_Aint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Aint neg_one = (MPI_Aint) -1, const_zero = (MPI_Aint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -180957,7 +181146,14 @@ + + /* CIntFromPy */ + static CYTHON_INLINE MPI_Count __Pyx_PyInt_As_MPI_Count(PyObject *x) { +- const MPI_Count neg_one = (MPI_Count) ((MPI_Count) 0 - (MPI_Count) 1), const_zero = (MPI_Count) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Count neg_one = (MPI_Count) -1, const_zero = (MPI_Count) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -181146,7 +181342,14 @@ + + /* CIntFromPy */ + static CYTHON_INLINE MPI_Offset __Pyx_PyInt_As_MPI_Offset(PyObject *x) { +- const MPI_Offset neg_one = (MPI_Offset) ((MPI_Offset) 0 - (MPI_Offset) 1), const_zero = (MPI_Offset) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Offset neg_one = (MPI_Offset) -1, const_zero = (MPI_Offset) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -181333,9 +181536,54 @@ + return (MPI_Offset) -1; + } + ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const long neg_one = (long) -1, const_zero = (long) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(long) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(long) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(long) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(long), ++ little, !is_unsigned); ++ } ++} ++ + /* CIntFromPy */ + static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *x) { +- const unsigned char neg_one = (unsigned char) ((unsigned char) 0 - (unsigned char) 1), const_zero = (unsigned char) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const unsigned char neg_one = (unsigned char) -1, const_zero = (unsigned char) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -181522,9 +181770,92 @@ + return (unsigned char) -1; + } + ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Offset(MPI_Offset value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Offset neg_one = (MPI_Offset) -1, const_zero = (MPI_Offset) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(MPI_Offset) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(MPI_Offset) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Offset) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(MPI_Offset) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Offset) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(MPI_Offset), ++ little, !is_unsigned); ++ } ++} ++ ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Fint(MPI_Fint value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Fint neg_one = (MPI_Fint) -1, const_zero = (MPI_Fint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(MPI_Fint) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(MPI_Fint) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Fint) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(MPI_Fint) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Fint) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(MPI_Fint), ++ little, !is_unsigned); ++ } ++} ++ + /* CIntFromPy */ + static CYTHON_INLINE MPI_Fint __Pyx_PyInt_As_MPI_Fint(PyObject *x) { +- const MPI_Fint neg_one = (MPI_Fint) ((MPI_Fint) 0 - (MPI_Fint) 1), const_zero = (MPI_Fint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Fint neg_one = (MPI_Fint) -1, const_zero = (MPI_Fint) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -181711,9 +182042,54 @@ + return (MPI_Fint) -1; + } + ++/* CIntToPy */ ++static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MPI_Count(MPI_Count value) { ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const MPI_Count neg_one = (MPI_Count) -1, const_zero = (MPI_Count) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif ++ const int is_unsigned = neg_one > const_zero; ++ if (is_unsigned) { ++ if (sizeof(MPI_Count) < sizeof(long)) { ++ return PyInt_FromLong((long) value); ++ } else if (sizeof(MPI_Count) <= sizeof(unsigned long)) { ++ return PyLong_FromUnsignedLong((unsigned long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Count) <= sizeof(unsigned PY_LONG_LONG)) { ++ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); ++#endif ++ } ++ } else { ++ if (sizeof(MPI_Count) <= sizeof(long)) { ++ return PyInt_FromLong((long) value); ++#ifdef HAVE_LONG_LONG ++ } else if (sizeof(MPI_Count) <= sizeof(PY_LONG_LONG)) { ++ return PyLong_FromLongLong((PY_LONG_LONG) value); ++#endif ++ } ++ } ++ { ++ int one = 1; int little = (int)*(unsigned char *)&one; ++ unsigned char *bytes = (unsigned char *)&value; ++ return _PyLong_FromByteArray(bytes, sizeof(MPI_Count), ++ little, !is_unsigned); ++ } ++} ++ + /* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +- const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wconversion" ++#endif ++ const long neg_one = (long) -1, const_zero = (long) 0; ++#ifdef __Pyx_HAS_GCC_DIAGNOSTIC ++#pragma GCC diagnostic pop ++#endif + const int is_unsigned = neg_one > const_zero; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { +@@ -182002,11 +182378,33 @@ + + /* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { +- char ctversion[4], rtversion[4]; +- PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); +- PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); +- if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { ++ char ctversion[5]; ++ int same=1, i, found_dot; ++ const char* rt_from_call = Py_GetVersion(); ++ PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); ++ found_dot = 0; ++ for (i = 0; i < 4; i++) { ++ if (!ctversion[i]) { ++ same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); ++ break; ++ } ++ if (rt_from_call[i] != ctversion[i]) { ++ same = 0; ++ break; ++ } ++ } ++ if (!same) { ++ char rtversion[5] = {'\0'}; + char message[200]; ++ for (i=0; i<4; ++i) { ++ if (rt_from_call[i] == '.') { ++ if (found_dot) break; ++ found_dot = 1; ++ } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { ++ break; ++ } ++ rtversion[i] = rt_from_call[i]; ++ } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", +@@ -182301,6 +182699,23 @@ + 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); ++#if PY_MAJOR_VERSION < 3 ++ } else if (likely(PyInt_CheckExact(o))) { ++ return PyInt_AS_LONG(o); ++#endif ++ } else { ++ Py_ssize_t ival; ++ PyObject *x; ++ x = PyNumber_Index(o); ++ if (!x) return -1; ++ ival = PyInt_AsLong(x); ++ Py_DECREF(x); ++ return ival; ++ } ++} + static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); + } -- 2.39.2