Offset 1616, 30 lines modified		Offset 1616, 30 lines modified
1616	····#undef·CYTHON_ATOMICS	1616	····#undef·CYTHON_ATOMICS
1617	····#define·CYTHON_ATOMICS·0	1617	····#define·CYTHON_ATOMICS·0
1618	····#ifdef·__PYX_DEBUG_ATOMICS	1618	····#ifdef·__PYX_DEBUG_ATOMICS
1619	········#warning·"Not·using·atomics"	1619	········#warning·"Not·using·atomics"
1620	····#endif	1620	····#endif
1621	#endif	1621	#endif
		1622	/*·IncludeStructmemberH.proto·*/
		1623	#include·<structmember.h>
1622	/*·CriticalSectionsDefinition.proto·*/	1624	/*·CriticalSectionsDefinition.proto·*/
1623	#if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING	1625	#if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
1624	#define·__Pyx_PyCriticalSection·void*	1626	#define·__Pyx_PyCriticalSection·void*
1625	#define·__Pyx_PyCriticalSection2·void*	1627	#define·__Pyx_PyCriticalSection2·void*
1626	#define·__Pyx_PyCriticalSection_End(cs)	1628	#define·__Pyx_PyCriticalSection_End(cs)
1627	#define·__Pyx_PyCriticalSection2_End(cs)	1629	#define·__Pyx_PyCriticalSection2_End(cs)
1628	#else	1630	#else
1629	#define·__Pyx_PyCriticalSection·PyCriticalSection	1631	#define·__Pyx_PyCriticalSection·PyCriticalSection
1630	#define·__Pyx_PyCriticalSection2·PyCriticalSection2	1632	#define·__Pyx_PyCriticalSection2·PyCriticalSection2
1631	#define·__Pyx_PyCriticalSection_End·PyCriticalSection_End	1633	#define·__Pyx_PyCriticalSection_End·PyCriticalSection_End
1632	#define·__Pyx_PyCriticalSection2_End·PyCriticalSection2_End	1634	#define·__Pyx_PyCriticalSection2_End·PyCriticalSection2_End
1633	#endif	1635	#endif
1634	/*·IncludeStructmemberH.proto·*/
1635	#include·<structmember.h>
1636	/*·CriticalSections.proto·(used·by·CythonFunctionShared)·*/	1636	/*·CriticalSections.proto·(used·by·CythonFunctionShared)·*/
1637	#if·!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING	1637	#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	#else	1640	#else
1641	#define·__Pyx_PyCriticalSection_Begin·PyCriticalSection_Begin	1641	#define·__Pyx_PyCriticalSection_Begin·PyCriticalSection_Begin
1642	#define·__Pyx_PyCriticalSection2_Begin·PyCriticalSection2_Begin	1642	#define·__Pyx_PyCriticalSection2_Begin·PyCriticalSection2_Begin
Offset 1877, 36 lines modified		Offset 1877, 44 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	/*·CalculateMetaclass.proto·*/
		1883	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);
1882	/*·IncludeStringH.proto·*/
1883	#include·<string.h>
1884	/*·CopyObjectArray.proto·*/
1885	#if·CYTHON_COMPILING_IN_CPYTHON
1886	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length);
1887	#endif
1888	/*·PyObjectCall.proto·*/	1884	/*·PyObjectCall.proto·*/
1889	#if·CYTHON_COMPILING_IN_CPYTHON	1885	#if·CYTHON_COMPILING_IN_CPYTHON
1890	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw);	1886	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw);
1891	#else	1887	#else
1892	#define·__Pyx_PyObject_Call(func,·arg,·kw)·PyObject_Call(func,·arg,·kw)	1888	#define·__Pyx_PyObject_Call(func,·arg,·kw)·PyObject_Call(func,·arg,·kw)
1893	#endif	1889	#endif
1894	/*·PyObjectCallMethO.proto·*/	1890	/*·PyObjectCallMethO.proto·*/
1895	#if·CYTHON_COMPILING_IN_CPYTHON	1891	#if·CYTHON_COMPILING_IN_CPYTHON
1896	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg);	1892	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg);
1897	#endif	1893	#endif
1898	/*·GetVTable.proto·*/
1899	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);	1894	/*·IgnoreException.proto·*/
		1895	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);
		1896	#define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)
		1897	/*·UnpackUnboundCMethod_decl.proto·*/
		1898	typedef·struct·{
		1899	····PyObject·*type;
		1900	····PyObject·**method_name;
		1901	····PyCFunction·func;
		1902	····PyObject·*method;
		1903	····int·flag;
		1904	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·CYTHON_ATOMICS
		1905	····__pyx_atomic_int_type·initialized;
		1906	#endif
		1907	}·__Pyx_CachedCFunction;
1900	/*·FormatTypeName.proto·*/	1908	/*·FormatTypeName.proto·*/
1901	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000	1909	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
1902	typedef·PyObject·*__Pyx_TypeName;	1910	typedef·PyObject·*__Pyx_TypeName;
1903	#define·__Pyx_FMT_TYPENAME·"%N"	1911	#define·__Pyx_FMT_TYPENAME·"%N"
1904	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)	1912	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)
1905	#define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)	1913	#define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)
Offset 1918, 50 lines modified		Offset 1926, 50 lines modified
1918	#else··//·!LIMITED_API	1926	#else··//·!LIMITED_API
1919	typedef·const·char·*__Pyx_TypeName;	1927	typedef·const·char·*__Pyx_TypeName;
1920	#define·__Pyx_FMT_TYPENAME·"%.200s"	1928	#define·__Pyx_FMT_TYPENAME·"%.200s"
1921	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)	1929	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)
1922	#define·__Pyx_DECREF_TypeName(obj)	1930	#define·__Pyx_DECREF_TypeName(obj)
1923	#endif	1931	#endif
1924	/*·CalculateMetaclass.proto·*/
1925	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);
1926	/*·IgnoreException.proto·*/
1927	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);
1928	#define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)
1929	/*·UnpackUnboundCMethod_decl.proto·*/
1930	typedef·struct·{
1931	····PyObject·*type;
1932	····PyObject·**method_name;
1933	····PyCFunction·func;
1934	····PyObject·*method;
1935	····int·flag;
1936	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·CYTHON_ATOMICS
1937	····__pyx_atomic_int_type·initialized;
1938	#endif
1939	}·__Pyx_CachedCFunction;
1940	/*·PyObjectCallMethod0.proto·*/	1932	/*·PyObjectCallMethod0.proto·*/
1941	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name);	1933	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name);
1942	/*·GetTypeDictOffset.proto·*/	1934	/*·GetTypeDictOffset.proto·*/
1943	#if·!CYTHON_USE_TYPE_SLOTS	1935	#if·!CYTHON_USE_TYPE_SLOTS
1944	CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result);	1936	CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result);
1945	#endif	1937	#endif
1946	/*·CheckUnpickleChecksumError.export·*/	1938	/*·CheckUnpickleChecksumError.export·*/
1947	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);	1939	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);
1948	/*·PyObjectCallMethod1.proto·*/	1940	/*·PyObjectCallMethod1.proto·*/
1949	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);	1941	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);
1950	/*·RaiseArgTupleInvalid.export·*/
1951	static·void·__Pyx_RaiseArgtupleInvalid(const·char*·func_name,·int·exact,
1952	····Py_ssize_t·num_min,·Py_ssize_t·num_max,·Py_ssize_t·num_found);	1942	/*·AddModuleRef.proto·*/
		1943	#if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\
		1944	·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000)
		1945	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name);
		1946	#else
		1947	··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name)
		1948	#endif
		1949	/*·IncludeStringH.proto·*/
		1950	#include·<string.h>
		1951	/*·VerifyCachedType.proto·*/
		1952	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
		1953	·······························const·char·*name,
		1954	·······························Py_ssize_t·expected_basicsize);
		1955	/*·CallTypeTraverse.proto·*/
		1956	#if·!CYTHON_USE_TYPE_SPECS
		1957	#define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0
		1958	#else
		1959	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg);
		1960	#endif
