Offset 1616, 31 lines modifiedOffset 1616, 31 lines modified
1616 ····#undef·CYTHON_ATOMICS1616 ····#undef·CYTHON_ATOMICS
1617 ····#define·CYTHON_ATOMICS·01617 ····#define·CYTHON_ATOMICS·0
1618 ····#ifdef·__PYX_DEBUG_ATOMICS1618 ····#ifdef·__PYX_DEBUG_ATOMICS
1619 ········#warning·"Not·using·atomics"1619 ········#warning·"Not·using·atomics"
1620 ····#endif1620 ····#endif
1621 #endif1621 #endif
  
1622 /*·IncludeStructmemberH.proto·*/ 
1623 #include·<structmember.h> 
  
1624 /*·CriticalSectionsDefinition.proto·*/1622 /*·CriticalSectionsDefinition.proto·*/
1625 #if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING1623 #if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
1626 #define·__Pyx_PyCriticalSection·void*1624 #define·__Pyx_PyCriticalSection·void*
1627 #define·__Pyx_PyCriticalSection2·void*1625 #define·__Pyx_PyCriticalSection2·void*
1628 #define·__Pyx_PyCriticalSection_End(cs)1626 #define·__Pyx_PyCriticalSection_End(cs)
1629 #define·__Pyx_PyCriticalSection2_End(cs)1627 #define·__Pyx_PyCriticalSection2_End(cs)
1630 #else1628 #else
1631 #define·__Pyx_PyCriticalSection·PyCriticalSection1629 #define·__Pyx_PyCriticalSection·PyCriticalSection
1632 #define·__Pyx_PyCriticalSection2·PyCriticalSection21630 #define·__Pyx_PyCriticalSection2·PyCriticalSection2
1633 #define·__Pyx_PyCriticalSection_End·PyCriticalSection_End1631 #define·__Pyx_PyCriticalSection_End·PyCriticalSection_End
1634 #define·__Pyx_PyCriticalSection2_End·PyCriticalSection2_End1632 #define·__Pyx_PyCriticalSection2_End·PyCriticalSection2_End
1635 #endif1633 #endif
  
1636 /*·CriticalSections.proto·(used·by·CythonFunctionShared)·*/1634 /*·IncludeStructmemberH.proto·*/
 1635 #include·<structmember.h>
  
 1636 /*·CriticalSections.proto·(used·by·ParseKeywordsImpl)·*/
1637 #if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING1637 #if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
1638 #define·__Pyx_PyCriticalSection_Begin(cs,·arg)·(void)(cs)1638 #define·__Pyx_PyCriticalSection_Begin(cs,·arg)·(void)(cs)
1639 #define·__Pyx_PyCriticalSection2_Begin(cs,·arg1,·arg2)·(void)(cs)1639 #define·__Pyx_PyCriticalSection2_Begin(cs,·arg1,·arg2)·(void)(cs)
1640 #else1640 #else
1641 #define·__Pyx_PyCriticalSection_Begin·PyCriticalSection_Begin1641 #define·__Pyx_PyCriticalSection_Begin·PyCriticalSection_Begin
1642 #define·__Pyx_PyCriticalSection2_Begin·PyCriticalSection2_Begin1642 #define·__Pyx_PyCriticalSection2_Begin·PyCriticalSection2_Begin
1643 #endif1643 #endif
Offset 1877, 22 lines modifiedOffset 1877, 14 lines modified
1877 static·__Pyx_CachedCodeObjectType·*__pyx_find_code_object(int·code_line);1877 static·__Pyx_CachedCodeObjectType·*__pyx_find_code_object(int·code_line);
1878 static·void·__pyx_insert_code_object(int·code_line,·__Pyx_CachedCodeObjectType*·code_object);1878 static·void·__pyx_insert_code_object(int·code_line,·__Pyx_CachedCodeObjectType*·code_object);
  
1879 /*·AddTraceback.proto·*/1879 /*·AddTraceback.proto·*/
1880 static·void·__Pyx_AddTraceback(const·char·*funcname,·int·c_line,1880 static·void·__Pyx_AddTraceback(const·char·*funcname,·int·c_line,
1881 ·······························int·py_line,·const·char·*filename);1881 ·······························int·py_line,·const·char·*filename);
  
1882 /*·PyObjectCallMethod0.proto·*/ 
1883 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name); 
  
1884 /*·GetTypeDictOffset.proto·*/ 
1885 #if·!CYTHON_USE_TYPE_SLOTS 
1886 CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result); 
1887 #endif 
  
1888 /*·FormatTypeName.proto·*/1882 /*·FormatTypeName.proto·*/
1889 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d00001883 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
1890 typedef·PyObject·*__Pyx_TypeName;1884 typedef·PyObject·*__Pyx_TypeName;
1891 #define·__Pyx_FMT_TYPENAME·"%N"1885 #define·__Pyx_FMT_TYPENAME·"%N"
1892 #define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)1886 #define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)
1893 #define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)1887 #define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)
1894 #elif·CYTHON_COMPILING_IN_LIMITED_API1888 #elif·CYTHON_COMPILING_IN_LIMITED_API
Offset 1903, 58 lines modifiedOffset 1895, 35 lines modified
1903 #else··//·!LIMITED_API1895 #else··//·!LIMITED_API
1904 typedef·const·char·*__Pyx_TypeName;1896 typedef·const·char·*__Pyx_TypeName;
1905 #define·__Pyx_FMT_TYPENAME·"%.200s"1897 #define·__Pyx_FMT_TYPENAME·"%.200s"
1906 #define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)1898 #define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)
1907 #define·__Pyx_DECREF_TypeName(obj)1899 #define·__Pyx_DECREF_TypeName(obj)
1908 #endif1900 #endif
  
 1901 /*·PyObjectCallMethod0.proto·*/
 1902 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name);
  
 1903 /*·GetTypeDictOffset.proto·*/
 1904 #if·!CYTHON_USE_TYPE_SLOTS
 1905 CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result);
 1906 #endif
  
1909 /*·IgnoreException.proto·*/1907 /*·IgnoreException.proto·*/
1910 static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);1908 static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);
1911 #define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)1909 #define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)
  
1912 /*·CheckUnpickleChecksumError.export·*/1910 /*·CheckUnpickleChecksumError.export·*/
1913 static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);1911 static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);
  
1914 /*·PyObjectCallMethod1.proto·*/1912 /*·PyObjectCallMethod1.proto·*/
1915 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);1913 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);
  
 1914 /*·RaiseArgTupleInvalid.export·*/
 1915 static·void·__Pyx_RaiseArgtupleInvalid(const·char*·func_name,·int·exact,
 1916 ····Py_ssize_t·num_min,·Py_ssize_t·num_max,·Py_ssize_t·num_found);
1916 /*·AddModuleRef.proto·*/ 
1917 #if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\ 
1918 ·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000) 
1919 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name); 
1920 #else 
1921 ··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name) 
1922 #endif 
  
1923 /*·IncludeStringH.proto·*/ 
1924 #include·<string.h> 
  
1925 /*·VerifyCachedType.proto·*/ 
1926 static·int·__Pyx_VerifyCachedType(PyObject·*cached_type, 
1927 ·······························const·char·*name, 
1928 ·······························Py_ssize_t·expected_basicsize); 
  
1929 /*·CallTypeTraverse.proto·*/ 
1930 #if·!CYTHON_USE_TYPE_SPECS 
1931 #define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0 
1932 #else 
1933 static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg); 
1934 #endif 
  