1953	/*·py_dict_items.proto·*/	1961	/*·py_dict_items.proto·*/
1954	#define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)	1962	#define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)
1955	#define·__Pyx_PyDict_items_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictItems_TypePtr)	1963	#define·__Pyx_PyDict_items_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictItems_TypePtr)
1956	#define·__Pyx_PyDict_items_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictItems_TypePtr)	1964	#define·__Pyx_PyDict_items_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictItems_TypePtr)
1957	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);	1965	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);
Offset 2019, 95 lines modified		Offset 2027, 56 lines modified
2019	/*·py_dict_values.proto·*/	2027	/*·py_dict_values.proto·*/
2020	#define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)	2028	#define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)
2021	#define·__Pyx_PyDict_values_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictValues_TypePtr)	2029	#define·__Pyx_PyDict_values_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictValues_TypePtr)
2022	#define·__Pyx_PyDict_values_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictValues_TypePtr)	2030	#define·__Pyx_PyDict_values_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictValues_TypePtr)
2023	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);	2031	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);
		2032	/*·CopyObjectArray.proto·*/
		2033	#if·CYTHON_COMPILING_IN_CPYTHON
		2034	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length);
2024	/*·RaiseDoubleKeywords.proto·*/
2025	static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);
2026	/*·AddModuleRef.proto·*/
2027	#if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\
2028	·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000)
2029	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name);
2030	#else
2031	··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name)
2032	#endif	2035	#endif
		2036	/*·GetVTable.proto·*/
		2037	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);
2033	/*·VerifyCachedType.proto·*/
2034	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
2035	·······························const·char·*name,
2036	·······························Py_ssize_t·expected_basicsize);
2037	/*·CallTypeTraverse.proto·*/
2038	#if·!CYTHON_USE_TYPE_SPECS
2039	#define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0
2040	#else
2041	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg);
2042	#endif
2043	/*·JoinPyUnicode.proto·*/
2044	#define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\
2045	····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API)	2038	/*·RaiseArgTupleInvalid.export·*/
		2039	static·void·__Pyx_RaiseArgtupleInvalid(const·char*·func_name,·int·exact,
		2040	····Py_ssize_t·num_min,·Py_ssize_t·num_max,·Py_ssize_t·num_found);
2046	/*·JoinPyUnicode.export·*/
2047	static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind);	2041	/*·RaiseDoubleKeywords.proto·*/
		2042	static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);
2048	/*·RaiseException.export·*/	2043	/*·RaiseException.export·*/
2049	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);	2044	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);
		2045	/*·FindInheritedMetaclass.proto·(used·by·Py3MetaclassGet)·*/
2050	/*·HasAttr.proto·(used·by·ImportImpl)·*/
2051	#if·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
2052	#define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)
2053	#else
2054	static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);
2055	#endif
2056	/*·TupleOrListFromArrayImpl.proto·(used·by·ListFromArray)·*/
2057	CYTHON_UNUSED·static·PyObject·*
2058	__Pyx_PyList_FromArray(PyObject·*const·*src,·Py_ssize_t·n);
2059	/*·ListFromArray.proto·(used·by·ImportImpl)·*/
2060	/*·ImportImpl.export·*/
2061	static·PyObject·*__Pyx__Import(PyObject·*name,·PyObject·*const·*imported_names,·Py_ssize_t·len_imported_names,·PyObject·*qualname,·PyObject·*moddict,·int·level);
2062	/*·ImportFrom.export·*/
2063	static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name);
2064	/*·FindInheritedMetaclass.proto·*/
2065	static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases);	2046	static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases);
		2047	/*·Py3MetaclassGet.export·*/
		2048	static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw);
2066	/*·RaiseErrorWithObjectTypes.proto·(used·by·MergeVTables)·*/
2067	#define·__Pyx_RaiseErrorWithObjectTypes1(exc_type,·message,·arg,·obj1,·obj2)·__Pyx_RaiseErrorWithTypes1(exc_type,·message,·arg,·Py_TYPE(obj1),·Py_TYPE(obj2))
2068	#define·__Pyx_RaiseTypeErrorWithObjectTypes(message,·obj1,·obj2)·__Pyx_RaiseTypeErrorWithTypes(message,·Py_TYPE(obj1),·Py_TYPE(obj2))
2069	#define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2)
2070	CYTHON_UNUSED
2071	static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2);
2072	/*·MergeVTables.proto·*/
2073	static·int·__Pyx_MergeVtables(PyTypeObject·*type);	2049	/*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/
		2050	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2);
2074	/*·PyObjectLookupSpecial.proto·*/	2051	/*·PyObjectLookupSpecial.proto·(used·by·Py3ClassCreate)·*/
2075	#if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS	2052	#if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS
2076	#define·__Pyx_PyObject_LookupSpecialNoError(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·0)	2053	#define·__Pyx_PyObject_LookupSpecialNoError(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·0)
2077	#define·__Pyx_PyObject_LookupSpecial(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·1)	2054	#define·__Pyx_PyObject_LookupSpecial(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·1)
2078	static·CYTHON_INLINE·PyObject*·__Pyx__PyObject_LookupSpecial(PyObject*·obj,·PyObject*·attr_name,·int·with_error);	2055	static·CYTHON_INLINE·PyObject*·__Pyx__PyObject_LookupSpecial(PyObject*·obj,·PyObject*·attr_name,·int·with_error);
2079	#else	2056	#else
2080	#define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n)	2057	#define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n)
2081	#define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n)	2058	#define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n)
2082	#endif	2059	#endif
2083	/*·pybuiltin_invalid.export·*/
2084	static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname);
2085	/*·Py3MetaclassGet.export·*/	2060	/*·Py3ClassCreate.export·*/
2086	static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw);	2061	static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname,
		2062	···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc);
		2063	static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict,
		2064	······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass);
2087	/*·LimitedApiGetTypeTypeDict.proto·(used·by·DelItemOnTypeDict)·*/	2065	/*·LimitedApiGetTypeTypeDict.proto·(used·by·DelItemOnTypeDict)·*/
2088	#if·CYTHON_COMPILING_IN_LIMITED_API	2066	#if·CYTHON_COMPILING_IN_LIMITED_API
2089	static·PyObject·*__Pyx_GetTypeTypeDict(PyTypeObject·*tp);	2067	static·PyObject·*__Pyx_GetTypeTypeDict(PyTypeObject·*tp);
2090	#endif	2068	#endif
2091	/*·DelItemOnTypeDict.proto·(used·by·SetupReduce)·*/	2069	/*·DelItemOnTypeDict.proto·(used·by·SetupReduce)·*/
Offset 2127, 38 lines modified		Offset 2096, 23 lines modified
2127	/*·SetItemOnTypeDict.export·*/	2096	/*·SetItemOnTypeDict.export·*/
2128	static·int·__Pyx__SetItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k,·PyObject·*v);	2097	static·int·__Pyx__SetItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k,·PyObject·*v);
2129	/*·SetupReduce.export·*/	2098	/*·SetupReduce.export·*/
2130	static·int·__Pyx_setup_reduce(PyObject*·type_obj);	2099	static·int·__Pyx_setup_reduce(PyObject*·type_obj);
		2100	/*·pybuiltin_invalid.export·*/
		2101	static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname);
2131	/*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/
2132	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2);
2133	/*·Py3ClassCreate.export·*/
2134	static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname,
2135	···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc);
2136	static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict,
2137	······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass);
2138	/*·ArgTypeTestError.export·*/
2139	static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);
2140	/*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/	2102	/*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/
2141	static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);	2103	static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);
2142	/*·FetchCommonType.proto·*/	2104	/*·FetchCommonType.proto·(used·by·CommonTypesMetaclass)·*/
2143	static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);	2105	static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);
2144	/*·RaiseErrorWithObjectType1.proto·*/
2145	#define·__Pyx_RaiseTypeErrorWithObjectType1(message,·arg,·obj)·__Pyx_RaiseErrorWithObjectType1(PyExc_TypeError,·message,·arg,·obj)
2146	#define·__Pyx_RaiseErrorWithObjectType1(exc_type,·message,·arg,·obj)·__Pyx_RaiseErrorWithType1(exc_type,·message,·arg,·Py_TYPE(obj))
2147	CYTHON_UNUSED
2148	static·void·__Pyx_RaiseErrorWithType1(PyObject*·exc_type,·const·char*·message,·const·char·*arg,·PyTypeObject·*type_obj);
2149	/*·CommonTypesMetaclass.proto·(used·by·CythonFunctionShared)·*/	2106	/*·CommonTypesMetaclass.proto·(used·by·CythonFunctionShared)·*/
2150	static·int·__pyx_CommonTypesMetaclass_init(PyObject·*module);	2107	static·int·__pyx_CommonTypesMetaclass_init(PyObject·*module);
2151	#define·__Pyx_CommonTypesMetaclass_USED	2108	#define·__Pyx_CommonTypesMetaclass_USED
2152	/*·CythonFunctionPerModule.proto·(used·by·CythonFunctionShared)·*/	2109	/*·CythonFunctionPerModule.proto·(used·by·CythonFunctionShared)·*/
2153	#define·__Pyx_CyFunction_USED	2110	#define·__Pyx_CyFunction_USED
2154	#if·CYTHON_OPAQUE_SHARED_TYPES	2111	#if·CYTHON_OPAQUE_SHARED_TYPES
Offset 2275, 28 lines modified		Offset 2229, 74 lines modified
2275	#if·CYTHON_VECTORCALL	2229	#if·CYTHON_VECTORCALL
2276	static·PyObject·*·__Pyx_CyFunction_Vectorcall_NOARGS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);	2230	static·PyObject·*·__Pyx_CyFunction_Vectorcall_NOARGS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2277	static·PyObject·*·__Pyx_CyFunction_Vectorcall_O(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);	2231	static·PyObject·*·__Pyx_CyFunction_Vectorcall_O(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2278	static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);	2232	static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2279	static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);	2233	static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2280	#endif	2234	#endif
		2235	/*·RaiseErrorWithObjectType1.proto·(used·by·ValidateBasesTuple)·*/
		2236	#define·__Pyx_RaiseTypeErrorWithObjectType1(message,·arg,·obj)·__Pyx_RaiseErrorWithObjectType1(PyExc_TypeError,·message,·arg,·obj)
		2237	#define·__Pyx_RaiseErrorWithObjectType1(exc_type,·message,·arg,·obj)·__Pyx_RaiseErrorWithType1(exc_type,·message,·arg,·Py_TYPE(obj))
		2238	CYTHON_UNUSED
		2239	static·void·__Pyx_RaiseErrorWithType1(PyObject*·exc_type,·const·char*·message,·const·char·*arg,·PyTypeObject·*type_obj);
2281	/*·ValidateBasesTuple.proto·(used·by·PyType_Ready)·*/	2240	/*·ValidateBasesTuple.proto·(used·by·PyType_Ready)·*/
2282	#if·CYTHON_COMPILING_IN_CPYTHON·||·CYTHON_COMPILING_IN_LIMITED_API·||·CYTHON_USE_TYPE_SPECS	2241	#if·CYTHON_COMPILING_IN_CPYTHON·||·CYTHON_COMPILING_IN_LIMITED_API·||·CYTHON_USE_TYPE_SPECS
2283	static·int·__Pyx_validate_bases_tuple(const·char·*type_name,·int·has_dictoffset,·PyObject·*bases);	2242	static·int·__Pyx_validate_bases_tuple(const·char·*type_name,·int·has_dictoffset,·PyObject·*bases);
2284	#endif	2243	#endif
2285	/*·PyType_Ready.export·*/	2244	/*·PyType_Ready.export·*/
2286	CYTHON_UNUSED·static·int·__Pyx_PyType_Ready(PyTypeObject·*t);	2245	CYTHON_UNUSED·static·int·__Pyx_PyType_Ready(PyTypeObject·*t);
2287	/*·ValidateExternBase.export·*/	2246	/*·ValidateExternBase.export·*/
2288	static·int·__Pyx_validate_extern_base(PyTypeObject·*base);	2247	static·int·__Pyx_validate_extern_base(PyTypeObject·*base);
2289	/*·UpdateUnpickledDict.export·*/	2248	/*·UpdateUnpickledDict.export·*/
2290	static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index);	2249	static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index);
		2250	/*·ImportFrom.export·*/
		2251	static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name);
		2252	/*·ArgTypeTestError.export·*/
		2253	static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);
		2254	/*·RaiseErrorWithObjectTypes.proto·*/
		2255	#define·__Pyx_RaiseErrorWithObjectTypes1(exc_type,·message,·arg,·obj1,·obj2)·__Pyx_RaiseErrorWithTypes1(exc_type,·message,·arg,·Py_TYPE(obj1),·Py_TYPE(obj2))
		2256	#define·__Pyx_RaiseTypeErrorWithObjectTypes(message,·obj1,·obj2)·__Pyx_RaiseTypeErrorWithTypes(message,·Py_TYPE(obj1),·Py_TYPE(obj2))
		2257	#define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2)
		2258	CYTHON_UNUSED
		2259	static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2);
		2260	/*·JoinPyUnicode.proto·*/
		2261	#define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\
		2262	····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API)
		2263	/*·JoinPyUnicode.export·*/
		2264	static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind);
		2265	/*·HasAttr.proto·(used·by·ImportImpl)·*/
		2266	#if·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
		2267	#define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)
		2268	#else
		2269	static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);
		2270	#endif
		2271	/*·TupleOrListFromArrayImpl.proto·(used·by·ListFromArray)·*/
		2272	CYTHON_UNUSED·static·PyObject·*
		2273	__Pyx_PyList_FromArray(PyObject·*const·*src,·Py_ssize_t·n);
		2274	/*·ListFromArray.proto·(used·by·ImportImpl)·*/
		2275	/*·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);
		2277	/*·MergeVTables.proto·*/
		2278	static·int·__Pyx_MergeVtables(PyTypeObject·*type);