1935 /*·PyObjectCall.proto·*/ 
1936 #if·CYTHON_COMPILING_IN_CPYTHON 
1937 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw); 
1938 #else 
1939 #define·__Pyx_PyObject_Call(func,·arg,·kw)·PyObject_Call(func,·arg,·kw) 
1940 #endif 
  
1941 /*·PyObjectCallMethO.proto·*/ 
1942 #if·CYTHON_COMPILING_IN_CPYTHON 
1943 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg); 
1944 #endif 
  
1945 /*·py_dict_items.proto·*/1917 /*·py_dict_items.proto·*/
1946 #define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)1918 #define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)
1947 #define·__Pyx_PyDict_items_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictItems_TypePtr)1919 #define·__Pyx_PyDict_items_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictItems_TypePtr)
1948 #define·__Pyx_PyDict_items_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictItems_TypePtr)1920 #define·__Pyx_PyDict_items_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictItems_TypePtr)
1949 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);1921 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);
  
Offset 1964, 14 lines modifiedOffset 1933, 26 lines modified
1964 #define·__Pyx_CallCFunctionWithKeywords(cfunc,·self,·args,·kwargs)\1933 #define·__Pyx_CallCFunctionWithKeywords(cfunc,·self,·args,·kwargs)\
1965 ····((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self,·args,·kwargs)1934 ····((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self,·args,·kwargs)
1966 #define·__Pyx_CallCFunctionFast(cfunc,·self,·args,·nargs)\1935 #define·__Pyx_CallCFunctionFast(cfunc,·self,·args,·nargs)\
1967 ····((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self,·args,·nargs)1936 ····((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self,·args,·nargs)
1968 #define·__Pyx_CallCFunctionFastWithKeywords(cfunc,·self,·args,·nargs,·kwnames)\1937 #define·__Pyx_CallCFunctionFastWithKeywords(cfunc,·self,·args,·nargs,·kwnames)\
1969 ····((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self,·args,·nargs,·kwnames)1938 ····((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self,·args,·nargs,·kwnames)
  
 1939 /*·PyObjectCall.proto·(used·by·PyObjectFastCall)·*/
 1940 #if·CYTHON_COMPILING_IN_CPYTHON
 1941 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw);
 1942 #else
 1943 #define·__Pyx_PyObject_Call(func,·arg,·kw)·PyObject_Call(func,·arg,·kw)
 1944 #endif
  
 1945 /*·PyObjectCallMethO.proto·(used·by·PyObjectFastCall)·*/
 1946 #if·CYTHON_COMPILING_IN_CPYTHON
 1947 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg);
 1948 #endif
  
1970 /*·PyObjectFastCall.proto·(used·by·PyObjectCallOneArg)·*/1949 /*·PyObjectFastCall.proto·(used·by·PyObjectCallOneArg)·*/
1971 #define·__Pyx_PyObject_FastCall(func,·args,·nargs)··__Pyx_PyObject_FastCallDict(func,·args,·(size_t)(nargs),·NULL)1950 #define·__Pyx_PyObject_FastCall(func,·args,·nargs)··__Pyx_PyObject_FastCallDict(func,·args,·(size_t)(nargs),·NULL)
1972 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_FastCallDict(PyObject·*func,·PyObject·*·const*args,·size_t·nargsf,·PyObject·*kwargs);1951 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_FastCallDict(PyObject·*func,·PyObject·*·const*args,·size_t·nargsf,·PyObject·*kwargs);
  
1973 /*·PyObjectCallOneArg.proto·(used·by·CallUnboundCMethod0)·*/1952 /*·PyObjectCallOneArg.proto·(used·by·CallUnboundCMethod0)·*/
1974 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallOneArg(PyObject·*func,·PyObject·*arg);1953 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallOneArg(PyObject·*func,·PyObject·*arg);
  
Offset 2024, 31 lines modifiedOffset 2005, 53 lines modified
  
2024 /*·py_dict_values.proto·*/2005 /*·py_dict_values.proto·*/
2025 #define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)2006 #define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)
2026 #define·__Pyx_PyDict_values_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictValues_TypePtr)2007 #define·__Pyx_PyDict_values_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictValues_TypePtr)
2027 #define·__Pyx_PyDict_values_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictValues_TypePtr)2008 #define·__Pyx_PyDict_values_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictValues_TypePtr)
2028 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);2009 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);
  
 2010 /*·RaiseDoubleKeywords.proto·*/
 2011 static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);
  
2029 /*·CalculateMetaclass.proto·*/2012 /*·CalculateMetaclass.proto·*/
2030 static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);2013 static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);
  
2031 /*·CopyObjectArray.proto·*/2014 /*·CopyObjectArray.proto·*/
2032 #if·CYTHON_COMPILING_IN_CPYTHON2015 #if·CYTHON_COMPILING_IN_CPYTHON
2033 static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length);2016 static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length);
2034 #endif2017 #endif
  
 2018 /*·IncludeStringH.proto·*/
 2019 #include·<string.h>
  
2035 /*·GetVTable.proto·*/2020 /*·GetVTable.proto·*/
2036 static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);2021 static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);
  
2037 /*·RaiseArgTupleInvalid.export·*/ 
2038 static·void·__Pyx_RaiseArgtupleInvalid(const·char*·func_name,·int·exact, 
2039 ····Py_ssize_t·num_min,·Py_ssize_t·num_max,·Py_ssize_t·num_found);2022 /*·AddModuleRef.proto·*/
 2023 #if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\
 2024 ·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000)
 2025 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name);
 2026 #else
 2027 ··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name)
 2028 #endif
  
2040 /*·RaiseDoubleKeywords.proto·*/ 
2041 static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);2029 /*·VerifyCachedType.proto·*/
 2030 static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
 2031 ·······························const·char·*name,
 2032 ·······························Py_ssize_t·expected_basicsize);
  
 2033 /*·CallTypeTraverse.proto·*/
 2034 #if·!CYTHON_USE_TYPE_SPECS
 2035 #define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0
 2036 #else
 2037 static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg);
 2038 #endif
  
 2039 /*·pybuiltin_invalid.export·*/
 2040 static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname);
  
2042 /*·RaiseErrorWithObjectType.proto·(used·by·ValidateBasesTuple)·*/2041 /*·RaiseErrorWithObjectType.proto·(used·by·ValidateBasesTuple)·*/
2043 #define·__Pyx_RaiseTypeErrorWithObjectType(message,·obj)··__Pyx_RaiseErrorWithObjectType(PyExc_TypeError,·message,·obj)2042 #define·__Pyx_RaiseTypeErrorWithObjectType(message,·obj)··__Pyx_RaiseErrorWithObjectType(PyExc_TypeError,·message,·obj)
2044 #define·__Pyx_RaiseErrorWithObjectType(exc_type,·message,·obj)··__Pyx_RaiseErrorWithType(exc_type,·message,·Py_TYPE(obj))2043 #define·__Pyx_RaiseErrorWithObjectType(exc_type,·message,·obj)··__Pyx_RaiseErrorWithType(exc_type,·message,·Py_TYPE(obj))
2045 CYTHON_UNUSED2044 CYTHON_UNUSED
2046 static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj);2045 static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj);
  
Offset 2085, 14 lines modifiedOffset 2088, 93 lines modified
  
2085 /*·SetupReduce.export·*/2088 /*·SetupReduce.export·*/
2086 static·int·__Pyx_setup_reduce(PyObject*·type_obj);2089 static·int·__Pyx_setup_reduce(PyObject*·type_obj);
  