2291	/*·ParseKeywordsImpl.export·*/	2279	/*·ParseKeywordsImpl.export·*/
2292	static·int·__Pyx_ParseKeywordsTuple(	2280	static·int·__Pyx_ParseKeywordsTuple(
2293	····PyObject·*kwds,	2281	····PyObject·*kwds,
2294	····PyObject·*·const·*kwvalues,	2282	····PyObject·*·const·*kwvalues,
2295	····PyObject·**·const·argnames[],	2283	····PyObject·**·const·argnames[],
2296	····PyObject·*kwds2,	2284	····PyObject·*kwds2,
2297	····PyObject·*values[],	2285	····PyObject·*values[],
Offset 2331, 17 lines modified		Offset 2331, 14 lines modified
2331	#else	2331	#else
2332	#define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)	2332	#define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)
2333	#endif	2333	#endif
2334	/*·Py3UpdateBases.export·*/	2334	/*·Py3UpdateBases.export·*/
2335	static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases);	2335	static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases);
2336	/*·SetVTable.export·*/
2337	static·int·__Pyx_SetVtable(PyTypeObject*·typeptr·,·void*·vtable);
2338	/*·CythonFunction.export·*/	2336	/*·CythonFunction.export·*/
2339	static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,	2337	static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,
2340	······································int·flags,·PyObject*·qualname,	2338	······································int·flags,·PyObject*·qualname,
2341	······································PyObject·*closure,	2339	······································PyObject·*closure,
2342	······································PyObject·*module,·PyObject·*globals,	2340	······································PyObject·*module,·PyObject·*globals,
2343	······································PyObject*·code);	2341	······································PyObject*·code);
2344	static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);	2342	static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);
Offset 2371, 14 lines modified		Offset 2368, 17 lines modified
2371	·········································PyObject·*module,·PyObject·*globals,	2368	·········································PyObject·*module,·PyObject·*globals,
2372	·········································PyObject·*code);	2369	·········································PyObject·*code);
2373	static·PyTypeObject·*__Pyx_Get_FusedFunction_Type(void);	2370	static·PyTypeObject·*__Pyx_Get_FusedFunction_Type(void);
2374	/*·RejectKeywords.export·*/	2371	/*·RejectKeywords.export·*/
2375	static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds);	2372	static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds);
		2373	/*·SetVTable.export·*/
		2374	static·int·__Pyx_SetVtable(PyTypeObject*·typeptr·,·void*·vtable);
2376	/*·GCCDiagnostics.proto·(used·by·CIntToPy)·*/	2375	/*·GCCDiagnostics.proto·(used·by·CIntToPy)·*/
2377	#if·!defined(__INTEL_COMPILER)·&&·defined(__GNUC__)·&&·(__GNUC__·>·4·||·(__GNUC__·==·4·&&·__GNUC_MINOR__·>=·6))	2376	#if·!defined(__INTEL_COMPILER)·&&·defined(__GNUC__)·&&·(__GNUC__·>·4·||·(__GNUC__·==·4·&&·__GNUC_MINOR__·>=·6))
2378	#define·__Pyx_HAS_GCC_DIAGNOSTIC	2377	#define·__Pyx_HAS_GCC_DIAGNOSTIC
2379	#endif	2378	#endif
2380	/*·PyObjectVectorcallKwds.proto·(used·by·PyObjectVectorcallMethodKwds)·*/	2379	/*·PyObjectVectorcallKwds.proto·(used·by·PyObjectVectorcallMethodKwds)·*/
2381	#if·CYTHON_VECTORCALL	2380	#if·CYTHON_VECTORCALL
Offset 3859, 25 lines modified		Offset 3859, 55 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	#endif	3864	#endif
		3865	/*·CalculateMetaclass·*/
		3866	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{
3865	/*·CopyObjectArray·*/
3866	#if·CYTHON_COMPILING_IN_CPYTHON
3867	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length)·{
3868	····PyObject·*v;
3869	····Py_ssize_t·i;	3867	····Py_ssize_t·i,·nbases;
		3868	#if·CYTHON_ASSUME_SAFE_SIZE
		3869	····nbases·=·PyTuple_GET_SIZE(bases);
		3870	#else
		3871	····nbases·=·PyTuple_Size(bases);
		3872	····if·(nbases·<·0)·return·NULL;
		3873	#endif
3870	····for·(i·=·0;·i·<·length;·i++)·{	3874	····for·(i=0;·i·<·nbases;·i++)·{
3871	········v·=·dest[i]·=·src[i];
3872	········Py_INCREF(v);	3875	········PyTypeObject·*tmptype;
		3876	#if·CYTHON_ASSUME_SAFE_MACROS
		3877	········PyObject·*tmp·=·PyTuple_GET_ITEM(bases,·i);
		3878	#else
		3879	········PyObject·*tmp·=·PyTuple_GetItem(bases,·i);
		3880	········if·(!tmp)·return·NULL;
		3881	#endif
		3882	········tmptype·=·Py_TYPE(tmp);
		3883	········if·(!metaclass)·{
		3884	············metaclass·=·tmptype;
		3885	············continue;
		3886	········}
		3887	········if·(PyType_IsSubtype(metaclass,·tmptype))
		3888	············continue;
		3889	········if·(PyType_IsSubtype(tmptype,·metaclass))·{
		3890	············metaclass·=·tmptype;
		3891	············continue;
		3892	········}
		3893	········PyErr_SetString(PyExc_TypeError,
		3894	························"metaclass·conflict:·"
		3895	························"the·metaclass·of·a·derived·class·"
		3896	························"must·be·a·(non-strict)·subclass·"
		3897	························"of·the·metaclasses·of·all·its·bases");
		3898	········return·NULL;
3873	····}	3899	····}
		3900	····if·(!metaclass)·{
		3901	········metaclass·=·&PyType_Type;
		3902	····}
		3903	····Py_INCREF((PyObject*)·metaclass);
		3904	····return·(PyObject*)·metaclass;
3874	}	3905	}
3875	#endif
3876	/*·PyObjectCall·*/	3906	/*·PyObjectCall·*/
3877	#if·CYTHON_COMPILING_IN_CPYTHON	3907	#if·CYTHON_COMPILING_IN_CPYTHON
3878	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{	3908	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{
3879	····PyObject·*result;	3909	····PyObject·*result;
3880	····ternaryfunc·call·=·Py_TYPE(func)->tp_call;	3910	····ternaryfunc·call·=·Py_TYPE(func)->tp_call;
3881	····if·(unlikely(!call))	3911	····if·(unlikely(!call))
Offset 3911, 37 lines modified		Offset 3941, 21 lines modified
3911	············PyExc_SystemError,	3941	············PyExc_SystemError,
3912	············"NULL·result·without·error·in·PyObject_Call");	3942	············"NULL·result·without·error·in·PyObject_Call");
3913	····}	3943	····}
3914	····return·result;	3944	····return·result;
3915	}	3945	}
3916	#endif	3946	#endif
		3947	/*·IgnoreException·*/
		3948	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{
		3949	····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{
		3950	········PyErr_Clear();
		3951	········return·1;
3917	/*·GetVTable·*/
3918	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table)·{
3919	····void*·ptr;
3920	····*table·=·NULL;
3921	#if·CYTHON_COMPILING_IN_LIMITED_API
3922	····PyObject·*ob·=·PyObject_GetAttr((PyObject·*)type,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
3923	#else
3924	····PyObject·*ob·=·PyObject_GetItem(type->tp_dict,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
3925	#endif
3926	····if·(!ob)
3927	········goto·no_attr;
3928	····ptr·=·PyCapsule_GetPointer(ob,·0);
3929	····if·(!ptr·&&·!PyErr_Occurred())
3930	········PyErr_SetString(PyExc_RuntimeError,·"invalid·vtable·found·for·imported·type");
3931	····Py_DECREF(ob);
3932	····*table·=·ptr;
3933	····return·1;
3934	no_attr:
3935	····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{
3936	········return·0;
3937	····}	3952	····}
3938	····Py_XDECREF(ob);
3939	····return·-1;	3953	····return·0;
3940	}	3954	}
3941	/*·FormatTypeName·*/	3955	/*·FormatTypeName·*/
3942	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000	3956	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
3943	static·__Pyx_TypeName	3957	static·__Pyx_TypeName
3944	__Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)	3958	__Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)
3945	{	3959	{
Offset 3975, 65 lines modified		Offset 3989, 14 lines modified
3975	····}·else·{	3989	····}·else·{
3976	········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);	3990	········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);
3977	····}	3991	····}
3978	····goto·done;	3992	····goto·done;
3979	}	3993	}
3980	#endif	3994	#endif
3981	/*·CalculateMetaclass·*/
3982	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{
3983	····Py_ssize_t·i,·nbases;
3984	#if·CYTHON_ASSUME_SAFE_SIZE
3985	····nbases·=·PyTuple_GET_SIZE(bases);
3986	#else
3987	····nbases·=·PyTuple_Size(bases);
3988	····if·(nbases·<·0)·return·NULL;
3989	#endif
3990	····for·(i=0;·i·<·nbases;·i++)·{
3991	········PyTypeObject·*tmptype;
3992	#if·CYTHON_ASSUME_SAFE_MACROS
3993	········PyObject·*tmp·=·PyTuple_GET_ITEM(bases,·i);
3994	#else
3995	········PyObject·*tmp·=·PyTuple_GetItem(bases,·i);
3996	········if·(!tmp)·return·NULL;
3997	#endif
3998	········tmptype·=·Py_TYPE(tmp);
3999	········if·(!metaclass)·{
4000	············metaclass·=·tmptype;
4001	············continue;
4002	········}
4003	········if·(PyType_IsSubtype(metaclass,·tmptype))
4004	············continue;
4005	········if·(PyType_IsSubtype(tmptype,·metaclass))·{
4006	············metaclass·=·tmptype;
4007	············continue;
4008	········}
4009	········PyErr_SetString(PyExc_TypeError,
4010	························"metaclass·conflict:·"
4011	························"the·metaclass·of·a·derived·class·"
4012	························"must·be·a·(non-strict)·subclass·"
4013	························"of·the·metaclasses·of·all·its·bases");
4014	········return·NULL;
4015	····}
4016	····if·(!metaclass)·{
4017	········metaclass·=·&PyType_Type;
4018	····}
4019	····Py_INCREF((PyObject*)·metaclass);
4020	····return·(PyObject*)·metaclass;
4021	}
4022	/*·IgnoreException·*/
4023	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{
4024	····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{
4025	········PyErr_Clear();
4026	········return·1;
4027	····}
4028	····return·0;
4029	}
4030	/*·PyObjectCallMethod0·*/	3995	/*·PyObjectCallMethod0·*/
4031	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name)·{	3996	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name)·{
4032	#if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)	3997	#if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)
4033	····return·PyObject_VectorcallMethod(method_name,·&obj,·1·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);	3998	····return·PyObject_VectorcallMethod(method_name,·&obj,·1·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);
4034	#elif·CYTHON_COMPILING_IN_LIMITED_API	3999	#elif·CYTHON_COMPILING_IN_LIMITED_API
4035	····return·PyObject_CallMethodObjArgs(obj,·method_name,·NULL);	4000	····return·PyObject_CallMethodObjArgs(obj,·method_name,·NULL);
4036	#else	4001	#else
Offset 4094, 39 lines modified		Offset 4057, 117 lines modified
4094	#elif·CYTHON_COMPILING_IN_LIMITED_API	4057	#elif·CYTHON_COMPILING_IN_LIMITED_API
4095	····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);	4058	····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);
4096	#else	4059	#else
4097	····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);	4060	····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);
4098	#endif	4061	#endif
4099	}	4062	}
4100	/*·RaiseArgTupleInvalid·*/
4101	static·void·__Pyx_RaiseArgtupleInvalid(
4102	····const·char*·func_name,
4103	····int·exact,
4104	····Py_ssize_t·num_min,
4105	····Py_ssize_t·num_max,
4106	····Py_ssize_t·num_found)
4107	{
4108	····Py_ssize_t·num_expected;
4109	····const·char·*more_or_less;
4110	····if·(num_found·<·num_min)·{
4111	········num_expected·=·num_min;
4112	········more_or_less·=·"at·least";	4063	/*·AddModuleRef·*/
		4064	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3
		4065	··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{
		4066	······PyObject·*module_dict·=·PyImport_GetModuleDict();
		4067	······PyObject·*m;
		4068	······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{
		4069	··········return·NULL;
		4070	······}
		4071	······if·(m·!=·NULL·&&·PyModule_Check(m))·{
		4072	··········return·m;
		4073	······}
		4074	······Py_XDECREF(m);
		4075	······m·=·PyModule_NewObject(name);
		4076	······if·(m·==·NULL)
		4077	··········return·NULL;
		4078	······if·(PyDict_CheckExact(module_dict))·{
		4079	··········PyObject·*new_m;
		4080	··········(void)PyDict_SetDefaultRef(module_dict,·name,·m,·&new_m);
		4081	··········Py_DECREF(m);
		4082	··········return·new_m;
4113	····}·else·{	4083	······}·else·{
4114	········num_expected·=·num_max;
4115	········more_or_less·=·"at·most";	4084	···········if·(PyObject_SetItem(module_dict,·name,·m)·!=·0)·{
		4085	················Py_DECREF(m);
		4086	················return·NULL;
		4087	············}
		4088	············return·m;
		4089	······}
		4090	··}
		4091	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
		4092	······if·((PY_VERSION_HEX·>=·0x030E0000)·&&··Py_Version·>=·0x030E0100)·{
		4093	··········return·PyImport_AddModuleRef(name);
		4094	······}
		4095	······PyObject·*py_name·=·PyUnicode_FromString(name);
		4096	······if·(!py_name)·return·NULL;
		4097	······PyObject·*module·=·__Pyx_PyImport_AddModuleObjectRef(py_name);
		4098	······Py_DECREF(py_name);
		4099	······return·module;
		4100	··}
		4101	#elif·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
		4102	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
		4103	······PyObject·*module·=·PyImport_AddModule(name);
		4104	······Py_XINCREF(module);
		4105	······return·module;
		4106	··}
		4107	#endif
		4108	/*·VerifyCachedType·*/
		4109	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
		4110	·······························const·char·*name,
		4111	·······························Py_ssize_t·expected_basicsize)·{
		4112	····Py_ssize_t·basicsize;
		4113	····if·(!PyType_Check(cached_type))·{
		4114	········PyErr_Format(PyExc_TypeError,
		4115	············"Shared·Cython·type·%.200s·is·not·a·type·object",·name);
		4116	········return·-1;
4116	····}	4117	····}
4117	····if·(exact)·{
4118	········more_or_less·=·"exactly";	4118	····if·(expected_basicsize·==·0)·{
		4119	········return·0;·//·size·is·inherited,·nothing·useful·to·check
4119	····}	4120	····}
4120	····PyErr_Format(PyExc_TypeError,
4121	·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)",
4122	·················func_name,·more_or_less,·num_expected,
4123	·················(num_expected·==·1)·?·""·:·"s",·num_found);	4121	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·CYTHON_OPAQUE_OBJECTS
		4122	····if·(expected_basicsize·<·0)·{
		4123	········basicsize·=·PyType_GetTypeDataSize((PyTypeObject*)cached_type);
		4124	····}·else
		4125	#endif
		4126	····{
		4127	····#if·CYTHON_COMPILING_IN_LIMITED_API
		4128	········PyObject·*py_basicsize;
		4129	········py_basicsize·=·PyObject_GetAttrString(cached_type,·"__basicsize__");
		4130	········if·(unlikely(!py_basicsize))·return·-1;
		4131	········basicsize·=·PyLong_AsSsize_t(py_basicsize);
		4132	········Py_DECREF(py_basicsize);
		4133	········py_basicsize·=·NULL;
		4134	········if·(unlikely(basicsize·==·(Py_ssize_t)-1)·&&·PyErr_Occurred())·return·-1;
		4135	····#else
		4136	········basicsize·=·((PyTypeObject*)·cached_type)->tp_basicsize;
		4137	····#endif
		4138	····}
		4139	····if·((expected_basicsize·>=·0)·?
		4140	············(basicsize·!=·expected_basicsize)·:
		4141	············(basicsize·<·-expected_basicsize))·{
		4142	········PyErr_Format(PyExc_TypeError,
		4143	············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling",
		4144	············name);
		4145	········return·-1;
		4146	····}
		4147	····return·0;
		4148	}
		4149	/*·CallTypeTraverse·*/
		4150	#if·!CYTHON_USE_TYPE_SPECS
		4151	#else
		4152	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{
		4153	····if·(!always_call)·{
		4154	········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*);
		4155	········unsigned·long·flags·=·PyType_GetFlags(base);
		4156	········if·(flags·&·Py_TPFLAGS_HEAPTYPE)·{
		4157	············return·0;
		4158	········}
		4159	····}
		4160	····Py_VISIT((PyObject*)Py_TYPE(o));
		4161	····return·0;