2087 /*·ValidateExternBase.export·*/2090 /*·ValidateExternBase.export·*/
2088 static·int·__Pyx_validate_extern_base(PyTypeObject·*base);2091 static·int·__Pyx_validate_extern_base(PyTypeObject·*base);
  
 2092 /*·ArgTypeTestError.export·*/
 2093 static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);
  
 2094 /*·UpdateUnpickledDict.export·*/
 2095 static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index);
  
 2096 /*·FindInheritedMetaclass.proto·*/
 2097 static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases);
  
 2098 /*·OwnedDictNext.proto·*/
 2099 #if·CYTHON_AVOID_BORROWED_REFS
 2100 static·int·__Pyx_PyDict_NextRef(PyObject·*p,·PyObject·**ppos,·PyObject·**pkey,·PyObject·**pvalue);
 2101 #else
 2102 CYTHON_INLINE
 2103 static·int·__Pyx_PyDict_NextRef(PyObject·*p,·Py_ssize_t·*ppos,·PyObject·**pkey,·PyObject·**pvalue);
 2104 #endif
  
 2105 /*·PyObjectLookupSpecial.proto·*/
 2106 #if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS
 2107 #define·__Pyx_PyObject_LookupSpecialNoError(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·0)
 2108 #define·__Pyx_PyObject_LookupSpecial(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·1)
 2109 static·CYTHON_INLINE·PyObject*·__Pyx__PyObject_LookupSpecial(PyObject*·obj,·PyObject*·attr_name,·int·with_error);
 2110 #else
 2111 #define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n)
 2112 #define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n)
 2113 #endif
  
 2114 /*·RaiseErrorWithObjectTypes.proto·*/
 2115 #define·__Pyx_RaiseErrorWithObjectTypes1(exc_type,·message,·arg,·obj1,·obj2)·__Pyx_RaiseErrorWithTypes1(exc_type,·message,·arg,·Py_TYPE(obj1),·Py_TYPE(obj2))
 2116 #define·__Pyx_RaiseTypeErrorWithObjectTypes(message,·obj1,·obj2)·__Pyx_RaiseTypeErrorWithTypes(message,·Py_TYPE(obj1),·Py_TYPE(obj2))
 2117 #define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2)
 2118 CYTHON_UNUSED
 2119 static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2);
  
 2120 /*·ParseKeywordsImpl.export·*/
 2121 static·int·__Pyx_ParseKeywordsTuple(
 2122 ····PyObject·*kwds,
 2123 ····PyObject·*·const·*kwvalues,
 2124 ····PyObject·**·const·argnames[],
 2125 ····PyObject·*kwds2,
 2126 ····PyObject·*values[],
 2127 ····Py_ssize_t·num_pos_args,
 2128 ····Py_ssize_t·num_kwargs,
 2129 ····const·char*·function_name,
 2130 ····int·ignore_unknown_kwargs
 2131 );
 2132 static·int·__Pyx_ParseKeywordDictToDict(
 2133 ····PyObject·*kwds,
 2134 ····PyObject·**·const·argnames[],
 2135 ····PyObject·*kwds2,
 2136 ····PyObject·*values[],
 2137 ····Py_ssize_t·num_pos_args,
 2138 ····const·char*·function_name
 2139 );
 2140 static·int·__Pyx_ParseKeywordDict(
 2141 ····PyObject·*kwds,
 2142 ····PyObject·**·const·argnames[],
 2143 ····PyObject·*values[],
 2144 ····Py_ssize_t·num_pos_args,
 2145 ····Py_ssize_t·num_kwargs,
 2146 ····const·char*·function_name,
 2147 ····int·ignore_unknown_kwargs
 2148 );
  
 2149 /*·CallUnboundCMethod2.proto·*/
 2150 CYTHON_UNUSED
 2151 static·PyObject*·__Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction*·cfunc,·PyObject*·self,·PyObject*·arg1,·PyObject*·arg2);
 2152 #if·CYTHON_COMPILING_IN_CPYTHON
 2153 static·CYTHON_INLINE·PyObject·*__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction·*cfunc,·PyObject·*self,·PyObject·*arg1,·PyObject·*arg2);
 2154 #else
 2155 #define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)
 2156 #endif
  
 2157 /*·ImportFrom.export·*/
 2158 static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name);
  
 2159 /*·Py3MetaclassGet.export·*/
 2160 static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw);
  
2089 /*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/2161 /*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/
2090 static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);2162 static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);
  
2091 /*·FetchCommonType.proto·(used·by·CommonTypesMetaclass)·*/2163 /*·FetchCommonType.proto·(used·by·CommonTypesMetaclass)·*/
2092 static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);2164 static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);
  
2093 /*·CommonTypesMetaclass.proto·(used·by·CythonFunctionShared)·*/2165 /*·CommonTypesMetaclass.proto·(used·by·CythonFunctionShared)·*/
Offset 2189, 22 lines modifiedOffset 2271, 14 lines modified
2189 #define·__Pyx_CyFunction_func_vectorcall(f)·(((PyCFunctionObject*)f)->vectorcall)2271 #define·__Pyx_CyFunction_func_vectorcall(f)·(((PyCFunctionObject*)f)->vectorcall)
2190 #endif2272 #endif
2191 #endif2273 #endif
  
2192 /*·PyMethodNew.proto·(used·by·CythonFunctionShared)·*/2274 /*·PyMethodNew.proto·(used·by·CythonFunctionShared)·*/
2193 static·PyObject·*__Pyx_PyMethod_New(PyObject·*func,·PyObject·*self,·PyObject·*typ);2275 static·PyObject·*__Pyx_PyMethod_New(PyObject·*func,·PyObject·*self,·PyObject·*typ);
  
2194 /*·OwnedDictNext.proto·(used·by·PyVectorcallFastCallDict)·*/ 
2195 #if·CYTHON_AVOID_BORROWED_REFS 
2196 static·int·__Pyx_PyDict_NextRef(PyObject·*p,·PyObject·**ppos,·PyObject·**pkey,·PyObject·**pvalue); 
2197 #else 
2198 CYTHON_INLINE 
2199 static·int·__Pyx_PyDict_NextRef(PyObject·*p,·Py_ssize_t·*ppos,·PyObject·**pkey,·PyObject·**pvalue); 
2200 #endif 
  
2201 /*·PyVectorcallFastCallDict.proto·(used·by·CythonFunctionShared)·*/2276 /*·PyVectorcallFastCallDict.proto·(used·by·CythonFunctionShared)·*/
2202 #if·CYTHON_VECTORCALL2277 #if·CYTHON_VECTORCALL
2203 static·CYTHON_INLINE·PyObject·*__Pyx_PyVectorcall_FastCallDict(PyObject·*func,·__pyx_vectorcallfunc·vc,·PyObject·*const·*args,·size_t·nargs,·PyObject·*kw);2278 static·CYTHON_INLINE·PyObject·*__Pyx_PyVectorcall_FastCallDict(PyObject·*func,·__pyx_vectorcallfunc·vc,·PyObject·*const·*args,·size_t·nargs,·PyObject·*kw);
2204 #endif2279 #endif
  
2205 /*·CythonFunctionShared.proto·*/2280 /*·CythonFunctionShared.proto·*/
2206 static·PyObject·*__Pyx_CyFunction_Init(PyObject·*op_in,·PyMethodDef·*ml,2281 static·PyObject·*__Pyx_CyFunction_Init(PyObject·*op_in,·PyMethodDef·*ml,
Offset 2215, 55 lines modifiedOffset 2289, 25 lines modified
2215 #if·CYTHON_VECTORCALL2289 #if·CYTHON_VECTORCALL
2216 static·PyObject·*·__Pyx_CyFunction_Vectorcall_NOARGS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);2290 static·PyObject·*·__Pyx_CyFunction_Vectorcall_NOARGS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2217 static·PyObject·*·__Pyx_CyFunction_Vectorcall_O(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);2291 static·PyObject·*·__Pyx_CyFunction_Vectorcall_O(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2218 static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);2292 static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2219 static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);2293 static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2220 #endif2294 #endif
  