4124	}	4162	}
		4163	#endif
4125	/*·PyObjectFastCall·(used·by·PyObjectCallOneArg)·*/	4164	/*·PyObjectFastCall·(used·by·PyObjectCallOneArg)·*/
4126	#if·CYTHON_COMPILING_IN_LIMITED_API	4165	#if·CYTHON_COMPILING_IN_LIMITED_API
4127	static·PyObject*·__Pyx_PyObject_FastCall_fallback(PyObject·*func,·PyObject·*·const*args,·size_t·nargs,·PyObject·*kwargs)·{	4166	static·PyObject*·__Pyx_PyObject_FastCall_fallback(PyObject·*func,·PyObject·*·const*args,·size_t·nargs,·PyObject·*kwargs)·{
4128	····PyObject·*argstuple;	4167	····PyObject·*argstuple;
4129	····PyObject·*result·=·0;	4168	····PyObject·*result·=·0;
4130	····size_t·i;	4169	····size_t·i;
Offset 4328, 202 lines modified		Offset 4369, 84 lines modified
4328	}	4369	}
4329	/*·py_dict_values·*/	4370	/*·py_dict_values·*/
4330	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{	4371	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{
4331	····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);	4372	····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);
4332	}	4373	}
4333	/*·RaiseDoubleKeywords·*/
4334	static·void·__Pyx_RaiseDoubleKeywordsError(
4335	····const·char*·func_name,
4336	····PyObject*·kw_name)
4337	{
4338	····PyErr_Format(PyExc_TypeError,
4339	········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);	4374	/*·CopyObjectArray·*/
		4375	#if·CYTHON_COMPILING_IN_CPYTHON
		4376	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length)·{
		4377	····PyObject·*v;
		4378	····Py_ssize_t·i;
		4379	····for·(i·=·0;·i·<·length;·i++)·{
		4380	········v·=·dest[i]·=·src[i];
		4381	········Py_INCREF(v);
		4382	····}
4340	}	4383	}
4341	/*·AddModuleRef·*/
4342	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3
4343	··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{
4344	······PyObject·*module_dict·=·PyImport_GetModuleDict();
4345	······PyObject·*m;
4346	······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{
4347	··········return·NULL;
4348	······}
4349	······if·(m·!=·NULL·&&·PyModule_Check(m))·{
4350	··········return·m;
4351	······}
4352	······Py_XDECREF(m);
4353	······m·=·PyModule_NewObject(name);
4354	······if·(m·==·NULL)
4355	··········return·NULL;
4356	······if·(PyDict_CheckExact(module_dict))·{
4357	··········PyObject·*new_m;
4358	··········(void)PyDict_SetDefaultRef(module_dict,·name,·m,·&new_m);
4359	··········Py_DECREF(m);
4360	··········return·new_m;
4361	······}·else·{
4362	···········if·(PyObject_SetItem(module_dict,·name,·m)·!=·0)·{
4363	················Py_DECREF(m);
4364	················return·NULL;
4365	············}
4366	············return·m;
4367	······}
4368	··}
4369	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
4370	······if·((PY_VERSION_HEX·>=·0x030E0000)·&&··Py_Version·>=·0x030E0100)·{
4371	··········return·PyImport_AddModuleRef(name);
4372	······}
4373	······PyObject·*py_name·=·PyUnicode_FromString(name);
4374	······if·(!py_name)·return·NULL;
4375	······PyObject·*module·=·__Pyx_PyImport_AddModuleObjectRef(py_name);
4376	······Py_DECREF(py_name);
4377	······return·module;
4378	··}
4379	#elif·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
4380	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name)·{
4381	······PyObject·*module·=·PyImport_AddModule(name);
4382	······Py_XINCREF(module);
4383	······return·module;
4384	··}
4385	#endif	4384	#endif
		4385	/*·GetVTable·*/
		4386	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table)·{
		4387	····void*·ptr;
		4388	····*table·=·NULL;
		4389	#if·CYTHON_COMPILING_IN_LIMITED_API
		4390	····PyObject·*ob·=·PyObject_GetAttr((PyObject·*)type,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
		4391	#else
		4392	····PyObject·*ob·=·PyObject_GetItem(type->tp_dict,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
4386	/*·VerifyCachedType·*/
4387	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
4388	·······························const·char·*name,
4389	·······························Py_ssize_t·expected_basicsize)·{
4390	····Py_ssize_t·basicsize;
4391	····if·(!PyType_Check(cached_type))·{
4392	········PyErr_Format(PyExc_TypeError,
4393	············"Shared·Cython·type·%.200s·is·not·a·type·object",·name);
4394	········return·-1;
4395	····}
4396	····if·(expected_basicsize·==·0)·{
4397	········return·0;·//·size·is·inherited,·nothing·useful·to·check
4398	····}
4399	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·CYTHON_OPAQUE_OBJECTS
4400	····if·(expected_basicsize·<·0)·{
4401	········basicsize·=·PyType_GetTypeDataSize((PyTypeObject*)cached_type);
4402	····}·else
4403	#endif	4393	#endif
		4394	····if·(!ob)
		4395	········goto·no_attr;
		4396	····ptr·=·PyCapsule_GetPointer(ob,·0);
		4397	····if·(!ptr·&&·!PyErr_Occurred())
		4398	········PyErr_SetString(PyExc_RuntimeError,·"invalid·vtable·found·for·imported·type");
		4399	····Py_DECREF(ob);
		4400	····*table·=·ptr;
		4401	····return·1;
		4402	no_attr:
		4403	····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{
4404	····{
4405	····#if·CYTHON_COMPILING_IN_LIMITED_API
4406	········PyObject·*py_basicsize;
4407	········py_basicsize·=·PyObject_GetAttrString(cached_type,·"__basicsize__");
4408	········if·(unlikely(!py_basicsize))·return·-1;
4409	········basicsize·=·PyLong_AsSsize_t(py_basicsize);
4410	········Py_DECREF(py_basicsize);
4411	········py_basicsize·=·NULL;
4412	········if·(unlikely(basicsize·==·(Py_ssize_t)-1)·&&·PyErr_Occurred())·return·-1;
4413	····#else
4414	········basicsize·=·((PyTypeObject*)·cached_type)->tp_basicsize;
4415	····#endif
4416	····}
4417	····if·((expected_basicsize·>=·0)·?
4418	············(basicsize·!=·expected_basicsize)·:
4419	············(basicsize·<·-expected_basicsize))·{
4420	········PyErr_Format(PyExc_TypeError,
4421	············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling",
4422	············name);
4423	········return·-1;	4404	········return·0;
4424	····}	4405	····}
		4406	····Py_XDECREF(ob);
4425	····return·0;	4407	····return·-1;
4426	}	4408	}
4427	/*·CallTypeTraverse·*/
4428	#if·!CYTHON_USE_TYPE_SPECS
4429	#else
4430	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{
4431	····if·(!always_call)·{
4432	········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*);
4433	········unsigned·long·flags·=·PyType_GetFlags(base);
4434	········if·(flags·&·Py_TPFLAGS_HEAPTYPE)·{
4435	············return·0;
4436	········}	4409	/*·RaiseArgTupleInvalid·*/
		4410	static·void·__Pyx_RaiseArgtupleInvalid(
		4411	····const·char*·func_name,
		4412	····int·exact,
		4413	····Py_ssize_t·num_min,
		4414	····Py_ssize_t·num_max,
		4415	····Py_ssize_t·num_found)
		4416	{
		4417	····Py_ssize_t·num_expected;
		4418	····const·char·*more_or_less;
		4419	····if·(num_found·<·num_min)·{
		4420	········num_expected·=·num_min;
		4421	········more_or_less·=·"at·least";
		4422	····}·else·{
		4423	········num_expected·=·num_max;
		4424	········more_or_less·=·"at·most";
4437	····}	4425	····}
4438	····Py_VISIT((PyObject*)Py_TYPE(o));
4439	····return·0;	4426	····if·(exact)·{
		4427	········more_or_less·=·"exactly";
		4428	····}
		4429	····PyErr_Format(PyExc_TypeError,
		4430	·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)",
		4431	·················func_name,·more_or_less,·num_expected,
		4432	·················(num_expected·==·1)·?·""·:·"s",·num_found);
4440	}	4433	}
4441	#endif
		4434	/*·RaiseDoubleKeywords·*/
		4435	static·void·__Pyx_RaiseDoubleKeywordsError(
		4436	····const·char*·func_name,
		4437	····PyObject*·kw_name)
		4438	{
		4439	····PyErr_Format(PyExc_TypeError,
		4440	········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);
4442	/*·JoinPyUnicode·*/
4443	static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind)·{
4444	#if·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH·&&·CYTHON_USE_UNICODE_INTERNALS
4445	····PyObject·*result_uval;
4446	····int·result_ukind,·kind_shift;
4447	····Py_ssize_t·i,·char_pos;
4448	····void·*result_udata;
4449	····static·const·Py_UCS4·max_char[5]·=·{0x7fU,·0xffU,·0xffffU,·0xffffU,·0x10ffffU};
4450	····assert·(kind·>=·0);
4451	····if·(kind·>·PyUnicode_4BYTE_KIND)·kind·=·PyUnicode_4BYTE_KIND;
4452	····result_uval·=·PyUnicode_New(result_ulength,·max_char[kind]);
4453	····if·(unlikely(!result_uval))·return·NULL;
4454	····kind_shift·=·kind·>>·1;··//·0,·1,·2
4455	····result_ukind·=·1·<<·kind_shift;··//·1,·2,·4
4456	····result_udata·=·PyUnicode_DATA(result_uval);
4457	····assert(kind_shift·==·2·||·kind_shift·==·1·||·kind_shift·==·0);
4458	····if·(unlikely((PY_SSIZE_T_MAX·>>·kind_shift)·-·result_ulength·<·0))
4459	········goto·overflow;
4460	····char_pos·=·0;
4461	····for·(i=0;·i·<·value_count;·i++)·{
4462	········int·ukind;
4463	········Py_ssize_t·ulength;
4464	········void·*udata;
4465	········PyObject·*uval·=·values[i];
4466	········if·(__Pyx_PyUnicode_READY(uval)·==·(-1))
4467	············goto·bad;
4468	········ulength·=·__Pyx_PyUnicode_GET_LENGTH(uval);
4469	········#if·!CYTHON_ASSUME_SAFE_SIZE
4470	········if·(unlikely(ulength·<·0))·goto·bad;
4471	········#endif
4472	········if·(unlikely(!ulength))
4473	············continue;
4474	········if·(unlikely((PY_SSIZE_T_MAX·>>·kind_shift)·-·ulength·<·char_pos))
4475	············goto·overflow;
4476	········ukind·=·__Pyx_PyUnicode_KIND(uval);
4477	········udata·=·__Pyx_PyUnicode_DATA(uval);
4478	········if·(ukind·==·result_ukind)·{
4479	············memcpy((char·*)result_udata·+·(char_pos·<<·kind_shift),·udata,·(size_t)·(ulength·<<·kind_shift));
4480	········}·else·{
4481	············#if·PY_VERSION_HEX·>=·0x030d0000
4482	············if·(unlikely(PyUnicode_CopyCharacters(result_uval,·char_pos,·uval,·0,·ulength)·<·0))·goto·bad;
4483	············#elif·CYTHON_COMPILING_IN_CPYTHON·||·defined(_PyUnicode_FastCopyCharacters)
4484	············_PyUnicode_FastCopyCharacters(result_uval,·char_pos,·uval,·0,·ulength);
4485	············#else
4486	············Py_ssize_t·j;
4487	············for·(j=0;·j·<·ulength;·j++)·{
4488	················Py_UCS4·uchar·=·__Pyx_PyUnicode_READ(ukind,·udata,·j);
4489	················__Pyx_PyUnicode_WRITE(result_ukind,·result_udata,·char_pos+j,·uchar);
4490	············}
4491	············#endif
4492	········}
4493	········char_pos·+=·ulength;
4494	····}
4495	····return·result_uval;
4496	overflow:
4497	····PyErr_SetString(PyExc_OverflowError,·"join()·result·is·too·long·for·a·Python·string");
4498	bad:
4499	····Py_DECREF(result_uval);
4500	····return·NULL;
4501	#else
4502	····Py_ssize_t·i;
4503	····PyObject·*result·=·NULL;
4504	····PyObject·*value_tuple·=·PyTuple_New(value_count);
4505	····if·(unlikely(!value_tuple))·return·NULL;
4506	····CYTHON_UNUSED_VAR(kind);
4507	····CYTHON_UNUSED_VAR(result_ulength);
4508	····for·(i=0;·i<value_count;·i++)·{
4509	········Py_INCREF(values[i]);
4510	········if·(__Pyx_PyTuple_SET_ITEM(value_tuple,·i,·values[i])·!=·(0))·goto·bad;
4511	····}
4512	····result·=·PyUnicode_Join(__pyx_mstate_global->__pyx_empty_unicode,·value_tuple);
4513	bad:
4514	····Py_DECREF(value_tuple);
4515	····return·result;
4516	#endif
4517	}	4441	}
4518	/*·RaiseException·*/	4442	/*·RaiseException·*/
4519	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause)·{	4443	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause)·{
4520	····PyObject*·owned_instance·=·NULL;	4444	····PyObject*·owned_instance·=·NULL;
4521	····if·(tb·==·Py_None)·{	4445	····if·(tb·==·Py_None)·{
4522	········tb·=·0;	4446	········tb·=·0;
Offset 4626, 203 lines modified		Offset 4549, 15 lines modified
4626	#endif	4549	#endif
4627	····}	4550	····}
4628	bad:	4551	bad:
4629	····Py_XDECREF(owned_instance);	4552	····Py_XDECREF(owned_instance);
4630	····return;	4553	····return;
4631	}	4554	}
		4555	/*·FindInheritedMetaclass·(used·by·Py3MetaclassGet)·*/