2221 /*·UpdateUnpickledDict.export·*/ 
2222 static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index); 
  
2223 /*·FindInheritedMetaclass.proto·*/ 
2224 static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases); 
  
2225 /*·pybuiltin_invalid.export·*/ 
2226 static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname); 
  
2227 /*·RaiseException.export·*/2295 /*·RaiseException.export·*/
2228 static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);2296 static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);
  
 2297 /*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/
 2298 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2);
2229 /*·PyObjectLookupSpecial.proto·*/ 
2230 #if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS 
2231 #define·__Pyx_PyObject_LookupSpecialNoError(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·0) 
2232 #define·__Pyx_PyObject_LookupSpecial(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·1) 
2233 static·CYTHON_INLINE·PyObject*·__Pyx__PyObject_LookupSpecial(PyObject*·obj,·PyObject*·attr_name,·int·with_error); 
2234 #else 
2235 #define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n) 
2236 #define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n) 
2237 #endif 
  
2238 /*·RaiseErrorWithObjectTypes.proto·*/ 
2239 #define·__Pyx_RaiseErrorWithObjectTypes1(exc_type,·message,·arg,·obj1,·obj2)·__Pyx_RaiseErrorWithTypes1(exc_type,·message,·arg,·Py_TYPE(obj1),·Py_TYPE(obj2)) 
2240 #define·__Pyx_RaiseTypeErrorWithObjectTypes(message,·obj1,·obj2)·__Pyx_RaiseTypeErrorWithTypes(message,·Py_TYPE(obj1),·Py_TYPE(obj2)) 
2241 #define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2) 
2242 CYTHON_UNUSED 
2243 static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2); 
  
2244 /*·ImportFrom.export·*/ 
2245 static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name); 
  
2246 /*·JoinPyUnicode.proto·*/ 
2247 #define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\ 
2248 ····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API) 
  
2249 /*·JoinPyUnicode.export·*/ 
2250 static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind); 
  
2251 /*·ArgTypeTestError.export·*/ 
2252 static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);2299 /*·Py3ClassCreate.export·*/
 2300 static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname,
 2301 ···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc);
 2302 static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict,
 2303 ······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass);
  
2253 /*·HasAttr.proto·(used·by·ImportImpl)·*/2304 /*·HasAttr.proto·(used·by·ImportImpl)·*/
2254 #if·__PYX_LIMITED_VERSION_HEX·>=·0x030d00002305 #if·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
2255 #define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)2306 #define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)
2256 #else2307 #else
2257 static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);2308 static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);
2258 #endif2309 #endif
Offset 2274, 79 lines modifiedOffset 2318, 38 lines modified
  
2274 /*·ListFromArray.proto·(used·by·ImportImpl)·*/2318 /*·ListFromArray.proto·(used·by·ImportImpl)·*/
  
  
2275 /*·ImportImpl.export·*/2319 /*·ImportImpl.export·*/
2276 static·PyObject·*__Pyx__Import(PyObject·*name,·PyObject·*const·*imported_names,·Py_ssize_t·len_imported_names,·PyObject·*qualname,·PyObject·*moddict,·int·level);2320 static·PyObject·*__Pyx__Import(PyObject·*name,·PyObject·*const·*imported_names,·Py_ssize_t·len_imported_names,·PyObject·*qualname,·PyObject·*moddict,·int·level);
  
2277 /*·Py3MetaclassGet.export·*/ 
2278 static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw); 
  
2279 /*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/ 
2280 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2); 
  
2281 /*·Py3ClassCreate.export·*/ 
2282 static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname, 
2283 ···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc); 
2284 static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict, 
2285 ······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass); 
  
2286 /*·MergeVTables.proto·*/2321 /*·MergeVTables.proto·*/
2287 static·int·__Pyx_MergeVtables(PyTypeObject·*type);2322 static·int·__Pyx_MergeVtables(PyTypeObject·*type);
  
 2323 /*·JoinPyUnicode.proto·*/
 2324 #define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\
 2325 ····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API)
2288 /*·ParseKeywordsImpl.export·*/ 
2289 static·int·__Pyx_ParseKeywordsTuple( 
2290 ····PyObject·*kwds, 
2291 ····PyObject·*·const·*kwvalues, 
2292 ····PyObject·**·const·argnames[], 
2293 ····PyObject·*kwds2, 
2294 ····PyObject·*values[], 
2295 ····Py_ssize_t·num_pos_args, 
2296 ····Py_ssize_t·num_kwargs, 
2297 ····const·char*·function_name, 
2298 ····int·ignore_unknown_kwargs 
2299 ); 
2300 static·int·__Pyx_ParseKeywordDictToDict( 
2301 ····PyObject·*kwds, 
2302 ····PyObject·**·const·argnames[], 
2303 ····PyObject·*kwds2, 
2304 ····PyObject·*values[], 
2305 ····Py_ssize_t·num_pos_args, 
2306 ····const·char*·function_name 
2307 ); 
2308 static·int·__Pyx_ParseKeywordDict( 
2309 ····PyObject·*kwds, 
2310 ····PyObject·**·const·argnames[], 
2311 ····PyObject·*values[], 
2312 ····Py_ssize_t·num_pos_args, 
2313 ····Py_ssize_t·num_kwargs, 
2314 ····const·char*·function_name, 
2315 ····int·ignore_unknown_kwargs 
2316 ); 
  
2317 /*·CallUnboundCMethod2.proto·*/ 
2318 CYTHON_UNUSED 
2319 static·PyObject*·__Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction*·cfunc,·PyObject*·self,·PyObject*·arg1,·PyObject*·arg2); 
2320 #if·CYTHON_COMPILING_IN_CPYTHON 
2321 static·CYTHON_INLINE·PyObject·*__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction·*cfunc,·PyObject·*self,·PyObject·*arg1,·PyObject·*arg2); 
2322 #else 
2323 #define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2) 
2324 #endif2326 /*·JoinPyUnicode.export·*/
 2327 static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind);
  
 2328 /*·Py3UpdateBases.export·*/
 2329 static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases);
  
 2330 /*·RejectKeywords.export·*/
 2331 static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds);
  
2325 /*·CythonFunction.export·*/2332 /*·CythonFunction.export·*/
2326 static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,2333 static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,
2327 ······································int·flags,·PyObject*·qualname,2334 ······································int·flags,·PyObject*·qualname,
2328 ······································PyObject·*closure,2335 ······································PyObject·*closure,
2329 ······································PyObject·*module,·PyObject·*globals,2336 ······································PyObject·*module,·PyObject·*globals,
2330 ······································PyObject*·code);2337 ······································PyObject*·code);
2331 static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);2338 static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);
  
2332 /*·Py3UpdateBases.export·*/ 
2333 static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases); 
  