4632	/*·HasAttr·(used·by·ImportImpl)·*/
4633	#if·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
4634	static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*o,·PyObject·*n)·{
4635	····PyObject·*r;
4636	····if·(unlikely(!PyUnicode_Check(n)))·{
4637	········PyErr_SetString(PyExc_TypeError,
4638	························"hasattr():·attribute·name·must·be·string");
4639	········return·-1;
4640	····}
4641	····r·=·__Pyx_PyObject_GetAttrStrNoError(o,·n);
4642	····if·(!r)·{
4643	········return·(unlikely(PyErr_Occurred()))·?·-1·:·0;
4644	····}·else·{
4645	········Py_DECREF(r);
4646	········return·1;
4647	····}
4648	}
4649	#endif
4650	/*·TupleOrListFromArrayImpl·(used·by·ListFromArray)·*/
4651	CYTHON_UNUSED·static·PyObject·*
4652	__Pyx_PyList_FromArray(PyObject·*const·*src,·Py_ssize_t·n)·{
4653	····PyObject·*res·=·PyList_New(n);
4654	····if·(unlikely(res·==·NULL))·return·NULL;
4655	····#if·CYTHON_COMPILING_IN_CPYTHON
4656	····__Pyx_copy_object_array(src,·((PyListObject*)res)->ob_item,·n);
4657	····#else
4658	····Py_ssize_t·i;
4659	····for·(i·=·0;·i·<·n;·i++)·{
Max diff block lines reached; 38070/84102 bytes (45.27%) of diff not shown.

Generated by diffoscope 332