2334 /*·FusedFunctionPerModule.proto·(used·by·FusedFunction)·*/2339 /*·FusedFunctionPerModule.proto·(used·by·FusedFunction)·*/
2335 #if·CYTHON_OPAQUE_SHARED_TYPES2340 #if·CYTHON_OPAQUE_SHARED_TYPES
2336 #define·__Pyx_as_FusedFunctionObject(o)·((__pyx_FusedFunctionObject·*)PyObject_GetTypeData((o),·__pyx_mstate_global->__pyx_FusedFunctionType))2341 #define·__Pyx_as_FusedFunctionObject(o)·((__pyx_FusedFunctionObject·*)PyObject_GetTypeData((o),·__pyx_mstate_global->__pyx_FusedFunctionType))
2337 #else2342 #else
2338 #define·__Pyx_as_FusedFunctionObject(o)·((__pyx_FusedFunctionObject*)o)2343 #define·__Pyx_as_FusedFunctionObject(o)·((__pyx_FusedFunctionObject*)o)
2339 #endif2344 #endif
2340 typedef·struct·{2345 typedef·struct·{
Offset 2365, 17 lines modifiedOffset 2368, 14 lines modified
2365 /*·FusedFunction.export·*/2368 /*·FusedFunction.export·*/
2366 static·PyObject·*__pyx_FusedFunction_New(PyMethodDef·*ml,·int·flags,2369 static·PyObject·*__pyx_FusedFunction_New(PyMethodDef·*ml,·int·flags,
2367 ·········································PyObject·*qualname,·PyObject·*closure,2370 ·········································PyObject·*qualname,·PyObject·*closure,
2368 ·········································PyObject·*module,·PyObject·*globals,2371 ·········································PyObject·*module,·PyObject·*globals,
2369 ·········································PyObject·*code);2372 ·········································PyObject·*code);
2370 static·PyTypeObject·*__Pyx_Get_FusedFunction_Type(void);2373 static·PyTypeObject·*__Pyx_Get_FusedFunction_Type(void);
  
2371 /*·RejectKeywords.export·*/ 
2372 static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds); 
  
2373 /*·SetVTable.export·*/2374 /*·SetVTable.export·*/
2374 static·int·__Pyx_SetVtable(PyTypeObject*·typeptr·,·void*·vtable);2375 static·int·__Pyx_SetVtable(PyTypeObject*·typeptr·,·void*·vtable);
  
2375 /*·GCCDiagnostics.proto·(used·by·CIntToPy)·*/2376 /*·GCCDiagnostics.proto·(used·by·CIntToPy)·*/
2376 #if·!defined(__INTEL_COMPILER)·&&·defined(__GNUC__)·&&·(__GNUC__·>·4·||·(__GNUC__·==·4·&&·__GNUC_MINOR__·>=·6))2377 #if·!defined(__INTEL_COMPILER)·&&·defined(__GNUC__)·&&·(__GNUC__·>·4·||·(__GNUC__·==·4·&&·__GNUC_MINOR__·>=·6))
2377 #define·__Pyx_HAS_GCC_DIAGNOSTIC2378 #define·__Pyx_HAS_GCC_DIAGNOSTIC
2378 #endif2379 #endif
Offset 3859, 50 lines modifiedOffset 3859, 14 lines modified
3859 ····PyTraceBack_Here(py_frame);3859 ····PyTraceBack_Here(py_frame);
3860 bad:3860 bad:
3861 ····Py_XDECREF(py_code);3861 ····Py_XDECREF(py_code);
3862 ····Py_XDECREF(py_frame);3862 ····Py_XDECREF(py_frame);
3863 }3863 }
3864 #endif3864 #endif
  
3865 /*·PyObjectCallMethod0·*/ 
3866 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name)·{ 
3867 #if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API) 
3868 ····return·PyObject_VectorcallMethod(method_name,·&obj,·1·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL); 
3869 #elif·CYTHON_COMPILING_IN_LIMITED_API 
3870 ····return·PyObject_CallMethodObjArgs(obj,·method_name,·NULL); 
3871 #else 
3872 ····return·PyObject_CallMethodNoArgs(obj,·method_name); 
3873 #endif 
3874 } 
  
3875 /*·GetTypeDictOffset·*/ 
3876 #if·!CYTHON_USE_TYPE_SLOTS 
3877 CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result)·{ 
3878 ····PyObject·*tp_dictoffset_o; 
3879 ····Py_ssize_t·tp_dictoffset; 
3880 ····tp_dictoffset_o·=·PyObject_GetAttrString(tp,·"__dictoffset__"); 
3881 ····if·(unlikely(!tp_dictoffset_o))·return·-1; 
3882 ····tp_dictoffset·=·PyLong_AsSsize_t(tp_dictoffset_o); 
3883 ····Py_DECREF(tp_dictoffset_o); 
3884 ····if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·==·0))·{ 
3885 ········PyErr_SetString( 
3886 ············PyExc_TypeError, 
3887 ············"'type'·doesn't·have·a·dictoffset"); 
3888 ········return·-1; 
3889 ····}·else·if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·<·0))·{ 
3890 ········PyErr_SetString( 
3891 ············PyExc_TypeError, 
3892 ············"'type'·has·an·unexpected·negative·dictoffset.·" 
3893 ············"Please·report·this·as·Cython·bug"); 
3894 ········return·-1; 
3895 ····} 
3896 ····return·tp_dictoffset; 
3897 } 
3898 #endif 
  
3899 /*·FormatTypeName·*/3865 /*·FormatTypeName·*/
3900 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d00003866 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
3901 static·__Pyx_TypeName3867 static·__Pyx_TypeName
3902 __Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)3868 __Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)
3903 {3869 {
3904 ····PyObject·*module·=·NULL,·*name·=·NULL,·*result·=·NULL;3870 ····PyObject·*module·=·NULL,·*name·=·NULL,·*result·=·NULL;
3905 ····#if·__PYX_LIMITED_VERSION_HEX·<·0x030b00003871 ····#if·__PYX_LIMITED_VERSION_HEX·<·0x030b0000
Offset 3934, 14 lines modifiedOffset 3898, 50 lines modified
3934 ····}·else·{3898 ····}·else·{
3935 ········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);3899 ········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);
3936 ····}3900 ····}
3937 ····goto·done;3901 ····goto·done;
3938 }3902 }
3939 #endif3903 #endif
  
 3904 /*·PyObjectCallMethod0·*/
 3905 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name)·{
 3906 #if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)
 3907 ····return·PyObject_VectorcallMethod(method_name,·&obj,·1·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);
 3908 #elif·CYTHON_COMPILING_IN_LIMITED_API
 3909 ····return·PyObject_CallMethodObjArgs(obj,·method_name,·NULL);
 3910 #else
 3911 ····return·PyObject_CallMethodNoArgs(obj,·method_name);
 3912 #endif
 3913 }
  
 3914 /*·GetTypeDictOffset·*/
 3915 #if·!CYTHON_USE_TYPE_SLOTS
 3916 CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result)·{
 3917 ····PyObject·*tp_dictoffset_o;
 3918 ····Py_ssize_t·tp_dictoffset;
 3919 ····tp_dictoffset_o·=·PyObject_GetAttrString(tp,·"__dictoffset__");
 3920 ····if·(unlikely(!tp_dictoffset_o))·return·-1;
 3921 ····tp_dictoffset·=·PyLong_AsSsize_t(tp_dictoffset_o);
 3922 ····Py_DECREF(tp_dictoffset_o);
 3923 ····if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·==·0))·{
 3924 ········PyErr_SetString(
 3925 ············PyExc_TypeError,
 3926 ············"'type'·doesn't·have·a·dictoffset");
 3927 ········return·-1;
 3928 ····}·else·if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·<·0))·{
 3929 ········PyErr_SetString(
 3930 ············PyExc_TypeError,
 3931 ············"'type'·has·an·unexpected·negative·dictoffset.·"
 3932 ············"Please·report·this·as·Cython·bug");
 3933 ········return·-1;
 3934 ····}
 3935 ····return·tp_dictoffset;
 3936 }
 3937 #endif
  
3940 /*·IgnoreException·*/3938 /*·IgnoreException·*/
3941 static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{3939 static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{
3942 ····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{3940 ····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{
3943 ········PyErr_Clear();3941 ········PyErr_Clear();
3944 ········return·1;3942 ········return·1;
3945 ····}3943 ····}
3946 ····return·0;3944 ····return·0;
Offset 3975, 119 lines modifiedOffset 3975, 41 lines modified
3975 #elif·CYTHON_COMPILING_IN_LIMITED_API3975 #elif·CYTHON_COMPILING_IN_LIMITED_API
3976 ····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);3976 ····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);
3977 #else3977 #else
3978 ····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);3978 ····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);
3979 #endif3979 #endif
3980 }3980 }
  
 3981 /*·RaiseArgTupleInvalid·*/
 3982 static·void·__Pyx_RaiseArgtupleInvalid(
 3983 ····const·char*·func_name,
 3984 ····int·exact,
 3985 ····Py_ssize_t·num_min,
 3986 ····Py_ssize_t·num_max,
 3987 ····Py_ssize_t·num_found)
 3988 {
 3989 ····Py_ssize_t·num_expected;
 3990 ····const·char·*more_or_less;
 3991 ····if·(num_found·<·num_min)·{
 3992 ········num_expected·=·num_min;
 3993 ········more_or_less·=·"at·least";
3981 /*·AddModuleRef·*/ 
3982 #if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3 
3983 ··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{ 
3984 ······PyObject·*module_dict·=·PyImport_GetModuleDict(); 
3985 ······PyObject·*m; 
3986 ······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{ 
3987 ··········return·NULL; 
3988 ······} 
3989 ······if·(m·!=·NULL·&&·PyModule_Check(m))·{ 
3990 ··········return·m; 
3991 ······} 
3992 ······Py_XDECREF(m); 
3993 ······m·=·PyModule_NewObject(name); 
3994 ······if·(m·==·NULL) 
3995 ··········return·NULL; 
3996 ······if·(PyDict_CheckExact(module_dict))·{ 
3997 ··········PyObject·*new_m; 
3998 ··········(void)PyDict_SetDefaultRef(module_dict,·name,·m,·&new_m); 
3999 ··········Py_DECREF(m); 
4000 ··········return·new_m; 
4001 ······}·else·{3994 ····}·else·{
 3995 ········num_expected·=·num_max;
 3996 ········more_or_less·=·"at·most";
4002 ···········if·(PyObject_SetItem(module_dict,·name,·m)·!=·0)·{ 
4003 ················Py_DECREF(m); 
4004 ················return·NULL; 
4005 ············} 
4006 ············return·m; 
4007 ······} 
4008 ··} 
4009 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{ 
4010 ······if·((PY_VERSION_HEX·>=·0x030E0000)·&&··Py_Version·>=·0x030E0100)·{ 
4011 ··········return·PyImport_AddModuleRef(name); 
4012 ······} 
4013 ······PyObject·*py_name·=·PyUnicode_FromString(name); 
4014 ······if·(!py_name)·return·NULL; 
4015 ······PyObject·*module·=·__Pyx_PyImport_AddModuleObjectRef(py_name); 
4016 ······Py_DECREF(py_name); 
4017 ······return·module; 
4018 ··} 
4019 #elif·__PYX_LIMITED_VERSION_HEX·<·0x030d0000 
4020 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{ 
4021 ······PyObject·*module·=·PyImport_AddModule(name); 
4022 ······Py_XINCREF(module); 
4023 ······return·module; 
4024 ··} 
4025 #endif 
  
4026 /*·VerifyCachedType·*/ 
4027 static·int·__Pyx_VerifyCachedType(PyObject·*cached_type, 
4028 ·······························const·char·*name, 
4029 ·······························Py_ssize_t·expected_basicsize)·{ 
4030 ····Py_ssize_t·basicsize; 
4031 ····if·(!PyType_Check(cached_type))·{ 
4032 ········PyErr_Format(PyExc_TypeError, 
4033 ············"Shared·Cython·type·%.200s·is·not·a·type·object",·name); 
4034 ········return·-1; 
4035 ····} 
4036 ····if·(expected_basicsize·==·0)·{ 
4037 ········return·0;·//·size·is·inherited,·nothing·useful·to·check 
4038 ····} 
4039 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·CYTHON_OPAQUE_OBJECTS 
4040 ····if·(expected_basicsize·<·0)·{ 
4041 ········basicsize·=·PyType_GetTypeDataSize((PyTypeObject*)cached_type); 
4042 ····}·else 
4043 #endif 
4044 ····{ 
4045 ····#if·CYTHON_COMPILING_IN_LIMITED_API 
4046 ········PyObject·*py_basicsize; 
4047 ········py_basicsize·=·PyObject_GetAttrString(cached_type,·"__basicsize__"); 
4048 ········if·(unlikely(!py_basicsize))·return·-1; 
4049 ········basicsize·=·PyLong_AsSsize_t(py_basicsize); 
4050 ········Py_DECREF(py_basicsize); 
4051 ········py_basicsize·=·NULL; 
4052 ········if·(unlikely(basicsize·==·(Py_ssize_t)-1)·&&·PyErr_Occurred())·return·-1; 
4053 ····#else 
4054 ········basicsize·=·((PyTypeObject*)·cached_type)->tp_basicsize; 
4055 ····#endif 
4056 ····} 
4057 ····if·((expected_basicsize·>=·0)·? 
4058 ············(basicsize·!=·expected_basicsize)·: 
4059 ············(basicsize·<·-expected_basicsize))·{ 
4060 ········PyErr_Format(PyExc_TypeError, 
4061 ············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling", 
4062 ············name); 
4063 ········return·-1; 
4064 ····}3997 ····}
 3998 ····if·(exact)·{
 3999 ········more_or_less·=·"exactly";
4065 ····return·0; 
4066 } 
  
4067 /*·CallTypeTraverse·*/ 
4068 #if·!CYTHON_USE_TYPE_SPECS 
4069 #else 
4070 static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{ 
4071 ····if·(!always_call)·{ 
4072 ········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*); 
4073 ········unsigned·long·flags·=·PyType_GetFlags(base); 
4074 ········if·(flags·&·Py_TPFLAGS_HEAPTYPE)·{ 
4075 ············return·0; 
4076 ········} 
4077 ····}4000 ····}
4078 ····Py_VISIT((PyObject*)Py_TYPE(o)); 
4079 ····return·0;4001 ····PyErr_Format(PyExc_TypeError,
 4002 ·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)",
 4003 ·················func_name,·more_or_less,·num_expected,
 4004 ·················(num_expected·==·1)·?·""·:·"s",·num_found);
4080 }4005 }
4081 #endif 
  
4082 /*·PyObjectCall·*/4006 /*·PyObjectCall·(used·by·PyObjectFastCall)·*/
4083 #if·CYTHON_COMPILING_IN_CPYTHON4007 #if·CYTHON_COMPILING_IN_CPYTHON
4084 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{4008 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{
4085 ····PyObject·*result;4009 ····PyObject·*result;
4086 ····ternaryfunc·call·=·Py_TYPE(func)->tp_call;4010 ····ternaryfunc·call·=·Py_TYPE(func)->tp_call;
4087 ····if·(unlikely(!call))4011 ····if·(unlikely(!call))
4088 ········return·PyObject_Call(func,·arg,·kw);4012 ········return·PyObject_Call(func,·arg,·kw);
4089 ····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))4013 ····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
Offset 4099, 15 lines modifiedOffset 4021, 15 lines modified
4099 ············PyExc_SystemError,4021 ············PyExc_SystemError,
4100 ············"NULL·result·without·error·in·PyObject_Call");4022 ············"NULL·result·without·error·in·PyObject_Call");
4101 ····}4023 ····}
4102 ····return·result;4024 ····return·result;
4103 }4025 }
4104 #endif4026 #endif
  
4105 /*·PyObjectCallMethO·*/4027 /*·PyObjectCallMethO·(used·by·PyObjectFastCall)·*/
4106 #if·CYTHON_COMPILING_IN_CPYTHON4028 #if·CYTHON_COMPILING_IN_CPYTHON
4107 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg)·{4029 static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg)·{
4108 ····PyObject·*self,·*result;4030 ····PyObject·*self,·*result;
4109 ····PyCFunction·cfunc;4031 ····PyCFunction·cfunc;
4110 ····cfunc·=·__Pyx_CyOrPyCFunction_GET_FUNCTION(func);4032 ····cfunc·=·__Pyx_CyOrPyCFunction_GET_FUNCTION(func);
4111 ····self·=·__Pyx_CyOrPyCFunction_GET_SELF(func);4033 ····self·=·__Pyx_CyOrPyCFunction_GET_SELF(func);
4112 ····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))4034 ····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
Offset 4327, 14 lines modifiedOffset 4249, 23 lines modified
4327 }4249 }
  
4328 /*·py_dict_values·*/4250 /*·py_dict_values·*/
4329 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{4251 static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{
4330 ····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);4252 ····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);
4331 }4253 }
  
 4254 /*·RaiseDoubleKeywords·*/
 4255 static·void·__Pyx_RaiseDoubleKeywordsError(
 4256 ····const·char*·func_name,
 4257 ····PyObject*·kw_name)
 4258 {
 4259 ····PyErr_Format(PyExc_TypeError,
 4260 ········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);
 4261 }
  
4332 /*·CalculateMetaclass·*/4262 /*·CalculateMetaclass·*/
4333 static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{4263 static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{
4334 ····Py_ssize_t·i,·nbases;4264 ····Py_ssize_t·i,·nbases;
4335 #if·CYTHON_ASSUME_SAFE_SIZE4265 #if·CYTHON_ASSUME_SAFE_SIZE
4336 ····nbases·=·PyTuple_GET_SIZE(bases);4266 ····nbases·=·PyTuple_GET_SIZE(bases);
4337 #else4267 #else
4338 ····nbases·=·PyTuple_Size(bases);4268 ····nbases·=·PyTuple_Size(bases);
Offset 4406, 47 lines modifiedOffset 4337, 136 lines modified
4406 ····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{4337 ····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{
4407 ········return·0;4338 ········return·0;
4408 ····}4339 ····}
4409 ····Py_XDECREF(ob);4340 ····Py_XDECREF(ob);
4410 ····return·-1;4341 ····return·-1;
4411 }4342 }
  
4412 /*·RaiseArgTupleInvalid·*/ 
4413 static·void·__Pyx_RaiseArgtupleInvalid( 
4414 ····const·char*·func_name, 
4415 ····int·exact, 
4416 ····Py_ssize_t·num_min, 
4417 ····Py_ssize_t·num_max, 
4418 ····Py_ssize_t·num_found) 
4419 { 
4420 ····Py_ssize_t·num_expected; 
4421 ····const·char·*more_or_less; 
4422 ····if·(num_found·<·num_min)·{ 
4423 ········num_expected·=·num_min; 
4424 ········more_or_less·=·"at·least";4343 /*·AddModuleRef·*/
 4344 #if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3
 4345 ··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{
 4346 ······PyObject·*module_dict·=·PyImport_GetModuleDict();
 4347 ······PyObject·*m;
 4348 ······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{
 4349 ··········return·NULL;
 4350 ······}
 4351 ······if·(m·!=·NULL·&&·PyModule_Check(m))·{
 4352 ··········return·m;
 4353 ······}
 4354 ······Py_XDECREF(m);
 4355 ······m·=·PyModule_NewObject(name);
 4356 ······if·(m·==·NULL)
 4357 ··········return·NULL;
 4358 ······if·(PyDict_CheckExact(module_dict))·{
 4359 ··········PyObject·*new_m;
 4360 ··········(void)PyDict_SetDefaultRef(module_dict,·name,·m,·&new_m);
 4361 ··········Py_DECREF(m);
 4362 ··········return·new_m;
4425 ····}·else·{4363 ······}·else·{
4426 ········num_expected·=·num_max; 
4427 ········more_or_less·=·"at·most";4364 ···········if·(PyObject_SetItem(module_dict,·name,·m)·!=·0)·{
 4365 ················Py_DECREF(m);
 4366 ················return·NULL;
 4367 ············}
 4368 ············return·m;
 4369 ······}
 4370 ··}
 4371 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
 4372 ······if·((PY_VERSION_HEX·>=·0x030E0000)·&&··Py_Version·>=·0x030E0100)·{
 4373 ··········return·PyImport_AddModuleRef(name);
 4374 ······}
 4375 ······PyObject·*py_name·=·PyUnicode_FromString(name);
 4376 ······if·(!py_name)·return·NULL;
 4377 ······PyObject·*module·=·__Pyx_PyImport_AddModuleObjectRef(py_name);
 4378 ······Py_DECREF(py_name);
 4379 ······return·module;
 4380 ··}
 4381 #elif·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
 4382 ··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
 4383 ······PyObject·*module·=·PyImport_AddModule(name);
 4384 ······Py_XINCREF(module);
 4385 ······return·module;
 4386 ··}
 4387 #endif
  
 4388 /*·VerifyCachedType·*/
 4389 static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
 4390 ·······························const·char·*name,
 4391 ·······························Py_ssize_t·expected_basicsize)·{
 4392 ····Py_ssize_t·basicsize;
 4393 ····if·(!PyType_Check(cached_type))·{
 4394 ········PyErr_Format(PyExc_TypeError,
 4395 ············"Shared·Cython·type·%.200s·is·not·a·type·object",·name);
 4396 ········return·-1;
4428 ····}4397 ····}
4429 ····if·(exact)·{ 
4430 ········more_or_less·=·"exactly";4398 ····if·(expected_basicsize·==·0)·{
 4399 ········return·0;·//·size·is·inherited,·nothing·useful·to·check
4431 ····}4400 ····}
4432 ····PyErr_Format(PyExc_TypeError, 
4433 ·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)", 
4434 ·················func_name,·more_or_less,·num_expected, 
4435 ·················(num_expected·==·1)·?·""·:·"s",·num_found);4401 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·CYTHON_OPAQUE_OBJECTS
 4402 ····if·(expected_basicsize·<·0)·{
 4403 ········basicsize·=·PyType_GetTypeDataSize((PyTypeObject*)cached_type);
 4404 ····}·else
 4405 #endif
 4406 ····{
 4407 ····#if·CYTHON_COMPILING_IN_LIMITED_API
 4408 ········PyObject·*py_basicsize;
 4409 ········py_basicsize·=·PyObject_GetAttrString(cached_type,·"__basicsize__");
 4410 ········if·(unlikely(!py_basicsize))·return·-1;
 4411 ········basicsize·=·PyLong_AsSsize_t(py_basicsize);
 4412 ········Py_DECREF(py_basicsize);
 4413 ········py_basicsize·=·NULL;
 4414 ········if·(unlikely(basicsize·==·(Py_ssize_t)-1)·&&·PyErr_Occurred())·return·-1;
 4415 ····#else
 4416 ········basicsize·=·((PyTypeObject*)·cached_type)->tp_basicsize;
 4417 ····#endif
 4418 ····}
 4419 ····if·((expected_basicsize·>=·0)·?
 4420 ············(basicsize·!=·expected_basicsize)·:
 4421 ············(basicsize·<·-expected_basicsize))·{
 4422 ········PyErr_Format(PyExc_TypeError,
 4423 ············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling",
 4424 ············name);
 4425 ········return·-1;
 4426 ····}
 4427 ····return·0;
4436 }4428 }
  
4437 /*·RaiseDoubleKeywords·*/ 
4438 static·void·__Pyx_RaiseDoubleKeywordsError( 
4439 ····const·char*·func_name, 
4440 ····PyObject*·kw_name) 
4441 { 
4442 ····PyErr_Format(PyExc_TypeError, 
4443 ········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);4429 /*·CallTypeTraverse·*/
 4430 #if·!CYTHON_USE_TYPE_SPECS
 4431 #else
 4432 static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{
 4433 ····if·(!always_call)·{
 4434 ········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*);
 4435 ········unsigned·long·flags·=·PyType_GetFlags(base);
 4436 ········if·(flags·&·Py_TPFLAGS_HEAPTYPE)·{
 4437 ············return·0;
 4438 ········}
 4439 ····}
 4440 ····Py_VISIT((PyObject*)Py_TYPE(o));
 4441 ····return·0;
 4442 }
 4443 #endif
  
 4444 /*·pybuiltin_invalid·*/
 4445 static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname)·{
 4446 ····__Pyx_TypeName·obj_type_name·=·__Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
 4447 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
 4448 ····if·(unlikely(!obj_type_name))·return;
 4449 ····#endif
 4450 ····if·(argname)·{
 4451 ········PyErr_Format(PyExc_TypeError,
 4452 ············"Argument·'%.200s'·has·incorrect·type·(expected·%.5s,·got·"·__Pyx_FMT_TYPENAME·")",
 4453 ············argname,·builtin_type_name,·obj_type_name
 4454 ········);
 4455 ····}·else·{
 4456 ········PyErr_Format(PyExc_TypeError,
 4457 ············"Expected·%.5s,·got·"·__Pyx_FMT_TYPENAME,
 4458 ············builtin_type_name,·obj_type_name
 4459 ········);
 4460 ····}
 4461 ····__Pyx_DECREF_TypeName(obj_type_name);
4444 }4462 }
  
4445 /*·RaiseErrorWithObjectType·(used·by·ValidateBasesTuple)·*/4463 /*·RaiseErrorWithObjectType·(used·by·ValidateBasesTuple)·*/
4446 static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj)·{4464 static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj)·{
4447 ····__Pyx_TypeName·type_name·=·__Pyx_PyType_GetFullyQualifiedName(type_obj);4465 ····__Pyx_TypeName·type_name·=·__Pyx_PyType_GetFullyQualifiedName(type_obj);
4448 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d00004466 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
4449 ····if·(unlikely(!type_name))·return;4467 ····if·(unlikely(!type_name))·return;
Offset 4844, 14 lines modifiedOffset 4864, 718 lines modified
4844 ············PyExc_TypeError,4864 ············PyExc_TypeError,
4845 ············"inheritance·from·PyVarObject·types·like·'"·__Pyx_FMT_TYPENAME·"'·not·currently·supported",·base);4865 ············"inheritance·from·PyVarObject·types·like·'"·__Pyx_FMT_TYPENAME·"'·not·currently·supported",·base);
4846 ········return·-1;4866 ········return·-1;
4847 ····}4867 ····}
4848 ····return·0;4868 ····return·0;
4849 }4869 }
  
 4870 /*·ArgTypeTestError·*/
 4871 static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact)
 4872 {
 4873 ····__Pyx_TypeName·type_name;
 4874 ····__Pyx_TypeName·obj_type_name;
 4875 ····PyObject·*extra_info·=·__pyx_mstate_global->__pyx_empty_unicode;
 4876 ····int·from_annotation_subclass·=·0;
 4877 ····if·(unlikely(!type))·{
 4878 ········PyErr_SetString(PyExc_SystemError,·"Missing·type·object");
 4879 ········return;
 4880 ····}·else·if·(exact·==·2)·{
 4881 ········if·(__Pyx_TypeCheck(obj,·type))·{
 4882 ············from_annotation_subclass·=·1;
 4883 ············extra_info·=·__pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately;
 4884 ········}
 4885 ····}
 4886 ····type_name·=·__Pyx_PyType_GetFullyQualifiedName(type);
 4887 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
 4888 ····if·(unlikely(!type_name))·return;
 4889 ····#endif
 4890 ····obj_type_name·=·__Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
 4891 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
 4892 ····if·(unlikely(!obj_type_name))·goto·obj_type_name_failed;
 4893 ····#endif
 4894 ····PyErr_Format(PyExc_TypeError,
 4895 ········"Argument·'%.200s'·has·incorrect·type·(expected·"·__Pyx_FMT_TYPENAME·",·got·"·__Pyx_FMT_TYPENAME·")"
 4896 #if·__PYX_LIMITED_VERSION_HEX·<·0x030C0000
 4897 ········"%s%U"
 4898 #endif
 4899 ········,·name,·type_name,·obj_type_name
 4900 #if·__PYX_LIMITED_VERSION_HEX·<·0x030C0000
 4901 ········,·(from_annotation_subclass·?·".·"·:·""),·extra_info
 4902 #endif
 4903 ········);
 4904 #if·__PYX_LIMITED_VERSION_HEX·>=·0x030C0000
 4905 ····if·(exact·==·2·&&·from_annotation_subclass)·{
 4906 ········PyObject·*res;
 4907 ········PyObject·*vargs[2];
 4908 ········vargs[0]·=·PyErr_GetRaisedException();
 4909 ········vargs[1]·=·extra_info;
 4910 ········res·=·PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note,·vargs,·2,·NULL);
 4911 ········Py_XDECREF(res);
 4912 ········PyErr_SetRaisedException(vargs[0]);
 4913 ····}
 4914 #endif
 4915 ····__Pyx_DECREF_TypeName(obj_type_name);
 4916 #if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
 4917 obj_type_name_failed:
 4918 #endif
 4919 ····__Pyx_DECREF_TypeName(type_name);
 4920 ····return;
 4921 }
  
 4922 /*·UpdateUnpickledDict·*/
 4923 static·int·__Pyx__UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index)·{
 4924 ····PyObject·*state_dict·=·__Pyx_PySequence_ITEM(state,·index);
 4925 ····if·(unlikely(!state_dict))·{
 4926 ········return·-1;
 4927 ····}
 4928 ····int·non_empty·=·PyObject_IsTrue(state_dict);
 4929 ····if·(non_empty·==·0)·{
 4930 ········Py_DECREF(state_dict);
 4931 ········return·0;
 4932 ····}·else·if·(unlikely(non_empty·==·-1))·{
 4933 ········return·-1;
 4934 ····}
 4935 ····PyObject·*dict;
 4936 ····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030A0000
 4937 ····dict·=·PyObject_GetAttrString(obj,·"__dict__");
 4938 ····#else
 4939 ····dict·=·PyObject_GenericGetDict(obj,·NULL);
 4940 ····#endif
 4941 ····if·(unlikely(!dict))·{
 4942 ········Py_DECREF(state_dict);
 4943 ········return·-1;
Max diff block lines reached; 42394/104885 bytes (40.42%) of diff not shown.
Generated by diffoscope 330