Offset 1877, 22 lines modified		Offset 1877, 37 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);	1882	/*·CopyObjectArray.proto·*/
		1883	#if·CYTHON_COMPILING_IN_CPYTHON
		1884	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length);
		1885	#endif
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);	1886	/*·PyObjectCall.proto·*/
		1887	#if·CYTHON_COMPILING_IN_CPYTHON
		1888	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw);
		1889	#else
		1890	#define·__Pyx_PyObject_Call(func,·arg,·kw)·PyObject_Call(func,·arg,·kw)
		1891	#endif
		1892	/*·PyObjectCallMethO.proto·*/
		1893	#if·CYTHON_COMPILING_IN_CPYTHON
		1894	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg);
1887	#endif	1895	#endif
		1896	/*·IncludeStringH.proto·*/
		1897	#include·<string.h>
		1898	/*·GetVTable.proto·*/
		1899	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);
1888	/*·FormatTypeName.proto·*/	1900	/*·FormatTypeName.proto·*/
1889	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000	1901	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
1890	typedef·PyObject·*__Pyx_TypeName;	1902	typedef·PyObject·*__Pyx_TypeName;
1891	#define·__Pyx_FMT_TYPENAME·"%N"	1903	#define·__Pyx_FMT_TYPENAME·"%N"
1892	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)	1904	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·Py_NewRef((PyObject*)tp)
1893	#define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)	1905	#define·__Pyx_DECREF_TypeName(obj)·Py_DECREF(obj)
1894	#elif·CYTHON_COMPILING_IN_LIMITED_API	1906	#elif·CYTHON_COMPILING_IN_LIMITED_API
Offset 1903, 59 lines modified		Offset 1918, 38 lines modified
1903	#else··//·!LIMITED_API	1918	#else··//·!LIMITED_API
1904	typedef·const·char·*__Pyx_TypeName;	1919	typedef·const·char·*__Pyx_TypeName;
1905	#define·__Pyx_FMT_TYPENAME·"%.200s"	1920	#define·__Pyx_FMT_TYPENAME·"%.200s"
1906	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)	1921	#define·__Pyx_PyType_GetFullyQualifiedName(tp)·((tp)->tp_name)
1907	#define·__Pyx_DECREF_TypeName(obj)	1922	#define·__Pyx_DECREF_TypeName(obj)
1908	#endif	1923	#endif
1909	/*·IgnoreException.proto·*/
1910	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);
1911	#define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)
1912	/*·CheckUnpickleChecksumError.export·*/
1913	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);
1914	/*·PyObjectCallMethod1.proto·*/
1915	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);
1916	/*·AddModuleRef.proto·*/	1924	/*·AddModuleRef.proto·*/
1917	#if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\	1925	#if·((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3)·||\
1918	·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000)	1926	·····__PYX_LIMITED_VERSION_HEX·<·0x030d0000)
1919	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name);	1927	··static·PyObject·*__Pyx_PyImport_AddModuleRef(const·char·*name);
1920	#else	1928	#else
1921	··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name)	1929	··#define·__Pyx_PyImport_AddModuleRef(name)·PyImport_AddModuleRef(name)
1922	#endif	1930	#endif
1923	/*·IncludeStringH.proto·*/
1924	#include·<string.h>
1925	/*·VerifyCachedType.proto·*/	1931	/*·VerifyCachedType.proto·*/
1926	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,	1932	static·int·__Pyx_VerifyCachedType(PyObject·*cached_type,
1927	·······························const·char·*name,	1933	·······························const·char·*name,
1928	·······························Py_ssize_t·expected_basicsize);	1934	·······························Py_ssize_t·expected_basicsize);
		1935	/*·IgnoreException.proto·*/
		1936	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception);
		1937	#define·__Pyx_IgnoreException(ignorable_exception)·__Pyx_IgnoreGivenException(NULL,·ignorable_exception)
1929	/*·CallTypeTraverse.proto·*/	1938	/*·CallTypeTraverse.proto·*/
1930	#if·!CYTHON_USE_TYPE_SPECS	1939	#if·!CYTHON_USE_TYPE_SPECS
1931	#define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0	1940	#define·__Pyx_call_type_traverse(o,·always_call,·visit,·arg)·0
1932	#else	1941	#else
1933	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg);	1942	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg);
1934	#endif	1943	#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·*/	1944	/*·py_dict_items.proto·*/
1946	#define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)	1945	#define·__Pyx_PyDict_items_TypePtr··(&PyDictKeys_Type)
1947	#define·__Pyx_PyDict_items_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictItems_TypePtr)	1946	#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)	1947	#define·__Pyx_PyDict_items_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictItems_TypePtr)
1949	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);	1948	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Items(PyObject*·d);
1950	/*·CallCFunction.proto·(used·by·CallUnboundCMethod0)·*/	1949	/*·CallCFunction.proto·(used·by·CallUnboundCMethod0)·*/
Offset 2024, 74 lines modified		Offset 2018, 60 lines modified
2024	/*·py_dict_values.proto·*/	2018	/*·py_dict_values.proto·*/
2025	#define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)	2019	#define·__Pyx_PyDict_values_TypePtr··(&PyDictKeys_Type)
2026	#define·__Pyx_PyDict_values_Check(obj)··PyObject_TypeCheck((obj),·__Pyx_PyDictValues_TypePtr)	2020	#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)	2021	#define·__Pyx_PyDict_values_CheckExact(obj)··Py_IS_TYPE((obj),·__Pyx_PyDictValues_TypePtr)
2028	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);	2022	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d);
2029	/*·CalculateMetaclass.proto·*/
2030	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);
2031	/*·CopyObjectArray.proto·*/
2032	#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);
2034	#endif
2035	/*·GetVTable.proto·*/
2036	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table);
2037	/*·RaiseArgTupleInvalid.export·*/	2023	/*·RaiseArgTupleInvalid.export·*/
2038	static·void·__Pyx_RaiseArgtupleInvalid(const·char*·func_name,·int·exact,	2024	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);	2025	····Py_ssize_t·num_min,·Py_ssize_t·num_max,·Py_ssize_t·num_found);
2040	/*·RaiseDoubleKeywords.proto·*/	2026	/*·RaiseDoubleKeywords.proto·*/
2041	static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);	2027	static·void·__Pyx_RaiseDoubleKeywordsError(const·char*·func_name,·PyObject*·kw_name);
		2028	/*·CalculateMetaclass.proto·*/
		2029	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases);
2042	/*·RaiseErrorWithObjectType.proto·(used·by·ValidateBasesTuple)·*/
2043	#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))
2045	CYTHON_UNUSED
2046	static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj);
		2030	/*·PyObjectCallMethod0.proto·*/
		2031	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name);
2047	/*·RaiseErrorWithObjectType1.proto·(used·by·ValidateBasesTuple)·*/
2048	#define·__Pyx_RaiseTypeErrorWithObjectType1(message,·arg,·obj)·__Pyx_RaiseErrorWithObjectType1(PyExc_TypeError,·message,·arg,·obj)
2049	#define·__Pyx_RaiseErrorWithObjectType1(exc_type,·message,·arg,·obj)·__Pyx_RaiseErrorWithType1(exc_type,·message,·arg,·Py_TYPE(obj))
2050	CYTHON_UNUSED
2051	static·void·__Pyx_RaiseErrorWithType1(PyObject*·exc_type,·const·char*·message,·const·char·*arg,·PyTypeObject·*type_obj);
2052	/*·ValidateBasesTuple.proto·(used·by·PyType_Ready)·*/
2053	#if·CYTHON_COMPILING_IN_CPYTHON·||·CYTHON_COMPILING_IN_LIMITED_API·||·CYTHON_USE_TYPE_SPECS
2054	static·int·__Pyx_validate_bases_tuple(const·char·*type_name,·int·has_dictoffset,·PyObject·*bases);	2032	/*·GetTypeDictOffset.proto·*/
		2033	#if·!CYTHON_USE_TYPE_SLOTS
		2034	CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result);
2055	#endif	2035	#endif
2056	/*·PyType_Ready.export·*/
2057	CYTHON_UNUSED·static·int·__Pyx_PyType_Ready(PyTypeObject·*t);	2036	/*·CheckUnpickleChecksumError.export·*/
		2037	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members);
		2038	/*·PyObjectCallMethod1.proto·*/
		2039	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg);
2058	/*·LimitedApiGetTypeTypeDict.proto·*/
2059	#if·CYTHON_COMPILING_IN_LIMITED_API
2060	static·PyObject·*__Pyx_GetTypeTypeDict(PyTypeObject·*tp);
2061	#endif
2062	/*·DelItemOnTypeDict.proto·(used·by·SetupReduce)·*/
2063	#define·__Pyx_DelItemOnTypeDict(tp,·k)·__Pyx__DelItemOnTypeDict((PyTypeObject*)tp,·k)	2040	/*·RaiseException.export·*/
		2041	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);
2064	/*·DelItemOnTypeDict.export·*/
2065	static·int·__Pyx__DelItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k);	2042	/*·HasAttr.proto·(used·by·ImportImpl)·*/
		2043	#if·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
		2044	#define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)
		2045	#else
		2046	static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);
		2047	#endif
2066	/*·SetItemOnTypeDict.proto·(used·by·SetupReduce)·*/
2067	#define·__Pyx_SetItemOnTypeDict(tp,·k,·v)·__Pyx__SetItemOnTypeDict((PyTypeObject*)tp,·k,·v)	2048	/*·TupleOrListFromArrayImpl.proto·(used·by·ListFromArray)·*/
		2049	CYTHON_UNUSED·static·PyObject·*
		2050	__Pyx_PyList_FromArray(PyObject·*const·*src,·Py_ssize_t·n);
		2051	/*·ListFromArray.proto·(used·by·ImportImpl)·*/
2068	/*·SetItemOnTypeDict.export·*/
2069	static·int·__Pyx__SetItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k,·PyObject·*v);
2070	/*·SetupReduce.export·*/
2071	static·int·__Pyx_setup_reduce(PyObject*·type_obj);
2072	/*·ValidateExternBase.export·*/
2073	static·int·__Pyx_validate_extern_base(PyTypeObject·*base);	2052	/*·ImportImpl.export·*/
		2053	static·PyObject·*__Pyx__Import(PyObject·*name,·PyObject·*const·*imported_names,·Py_ssize_t·len_imported_names,·PyObject·*qualname,·PyObject·*moddict,·int·level);
		2054	/*·ImportFrom.export·*/
		2055	static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name);
2074	/*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/	2056	/*·FetchSharedCythonModule.proto·(used·by·FetchCommonType)·*/
2075	static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);	2057	static·PyObject·*__Pyx_FetchSharedCythonABIModule(void);
2076	/*·FetchCommonType.proto·(used·by·CommonTypesMetaclass)·*/	2058	/*·FetchCommonType.proto·(used·by·CommonTypesMetaclass)·*/
2077	static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);	2059	static·PyTypeObject*·__Pyx_FetchCommonTypeFromSpec(PyTypeObject·*metaclass,·PyObject·*module,·PyType_Spec·*spec,·PyObject·*bases);
Offset 2215, 87 lines modified		Offset 2195, 84 lines modified
2215	#if·CYTHON_VECTORCALL	2195	#if·CYTHON_VECTORCALL
2216	static·PyObject·*·__Pyx_CyFunction_Vectorcall_NOARGS(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);	2196	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);	2197	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);	2198	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);	2199	static·PyObject·*·__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject·*func,·PyObject·*const·*args,·size_t·nargsf,·PyObject·*kwnames);
2220	#endif	2200	#endif
2221	/*·UpdateUnpickledDict.export·*/
2222	static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index);	2201	/*·RaiseErrorWithObjectTypes.proto·(used·by·MergeVTables)·*/
		2202	#define·__Pyx_RaiseErrorWithObjectTypes1(exc_type,·message,·arg,·obj1,·obj2)·__Pyx_RaiseErrorWithTypes1(exc_type,·message,·arg,·Py_TYPE(obj1),·Py_TYPE(obj2))
		2203	#define·__Pyx_RaiseTypeErrorWithObjectTypes(message,·obj1,·obj2)·__Pyx_RaiseTypeErrorWithTypes(message,·Py_TYPE(obj1),·Py_TYPE(obj2))
		2204	#define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2)
		2205	CYTHON_UNUSED
		2206	static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2);
2223	/*·FindInheritedMetaclass.proto·*/
2224	static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases);	2207	/*·MergeVTables.proto·*/
		2208	static·int·__Pyx_MergeVtables(PyTypeObject·*type);
2225	/*·pybuiltin_invalid.export·*/	2209	/*·pybuiltin_invalid.export·*/
2226	static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname);	2210	static·void·__Pyx_PyBuiltin_Invalid(PyObject·*obj,·const·char·*builtin_type_name,·const·char·*argname);
2227	/*·RaiseException.export·*/
2228	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause);	2211	/*·ArgTypeTestError.export·*/
		2212	static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);
		2213	/*·FindInheritedMetaclass.proto·*/
		2214	static·PyObject·*__Pyx_FindInheritedMetaclass(PyObject·*bases);
2229	/*·PyObjectLookupSpecial.proto·*/	2215	/*·PyObjectLookupSpecial.proto·*/
2230	#if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS	2216	#if·CYTHON_USE_PYTYPE_LOOKUP·&&·CYTHON_USE_TYPE_SLOTS
2231	#define·__Pyx_PyObject_LookupSpecialNoError(obj,·attr_name)··__Pyx__PyObject_LookupSpecial(obj,·attr_name,·0)	2217	#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)	2218	#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);	2219	static·CYTHON_INLINE·PyObject*·__Pyx__PyObject_LookupSpecial(PyObject*·obj,·PyObject*·attr_name,·int·with_error);
2234	#else	2220	#else
2235	#define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n)	2221	#define·__Pyx_PyObject_LookupSpecialNoError(o,n)·__Pyx_PyObject_GetAttrStrNoError(o,n)
2236	#define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n)	2222	#define·__Pyx_PyObject_LookupSpecial(o,n)·__Pyx_PyObject_GetAttrStr(o,n)
2237	#endif	2223	#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))	2224	/*·LimitedApiGetTypeTypeDict.proto·(used·by·DelItemOnTypeDict)·*/
		2225	#if·CYTHON_COMPILING_IN_LIMITED_API
		2226	static·PyObject·*__Pyx_GetTypeTypeDict(PyTypeObject·*tp);
		2227	#endif
		2228	/*·DelItemOnTypeDict.proto·(used·by·SetupReduce)·*/
		2229	#define·__Pyx_DelItemOnTypeDict(tp,·k)·__Pyx__DelItemOnTypeDict((PyTypeObject*)tp,·k)
		2230	/*·DelItemOnTypeDict.export·*/
		2231	static·int·__Pyx__DelItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k);
		2232	/*·RaiseErrorWithObjectType.proto·(used·by·SetupReduce)·*/
2241	#define·__Pyx_RaiseTypeErrorWithTypes(message,·type_obj1,·type_obj2)·__Pyx_RaiseErrorWithTypes1(PyExc_TypeError,·"%.1s"·message,·"",·type_obj1,·type_obj2)	2233	#define·__Pyx_RaiseTypeErrorWithObjectType(message,·obj)··__Pyx_RaiseErrorWithObjectType(PyExc_TypeError,·message,·obj)
		2234	#define·__Pyx_RaiseErrorWithObjectType(exc_type,·message,·obj)··__Pyx_RaiseErrorWithType(exc_type,·message,·Py_TYPE(obj))
2242	CYTHON_UNUSED	2235	CYTHON_UNUSED
2243	static·void·__Pyx_RaiseErrorWithTypes1(PyObject*·exc_type,·const·char·*message,·const·char·*arg,·PyTypeObject·*type_obj1,·PyTypeObject·*type_obj2);	2236	static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj);
2244	/*·ImportFrom.export·*/
2245	static·PyObject*·__Pyx_ImportFrom(PyObject*·module,·PyObject*·name);	2237	/*·SetItemOnTypeDict.proto·(used·by·SetupReduce)·*/
		2238	#define·__Pyx_SetItemOnTypeDict(tp,·k,·v)·__Pyx__SetItemOnTypeDict((PyTypeObject*)tp,·k,·v)
		2239	/*·SetItemOnTypeDict.export·*/
		2240	static·int·__Pyx__SetItemOnTypeDict(PyTypeObject·*tp,·PyObject·*k,·PyObject·*v);
		2241	/*·SetupReduce.export·*/
		2242	static·int·__Pyx_setup_reduce(PyObject*·type_obj);
2246	/*·JoinPyUnicode.proto·*/	2243	/*·JoinPyUnicode.proto·*/
2247	#define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\	2244	#define·__Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\
2248	····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API)	2245	····(!CYTHON_COMPILING_IN_GRAAL·&&·!CYTHON_COMPILING_IN_PYPY·&&·!CYTHON_COMPILING_IN_LIMITED_API)
2249	/*·JoinPyUnicode.export·*/	2246	/*·JoinPyUnicode.export·*/
2250	static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind);	2247	static·PyObject*·__Pyx_PyUnicode_Join(PyObject**·values,·Py_ssize_t·value_count,·Py_ssize_t·result_ulength,·int·kind);
		2248	/*·RaiseErrorWithObjectType1.proto·*/
		2249	#define·__Pyx_RaiseTypeErrorWithObjectType1(message,·arg,·obj)·__Pyx_RaiseErrorWithObjectType1(PyExc_TypeError,·message,·arg,·obj)
		2250	#define·__Pyx_RaiseErrorWithObjectType1(exc_type,·message,·arg,·obj)·__Pyx_RaiseErrorWithType1(exc_type,·message,·arg,·Py_TYPE(obj))
		2251	CYTHON_UNUSED
		2252	static·void·__Pyx_RaiseErrorWithType1(PyObject*·exc_type,·const·char*·message,·const·char·*arg,·PyTypeObject·*type_obj);
2251	/*·ArgTypeTestError.export·*/
2252	static·void·__Pyx_ArgTypeError(PyObject·*obj,·PyTypeObject·*type,·const·char·*name,·int·exact);
2253	/*·HasAttr.proto·(used·by·ImportImpl)·*/
2254	#if·__PYX_LIMITED_VERSION_HEX·>=·0x030d0000
2255	#define·__Pyx_HasAttr(o,·n)··PyObject_HasAttrWithError(o,·n)
2256	#else
2257	static·CYTHON_INLINE·int·__Pyx_HasAttr(PyObject·*,·PyObject·*);
2258	#endif
2259	/*·TupleOrListFromArrayImpl.proto·(used·by·ListFromArray)·*/
2260	CYTHON_UNUSED·static·PyObject·*
2261	__Pyx_PyList_FromArray(PyObject·*const·*src,·Py_ssize_t·n);
2262	/*·ListFromArray.proto·(used·by·ImportImpl)·*/
2263	/*·ImportImpl.export·*/
2264	static·PyObject·*__Pyx__Import(PyObject·*name,·PyObject·*const·*imported_names,·Py_ssize_t·len_imported_names,·PyObject·*qualname,·PyObject·*moddict,·int·level);
2265	/*·Py3MetaclassGet.export·*/
2266	static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw);
2267	/*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/
2268	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2);
2269	/*·Py3ClassCreate.export·*/
2270	static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname,
2271	···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc);
2272	static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict,
2273	······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass);
2274	/*·MergeVTables.proto·*/
2275	static·int·__Pyx_MergeVtables(PyTypeObject·*type);	2253	/*·ValidateExternBase.export·*/
		2254	static·int·__Pyx_validate_extern_base(PyTypeObject·*base);
2276	/*·ParseKeywordsImpl.export·*/	2255	/*·ParseKeywordsImpl.export·*/
2277	static·int·__Pyx_ParseKeywordsTuple(	2256	static·int·__Pyx_ParseKeywordsTuple(
2278	····PyObject·*kwds,	2257	····PyObject·*kwds,
2279	····PyObject·*·const·*kwvalues,	2258	····PyObject·*·const·*kwvalues,
2280	····PyObject·**·const·argnames[],	2259	····PyObject·**·const·argnames[],
2281	····PyObject·*kwds2,	2260	····PyObject·*kwds2,
Offset 2328, 22 lines modified		Offset 2305, 48 lines modified
2328	static·PyObject*·__Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction*·cfunc,·PyObject*·self,·PyObject*·arg1,·PyObject*·arg2);	2305	static·PyObject*·__Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction*·cfunc,·PyObject*·self,·PyObject*·arg1,·PyObject*·arg2);
2329	#if·CYTHON_COMPILING_IN_CPYTHON	2306	#if·CYTHON_COMPILING_IN_CPYTHON
2330	static·CYTHON_INLINE·PyObject·*__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction·*cfunc,·PyObject·*self,·PyObject·*arg1,·PyObject·*arg2);	2307	static·CYTHON_INLINE·PyObject·*__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction·*cfunc,·PyObject·*self,·PyObject·*arg1,·PyObject·*arg2);
2331	#else	2308	#else
2332	#define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)	2309	#define·__Pyx_CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)··__Pyx__CallUnboundCMethod2(cfunc,·self,·arg1,·arg2)
2333	#endif	2310	#endif
		2311	/*·Py3MetaclassGet.export·*/
		2312	static·PyObject·*__Pyx_Py3MetaclassGet(PyObject·*bases,·PyObject·*mkw);
		2313	/*·PyObjectCall2Args.proto·(used·by·Py3ClassCreate)·*/
		2314	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call2Args(PyObject*·function,·PyObject*·arg1,·PyObject*·arg2);
		2315	/*·Py3ClassCreate.export·*/
		2316	static·PyObject·*__Pyx_Py3MetaclassPrepare(PyObject·*metaclass,·PyObject·*bases,·PyObject·*name,·PyObject·*qualname,
		2317	···········································PyObject·*mkw,·PyObject·*modname,·PyObject·*doc);
		2318	static·PyObject·*__Pyx_Py3ClassCreate(PyObject·*metaclass,·PyObject·*name,·PyObject·*bases,·PyObject·*dict,
		2319	······································PyObject·*mkw,·int·calculate_metaclass,·int·allow_py2_metaclass);
		2320	/*·ValidateBasesTuple.proto·(used·by·PyType_Ready)·*/
		2321	#if·CYTHON_COMPILING_IN_CPYTHON·||·CYTHON_COMPILING_IN_LIMITED_API·||·CYTHON_USE_TYPE_SPECS
		2322	static·int·__Pyx_validate_bases_tuple(const·char·*type_name,·int·has_dictoffset,·PyObject·*bases);
		2323	#endif
		2324	/*·PyType_Ready.export·*/
		2325	CYTHON_UNUSED·static·int·__Pyx_PyType_Ready(PyTypeObject·*t);
		2326	/*·UpdateUnpickledDict.export·*/
		2327	static·int·__Pyx_UpdateUnpickledDict(PyObject·*obj,·PyObject·*state,·Py_ssize_t·index);
2334	/*·CythonFunction.export·*/	2328	/*·CythonFunction.export·*/
2335	static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,	2329	static·PyObject·*__Pyx_CyFunction_New(PyMethodDef·*ml,
2336	······································int·flags,·PyObject*·qualname,	2330	······································int·flags,·PyObject*·qualname,
2337	······································PyObject·*closure,	2331	······································PyObject·*closure,
2338	······································PyObject·*module,·PyObject·*globals,	2332	······································PyObject·*module,·PyObject·*globals,
2339	······································PyObject*·code);	2333	······································PyObject*·code);
2340	static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);	2334	static·PyTypeObject·*__Pyx_Get_CyFunction_Type(void);
		2335	/*·SetVTable.export·*/
		2336	static·int·__Pyx_SetVtable(PyTypeObject*·typeptr·,·void*·vtable);
2341	/*·Py3UpdateBases.export·*/	2337	/*·Py3UpdateBases.export·*/
2342	static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases);	2338	static·PyObject*·__Pyx_PEP560_update_bases(PyObject·*bases);
2343	/*·FusedFunctionPerModule.proto·(used·by·FusedFunction)·*/	2339	/*·FusedFunctionPerModule.proto·(used·by·FusedFunction)·*/
2344	#if·CYTHON_OPAQUE_SHARED_TYPES	2340	#if·CYTHON_OPAQUE_SHARED_TYPES
2345	#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))
2346	#else	2342	#else
Offset 2368, 17 lines modified		Offset 2371, 14 lines modified
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·*/	2374	/*·RejectKeywords.export·*/
2372	static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds);	2375	static·void·__Pyx_RejectKeywords(const·char*·function_name,·PyObject·*kwds);
2373	/*·SetVTable.export·*/
2374	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_DIAGNOSTIC	2378	#define·__Pyx_HAS_GCC_DIAGNOSTIC
2378	#endif	2379	#endif
2379	/*·PyObjectVectorcallKwds.proto·(used·by·PyObjectVectorcallMethodKwds)·*/	2380	/*·PyObjectVectorcallKwds.proto·(used·by·PyObjectVectorcallMethodKwds)·*/
2380	#if·CYTHON_VECTORCALL	2381	#if·CYTHON_VECTORCALL
Offset 3859, 50 lines modified		Offset 3859, 91 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	/*·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	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;
		3870	····for·(i·=·0;·i·<·length;·i++)·{
		3871	········v·=·dest[i]·=·src[i];
		3872	········Py_INCREF(v);
		3873	····}
3874	}	3874	}
		3875	#endif
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))·{	3876	/*·PyObjectCall·*/
		3877	#if·CYTHON_COMPILING_IN_CPYTHON
		3878	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{
		3879	····PyObject·*result;
		3880	····ternaryfunc·call·=·Py_TYPE(func)->tp_call;
		3881	····if·(unlikely(!call))
		3882	········return·PyObject_Call(func,·arg,·kw);
		3883	····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
		3884	········return·NULL;
		3885	····result·=·(*call)(func,·arg,·kw);
		3886	····Py_LeaveRecursiveCall();
		3887	····if·(unlikely(!result)·&&·unlikely(!PyErr_Occurred()))·{
3885	········PyErr_SetString(	3888	········PyErr_SetString(
3886	············PyExc_TypeError,	3889	············PyExc_SystemError,
3887	············"'type'·doesn't·have·a·dictoffset");
3888	········return·-1;
3889	····}·else·if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·<·0))·{	3890	············"NULL·result·without·error·in·PyObject_Call");
		3891	····}
		3892	····return·result;
		3893	}
		3894	#endif
		3895	/*·PyObjectCallMethO·*/
		3896	#if·CYTHON_COMPILING_IN_CPYTHON
		3897	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg)·{
		3898	····PyObject·*self,·*result;
		3899	····PyCFunction·cfunc;
		3900	····cfunc·=·__Pyx_CyOrPyCFunction_GET_FUNCTION(func);
		3901	····self·=·__Pyx_CyOrPyCFunction_GET_SELF(func);
		3902	····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
		3903	········return·NULL;
		3904	····result·=·cfunc(self,·arg);
		3905	····Py_LeaveRecursiveCall();
		3906	····if·(unlikely(!result)·&&·unlikely(!PyErr_Occurred()))·{
3890	········PyErr_SetString(	3907	········PyErr_SetString(
3891	············PyExc_TypeError,	3908	············PyExc_SystemError,
		3909	············"NULL·result·without·error·in·PyObject_Call");
3892	············"'type'·has·an·unexpected·negative·dictoffset.·"
3893	············"Please·report·this·as·Cython·bug");
3894	········return·-1;
3895	····}	3910	····}
3896	····return·tp_dictoffset;	3911	····return·result;
3897	}	3912	}
3898	#endif	3913	#endif
		3914	/*·GetVTable·*/
		3915	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table)·{
		3916	····void*·ptr;
		3917	····*table·=·NULL;
		3918	#if·CYTHON_COMPILING_IN_LIMITED_API
		3919	····PyObject·*ob·=·PyObject_GetAttr((PyObject·*)type,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
		3920	#else
		3921	····PyObject·*ob·=·PyObject_GetItem(type->tp_dict,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
		3922	#endif
		3923	····if·(!ob)
		3924	········goto·no_attr;
		3925	····ptr·=·PyCapsule_GetPointer(ob,·0);
		3926	····if·(!ptr·&&·!PyErr_Occurred())
		3927	········PyErr_SetString(PyExc_RuntimeError,·"invalid·vtable·found·for·imported·type");
		3928	····Py_DECREF(ob);
		3929	····*table·=·ptr;
		3930	····return·1;
		3931	no_attr:
		3932	····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{
		3933	········return·0;
		3934	····}
		3935	····Py_XDECREF(ob);
		3936	····return·-1;
		3937	}
3899	/*·FormatTypeName·*/	3938	/*·FormatTypeName·*/
3900	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000	3939	#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
3901	static·__Pyx_TypeName	3940	static·__Pyx_TypeName
3902	__Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)	3941	__Pyx_PyType_GetFullyQualifiedName(PyTypeObject*·tp)
3903	{	3942	{
3904	····PyObject·*module·=·NULL,·*name·=·NULL,·*result·=·NULL;	3943	····PyObject·*module·=·NULL,·*name·=·NULL,·*result·=·NULL;
3905	····#if·__PYX_LIMITED_VERSION_HEX·<·0x030b0000	3944	····#if·__PYX_LIMITED_VERSION_HEX·<·0x030b0000
Offset 3934, 55 lines modified		Offset 3975, 14 lines modified
3934	····}·else·{	3975	····}·else·{
3935	········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);	3976	········result·=·__Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);
3936	····}	3977	····}
3937	····goto·done;	3978	····goto·done;
3938	}	3979	}
3939	#endif	3980	#endif
3940	/*·IgnoreException·*/
3941	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{
3942	····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{
3943	········PyErr_Clear();
3944	········return·1;
3945	····}
3946	····return·0;
3947	}
3948	/*·CheckUnpickleChecksumError·*/
3949	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members)·{
3950	····PyObject·*pickle_module·=·PyImport_ImportModule("pickle");
3951	····if·(unlikely(!pickle_module))·return;
3952	····PyObject·*pickle_error·=·PyObject_GetAttrString(pickle_module,·"PickleError");
3953	····Py_DECREF(pickle_module);
3954	····if·(unlikely(!pickle_error))·return;
3955	····if·(checksum2·==·checksum1)·{
3956	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x)·=·(%s))",
3957	············checksum,·checksum1,·members);
3958	····}·else·if·(checksum3·==·checksum2)·{
3959	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x,·0x%x)·=·(%s))",
3960	············checksum,·checksum1,·checksum2,·members);
3961	····}·else·{
3962	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x,·0x%x,·0x%x)·=·(%s))",
3963	············checksum,·checksum1,·checksum2,·checksum3,·members);
3964	····}
3965	····Py_DECREF(pickle_error);
3966	}
3967	/*·PyObjectCallMethod1·*/
3968	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg)·{
3969	#if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)
3970	····PyObject·*args[2]·=·{obj,·arg};
3971	····return·PyObject_VectorcallMethod(method_name,·args,·2·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);
3972	#elif·CYTHON_COMPILING_IN_LIMITED_API
3973	····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);
3974	#else
3975	····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);
3976	#endif
3977	}
3978	/*·AddModuleRef·*/	3981	/*·AddModuleRef·*/
3979	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3	3982	#if·CYTHON_COMPILING_IN_CPYTHON_FREETHREADING·&&·PY_VERSION_HEX·<·0x030F00a3
3980	··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{	3983	··static·PyObject·*__Pyx_PyImport_AddModuleObjectRef(PyObject·*name)·{
3981	······PyObject·*module_dict·=·PyImport_GetModuleDict();	3984	······PyObject·*module_dict·=·PyImport_GetModuleDict();
3982	······PyObject·*m;	3985	······PyObject·*m;
3983	······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{	3986	······if·(PyMapping_GetOptionalItem(module_dict,·name,·&m)·<·0)·{
3984	··········return·NULL;	3987	··········return·NULL;
Offset 4063, 14 lines modified		Offset 4063, 23 lines modified
4063	············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling",	4063	············"Shared·Cython·type·%.200s·has·the·wrong·size,·try·recompiling",
4064	············name);	4064	············name);
4065	········return·-1;	4065	········return·-1;
4066	····}	4066	····}
4067	····return·0;	4067	····return·0;
4068	}	4068	}
		4069	/*·IgnoreException·*/
		4070	static·CYTHON_INLINE·int·__Pyx_IgnoreGivenException(PyObject·*given_exception,·PyObject·*ignorable_exception)·{
		4071	····if·(PyErr_GivenExceptionMatches(given_exception·?·given_exception·:·PyErr_Occurred(),·ignorable_exception))·{
		4072	········PyErr_Clear();
		4073	········return·1;
		4074	····}
		4075	····return·0;
		4076	}
4069	/*·CallTypeTraverse·*/	4077	/*·CallTypeTraverse·*/
4070	#if·!CYTHON_USE_TYPE_SPECS	4078	#if·!CYTHON_USE_TYPE_SPECS
4071	#else	4079	#else
4072	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{	4080	static·int·__Pyx_call_type_traverse(PyObject·*o,·int·always_call,·visitproc·visit,·void·*arg)·{
4073	····if·(!always_call)·{	4081	····if·(!always_call)·{
4074	········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*);	4082	········PyTypeObject·*base·=·__Pyx_PyObject_GetSlot(o,·tp_base,·PyTypeObject*);
4075	········unsigned·long·flags·=·PyType_GetFlags(base);	4083	········unsigned·long·flags·=·PyType_GetFlags(base);
Offset 4079, 54 lines modified		Offset 4088, 14 lines modified
4079	········}	4088	········}
4080	····}	4089	····}
4081	····Py_VISIT((PyObject*)Py_TYPE(o));	4090	····Py_VISIT((PyObject*)Py_TYPE(o));
4082	····return·0;	4091	····return·0;
4083	}	4092	}
4084	#endif	4093	#endif
4085	/*·PyObjectCall·*/
4086	#if·CYTHON_COMPILING_IN_CPYTHON
4087	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_Call(PyObject·*func,·PyObject·*arg,·PyObject·*kw)·{
4088	····PyObject·*result;
4089	····ternaryfunc·call·=·Py_TYPE(func)->tp_call;
4090	····if·(unlikely(!call))
4091	········return·PyObject_Call(func,·arg,·kw);
4092	····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
4093	········return·NULL;
4094	····result·=·(*call)(func,·arg,·kw);
4095	····Py_LeaveRecursiveCall();
4096	····if·(unlikely(!result)·&&·unlikely(!PyErr_Occurred()))·{
4097	········PyErr_SetString(
4098	············PyExc_SystemError,
4099	············"NULL·result·without·error·in·PyObject_Call");
4100	····}
4101	····return·result;
4102	}
4103	#endif
4104	/*·PyObjectCallMethO·*/
4105	#if·CYTHON_COMPILING_IN_CPYTHON
4106	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethO(PyObject·*func,·PyObject·*arg)·{
4107	····PyObject·*self,·*result;
4108	····PyCFunction·cfunc;
4109	····cfunc·=·__Pyx_CyOrPyCFunction_GET_FUNCTION(func);
4110	····self·=·__Pyx_CyOrPyCFunction_GET_SELF(func);
4111	····if·(unlikely(Py_EnterRecursiveCall("·while·calling·a·Python·object")))
4112	········return·NULL;
4113	····result·=·cfunc(self,·arg);
4114	····Py_LeaveRecursiveCall();
4115	····if·(unlikely(!result)·&&·unlikely(!PyErr_Occurred()))·{
4116	········PyErr_SetString(
4117	············PyExc_SystemError,
4118	············"NULL·result·without·error·in·PyObject_Call");
4119	····}
4120	····return·result;
4121	}
4122	#endif
4123	/*·PyObjectFastCall·(used·by·PyObjectCallOneArg)·*/	4094	/*·PyObjectFastCall·(used·by·PyObjectCallOneArg)·*/
4124	#if·CYTHON_COMPILING_IN_LIMITED_API	4095	#if·CYTHON_COMPILING_IN_LIMITED_API
4125	static·PyObject*·__Pyx_PyObject_FastCall_fallback(PyObject·*func,·PyObject·*·const*args,·size_t·nargs,·PyObject·*kwargs)·{	4096	static·PyObject*·__Pyx_PyObject_FastCall_fallback(PyObject·*func,·PyObject·*·const*args,·size_t·nargs,·PyObject·*kwargs)·{
4126	····PyObject·*argstuple;	4097	····PyObject·*argstuple;
4127	····PyObject·*result·=·0;	4098	····PyObject·*result·=·0;
4128	····size_t·i;	4099	····size_t·i;
4129	····argstuple·=·PyTuple_New((Py_ssize_t)nargs);	4100	····argstuple·=·PyTuple_New((Py_ssize_t)nargs);
Offset 4327, 14 lines modified		Offset 4296, 49 lines modified
4327	}	4296	}
4328	/*·py_dict_values·*/	4297	/*·py_dict_values·*/
4329	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{	4298	static·CYTHON_INLINE·PyObject*·__Pyx_PyDict_Values(PyObject*·d)·{
4330	····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);	4299	····return·__Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values,·d);
4331	}	4300	}
		4301	/*·RaiseArgTupleInvalid·*/
		4302	static·void·__Pyx_RaiseArgtupleInvalid(
		4303	····const·char*·func_name,
		4304	····int·exact,
		4305	····Py_ssize_t·num_min,
		4306	····Py_ssize_t·num_max,
		4307	····Py_ssize_t·num_found)
		4308	{
		4309	····Py_ssize_t·num_expected;
		4310	····const·char·*more_or_less;
		4311	····if·(num_found·<·num_min)·{
		4312	········num_expected·=·num_min;
		4313	········more_or_less·=·"at·least";
		4314	····}·else·{
		4315	········num_expected·=·num_max;
		4316	········more_or_less·=·"at·most";
		4317	····}
		4318	····if·(exact)·{
		4319	········more_or_less·=·"exactly";
		4320	····}
		4321	····PyErr_Format(PyExc_TypeError,
		4322	·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)",
		4323	·················func_name,·more_or_less,·num_expected,
		4324	·················(num_expected·==·1)·?·""·:·"s",·num_found);
		4325	}
		4326	/*·RaiseDoubleKeywords·*/
		4327	static·void·__Pyx_RaiseDoubleKeywordsError(
		4328	····const·char*·func_name,
		4329	····PyObject*·kw_name)
		4330	{
		4331	····PyErr_Format(PyExc_TypeError,
		4332	········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);
		4333	}
4332	/*·CalculateMetaclass·*/	4334	/*·CalculateMetaclass·*/
4333	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{	4335	static·PyObject·*__Pyx_CalculateMetaclass(PyTypeObject·*metaclass,·PyObject·*bases)·{
4334	····Py_ssize_t·i,·nbases;	4336	····Py_ssize_t·i,·nbases;
4335	#if·CYTHON_ASSUME_SAFE_SIZE	4337	#if·CYTHON_ASSUME_SAFE_SIZE
4336	····nbases·=·PyTuple_GET_SIZE(bases);	4338	····nbases·=·PyTuple_GET_SIZE(bases);
4337	#else	4339	#else
4338	····nbases·=·PyTuple_Size(bases);	4340	····nbases·=·PyTuple_Size(bases);
Offset 4369, 487 lines modified		Offset 4373, 376 lines modified
4369	····if·(!metaclass)·{	4373	····if·(!metaclass)·{
4370	········metaclass·=·&PyType_Type;	4374	········metaclass·=·&PyType_Type;
4371	····}	4375	····}
4372	····Py_INCREF((PyObject*)·metaclass);	4376	····Py_INCREF((PyObject*)·metaclass);
4373	····return·(PyObject*)·metaclass;	4377	····return·(PyObject*)·metaclass;
4374	}	4378	}
		4379	/*·PyObjectCallMethod0·*/
		4380	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod0(PyObject*·obj,·PyObject*·method_name)·{
		4381	#if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)
		4382	····return·PyObject_VectorcallMethod(method_name,·&obj,·1·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);
		4383	#elif·CYTHON_COMPILING_IN_LIMITED_API
		4384	····return·PyObject_CallMethodObjArgs(obj,·method_name,·NULL);
4375	/*·CopyObjectArray·*/
4376	#if·CYTHON_COMPILING_IN_CPYTHON
4377	static·CYTHON_INLINE·void·__Pyx_copy_object_array(PyObject·*const·*CYTHON_RESTRICT·src,·PyObject**·CYTHON_RESTRICT·dest,·Py_ssize_t·length)·{
4378	····PyObject·*v;
4379	····Py_ssize_t·i;
4380	····for·(i·=·0;·i·<·length;·i++)·{
4381	········v·=·dest[i]·=·src[i];
4382	········Py_INCREF(v);
4383	····}
4384	}
4385	#endif
4386	/*·GetVTable·*/
4387	static·int·__Pyx_GetVtable(PyTypeObject·*type,·void**·table)·{
4388	····void*·ptr;
4389	····*table·=·NULL;
4390	#if·CYTHON_COMPILING_IN_LIMITED_API
4391	····PyObject·*ob·=·PyObject_GetAttr((PyObject·*)type,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);
4392	#else	4385	#else
4393	····PyObject·*ob·=·PyObject_GetItem(type->tp_dict,·__pyx_mstate_global->__pyx_n_u_pyx_vtable);	4386	····return·PyObject_CallMethodNoArgs(obj,·method_name);
4394	#endif	4387	#endif
4395	····if·(!ob)
4396	········goto·no_attr;
4397	····ptr·=·PyCapsule_GetPointer(ob,·0);
4398	····if·(!ptr·&&·!PyErr_Occurred())
4399	········PyErr_SetString(PyExc_RuntimeError,·"invalid·vtable·found·for·imported·type");
4400	····Py_DECREF(ob);
4401	····*table·=·ptr;
4402	····return·1;
4403	no_attr:
4404	····if·(PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API·?·PyExc_AttributeError·:·PyExc_KeyError))·{
4405	········return·0;
4406	····}
4407	····Py_XDECREF(ob);
4408	····return·-1;
4409	}	4388	}
4410	/*·RaiseArgTupleInvalid·*/
4411	static·void·__Pyx_RaiseArgtupleInvalid(
4412	····const·char*·func_name,
4413	····int·exact,
4414	····Py_ssize_t·num_min,
4415	····Py_ssize_t·num_max,
4416	····Py_ssize_t·num_found)
4417	{
4418	····Py_ssize_t·num_expected;
4419	····const·char·*more_or_less;
4420	····if·(num_found·<·num_min)·{
4421	········num_expected·=·num_min;
4422	········more_or_less·=·"at·least";
4423	····}·else·{
4424	········num_expected·=·num_max;
4425	········more_or_less·=·"at·most";
4426	····}
4427	····if·(exact)·{
4428	········more_or_less·=·"exactly";	4389	/*·GetTypeDictOffset·*/
		4390	#if·!CYTHON_USE_TYPE_SLOTS
		4391	CYTHON_UNUSED·static·Py_ssize_t·__Pyx_GetTypeDictOffset(PyObject·*tp,·int·require_cython_valid_result)·{
		4392	····PyObject·*tp_dictoffset_o;
		4393	····Py_ssize_t·tp_dictoffset;
		4394	····tp_dictoffset_o·=·PyObject_GetAttrString(tp,·"__dictoffset__");
		4395	····if·(unlikely(!tp_dictoffset_o))·return·-1;
		4396	····tp_dictoffset·=·PyLong_AsSsize_t(tp_dictoffset_o);
		4397	····Py_DECREF(tp_dictoffset_o);
		4398	····if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·==·0))·{
		4399	········PyErr_SetString(
		4400	············PyExc_TypeError,
		4401	············"'type'·doesn't·have·a·dictoffset");
		4402	········return·-1;
		4403	····}·else·if·(unlikely(require_cython_valid_result·&&·tp_dictoffset·<·0))·{
		4404	········PyErr_SetString(
		4405	············PyExc_TypeError,
		4406	············"'type'·has·an·unexpected·negative·dictoffset.·"
		4407	············"Please·report·this·as·Cython·bug");
		4408	········return·-1;
4429	····}	4409	····}
		4410	····return·tp_dictoffset;
4430	····PyErr_Format(PyExc_TypeError,
4431	·················"%.200s()·takes·%.8s·%"·CYTHON_FORMAT_SSIZE_T·"d·positional·argument%.1s·(%"·CYTHON_FORMAT_SSIZE_T·"d·given)",
4432	·················func_name,·more_or_less,·num_expected,
4433	·················(num_expected·==·1)·?·""·:·"s",·num_found);
4434	}
4435	/*·RaiseDoubleKeywords·*/
4436	static·void·__Pyx_RaiseDoubleKeywordsError(
4437	····const·char*·func_name,
4438	····PyObject*·kw_name)
4439	{
4440	····PyErr_Format(PyExc_TypeError,
4441	········"%s()·got·multiple·values·for·keyword·argument·'%U'",·func_name,·kw_name);
4442	}
4443	/*·RaiseErrorWithObjectType·(used·by·ValidateBasesTuple)·*/
4444	static·void·__Pyx_RaiseErrorWithType(PyObject*·exc_type,·const·char*·message,·PyTypeObject·*type_obj)·{
4445	····__Pyx_TypeName·type_name·=·__Pyx_PyType_GetFullyQualifiedName(type_obj);
4446	····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
4447	····if·(unlikely(!type_name))·return;
4448	····#endif
4449	····PyErr_Format(exc_type,·message,·type_name);
4450	····__Pyx_DECREF_TypeName(type_name);
4451	}	4411	}
		4412	#endif
		4413	/*·CheckUnpickleChecksumError·*/
		4414	static·void·__Pyx_RaiseUnpickleChecksumError(long·checksum,·long·checksum1,·long·checksum2,·long·checksum3,·const·char·*members)·{
		4415	····PyObject·*pickle_module·=·PyImport_ImportModule("pickle");
4452	/*·RaiseErrorWithObjectType1·(used·by·ValidateBasesTuple)·*/
4453	static·void·__Pyx_RaiseErrorWithType1(PyObject*·exc_type,·const·char*·message,·const·char·*arg,·PyTypeObject·*type_obj)·{
4454	····__Pyx_TypeName·type_name·=·__Pyx_PyType_GetFullyQualifiedName(type_obj);
4455	····#if·CYTHON_COMPILING_IN_LIMITED_API·&&·__PYX_LIMITED_VERSION_HEX·<·0x030d0000
4456	····if·(unlikely(!type_name))·return;	4416	····if·(unlikely(!pickle_module))·return;
4457	····#endif
4458	····PyErr_Format(exc_type,·message,·arg,·type_name);
4459	····__Pyx_DECREF_TypeName(type_name);	4417	····PyObject·*pickle_error·=·PyObject_GetAttrString(pickle_module,·"PickleError");
		4418	····Py_DECREF(pickle_module);
		4419	····if·(unlikely(!pickle_error))·return;
		4420	····if·(checksum2·==·checksum1)·{
		4421	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x)·=·(%s))",
		4422	············checksum,·checksum1,·members);
		4423	····}·else·if·(checksum3·==·checksum2)·{
		4424	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x,·0x%x)·=·(%s))",
		4425	············checksum,·checksum1,·checksum2,·members);
		4426	····}·else·{
		4427	········PyErr_Format(pickle_error,·"Incompatible·checksums·(0x%x·vs·(0x%x,·0x%x,·0x%x)·=·(%s))",
		4428	············checksum,·checksum1,·checksum2,·checksum3,·members);
		4429	····}
		4430	····Py_DECREF(pickle_error);
4460	}	4431	}
		4432	/*·PyObjectCallMethod1·*/
		4433	static·CYTHON_INLINE·PyObject*·__Pyx_PyObject_CallMethod1(PyObject*·obj,·PyObject*·method_name,·PyObject*·arg)·{
		4434	#if·CYTHON_VECTORCALL·&&·(__PYX_LIMITED_VERSION_HEX·>=·0x030C0000·||·!CYTHON_COMPILING_IN_LIMITED_API)
		4435	····PyObject·*args[2]·=·{obj,·arg};
		4436	····return·PyObject_VectorcallMethod(method_name,·args,·2·|·PY_VECTORCALL_ARGUMENTS_OFFSET,·NULL);
		4437	#elif·CYTHON_COMPILING_IN_LIMITED_API
		4438	····return·PyObject_CallMethodObjArgs(obj,·method_name,·arg,·NULL);
4461	/*·ValidateBasesTuple·(used·by·PyType_Ready)·*/
4462	#if·CYTHON_COMPILING_IN_CPYTHON·||·CYTHON_COMPILING_IN_LIMITED_API·||·CYTHON_USE_TYPE_SPECS
4463	static·int·__Pyx_validate_bases_tuple(const·char·*type_name,·int·has_dictoffset,·PyObject·*bases)·{
4464	····Py_ssize_t·i,·n;
4465	#if·CYTHON_ASSUME_SAFE_SIZE
4466	····n·=·PyTuple_GET_SIZE(bases);
4467	#else
4468	····n·=·PyTuple_Size(bases);
4469	····if·(unlikely(n·<·0))·return·-1;
4470	#endif
4471	····if·(!has_dictoffset)·{
4472	········PyObject·*b;
4473	#if·CYTHON_AVOID_BORROWED_REFS
4474	········b·=·PySequence_GetItem(bases,·0);
4475	········if·(!b)·return·-1;
4476	#elif·CYTHON_ASSUME_SAFE_MACROS
4477	········b·=·PyTuple_GET_ITEM(bases,·0);
4478	#else
4479	········b·=·PyTuple_GetItem(bases,·0);
4480	········if·(!b)·return·-1;
4481	#endif
4482	#if·CYTHON_USE_TYPE_SLOTS
4483	········has_dictoffset·=·((PyTypeObject*)b)->tp_dictoffset·!=·0;
4484	#else	4439	#else
		4440	····return·PyObject_CallMethodOneArg(obj,·method_name,·arg);
4485	········Py_ssize_t·dictoffset·=·__Pyx_GetTypeDictOffset(b,·0);
4486	········has_dictoffset·=·dictoffset·!=·0;
4487	#endif
4488	#if·CYTHON_AVOID_BORROWED_REFS
4489	········Py_DECREF(b);
4490	#endif
4491	#if·!CYTHON_USE_TYPE_SLOTS
4492	········if·(dictoffset·==·-1·&&·PyErr_Occurred())·return·-1;
4493	#endif	4441	#endif
		4442	}
		4443	/*·RaiseException·*/
		4444	static·void·__Pyx_Raise(PyObject·*type,·PyObject·*value,·PyObject·*tb,·PyObject·*cause)·{
		4445	····PyObject*·owned_instance·=·NULL;
		4446	····if·(tb·==·Py_None)·{
		4447	········tb·=·0;
		4448	····}·else·if·(tb·&&·!PyTraceBack_Check(tb))·{
		4449	········PyErr_SetString(PyExc_TypeError,
		4450	············"raise:·arg·3·must·be·a·traceback·or·None");
		4451	········goto·bad;
4494	····}	4452	····}
		4453	····if·(value·==·Py_None)
		4454	········value·=·0;
		4455	····if·(PyExceptionInstance_Check(type))·{
		4456	········if·(value)·{
		4457	············PyErr_SetString(PyExc_TypeError,
		4458	················"instance·exception·may·not·have·a·separate·value");
		4459	············goto·bad;
4495	····for·(i·=·1;·i·<·n;·i++)
4496	····{
4497	········PyTypeObject·*b;
4498	#if·CYTHON_AVOID_BORROWED_REFS
4499	········PyObject·*b0·=·PySequence_GetItem(bases,·i);
4500	········if·(!b0)·return·-1;
4501	#elif·CYTHON_ASSUME_SAFE_MACROS
4502	········PyObject·*b0·=·PyTuple_GET_ITEM(bases,·i);
4503	#else
4504	········PyObject·*b0·=·PyTuple_GetItem(bases,·i);
4505	········if·(!b0)·return·-1;
4506	#endif
4507	········b·=·(PyTypeObject*)·b0;
4508	········if·(!__Pyx_PyType_HasFeature(b,·Py_TPFLAGS_HEAPTYPE))
4509	········{
4510	············__Pyx_RaiseErrorWithType(
4511	················PyExc_TypeError,·"base·class·'"·__Pyx_FMT_TYPENAME·"'·is·not·a·heap·type",·b);
4512	#if·CYTHON_AVOID_BORROWED_REFS
4513	············Py_DECREF(b0);
4514	#endif
4515	············return·-1;
4516	········}	4460	········}
		4461	········value·=·type;
		4462	········type·=·(PyObject*)·Py_TYPE(value);
		4463	····}·else·if·(PyExceptionClass_Check(type))·{
		4464	········PyObject·*instance_class·=·NULL;
		4465	········if·(value·&&·PyExceptionInstance_Check(value))·{
		4466	············instance_class·=·(PyObject*)·Py_TYPE(value);
		4467	············if·(instance_class·!=·type)·{
		4468	················int·is_subclass·=·PyObject_IsSubclass(instance_class,·type);
		4469	················if·(!is_subclass)·{
		4470	····················instance_class·=·NULL;
		4471	················}·else·if·(unlikely(is_subclass·==·-1))·{
4517	········if·(!has_dictoffset)
4518	········{
4519	············Py_ssize_t·b_dictoffset·=·0;
4520	#if·CYTHON_USE_TYPE_SLOTS
4521	············b_dictoffset·=·b->tp_dictoffset;
4522	#else
4523	············b_dictoffset·=·__Pyx_GetTypeDictOffset((PyObject*)b,·0);
4524	············if·(b_dictoffset·==·-1·&&·PyErr_Occurred())·goto·dictoffset_return;
4525	#endif
4526	············if·(b_dictoffset)·{
4527	················__Pyx_RaiseErrorWithType1(
4528	····················PyExc_TypeError,
4529	····················"extension·type·'%.200s'·has·no·__dict__·slot,·"
4530	····················"but·base·type·'"·__Pyx_FMT_TYPENAME·"'·has:·"
4531	····················"either·add·'cdef·dict·__dict__'·to·the·extension·type·"
4532	····················"or·add·'__slots__·=·[...]'·to·the·base·type",
4533	····················type_name,·b);	4472	····················goto·bad;
		4473	················}·else·{
		4474	····················type·=·instance_class;
		4475	················}
4534	#if·!CYTHON_USE_TYPE_SLOTS
4535	··············dictoffset_return:
4536	#endif
4537	#if·CYTHON_AVOID_BORROWED_REFS
4538	················Py_DECREF(b0);
4539	#endif
4540	················return·-1;
4541	············}	4476	············}
4542	········}	4477	········}
4543	#if·CYTHON_AVOID_BORROWED_REFS
4544	········Py_DECREF(b0);
4545	#endif	4478	········if·(!instance_class)·{
		4479	············PyObject·*args;
		4480	············if·(!value)
		4481	················args·=·PyTuple_New(0);
		4482	············else·if·(PyTuple_Check(value))·{
		4483	················Py_INCREF(value);
		4484	················args·=·value;
		4485	············}·else
		4486	················args·=·PyTuple_Pack(1,·value);
		4487	············if·(!args)
		4488	················goto·bad;
		4489	············owned_instance·=·PyObject_Call(type,·args,·NULL);
		4490	············Py_DECREF(args);
		4491	············if·(!owned_instance)
		4492	················goto·bad;
		4493	············value·=·owned_instance;
		4494	············if·(!PyExceptionInstance_Check(value))·{
		4495	················PyErr_Format(PyExc_TypeError,
		4496	·····························"calling·%R·should·have·returned·an·instance·of·"
		4497	·····························"BaseException,·not·%R",
		4498	·····························type,·Py_TYPE(value));
		4499	················goto·bad;
		4500	············}
		4501	········}
		4502	····}·else·{
		4503	········PyErr_SetString(PyExc_TypeError,
		4504	············"raise:·exception·class·must·be·a·subclass·of·BaseException");
		4505	········goto·bad;
4546	····}	4506	····}
4547	····return·0;
4548	}
4549	#endif
4550	/*·PyType_Ready·*/
4551	CYTHON_UNUSED·static·int·__Pyx_PyType_HasMultipleInheritance(PyTypeObject·*t)·{
4552	····while·(t)·{
4553	········PyObject·*bases·=·__Pyx_PyType_GetSlot(t,·tp_bases,·PyObject*);
4554	········if·(bases)·{	4507	····if·(cause)·{
4555	············return·1;	4508	········PyObject·*fixed_cause;
		4509	········if·(cause·==·Py_None)·{
		4510	············fixed_cause·=·NULL;
		4511	········}·else·if·(PyExceptionClass_Check(cause))·{
		4512	············fixed_cause·=·PyObject_CallObject(cause,·NULL);
		4513	············if·(fixed_cause·==·NULL)
		4514	················goto·bad;
		4515	········}·else·if·(PyExceptionInstance_Check(cause))·{
		4516	············fixed_cause·=·cause;
		4517	············Py_INCREF(fixed_cause);
		4518	········}·else·{
		4519	············PyErr_SetString(PyExc_TypeError,
		4520	····························"exception·causes·must·derive·from·"
		4521	····························"BaseException");
		4522	············goto·bad;
4556	········}	4523	········}
4557	········t·=·__Pyx_PyType_GetSlot(t,·tp_base,·PyTypeObject*);	4524	········PyException_SetCause(value,·fixed_cause);
4558	····}	4525	····}
4559	····return·0;
4560	}
4561	static·int·__Pyx_PyType_Ready(PyTypeObject·*t)·{
4562	#if·CYTHON_USE_TYPE_SPECS·||·!CYTHON_COMPILING_IN_CPYTHON
4563	····(void)__Pyx_PyObject_CallMethod0;
4564	#if·CYTHON_USE_TYPE_SPECS
4565	····(void)__Pyx_validate_bases_tuple;
4566	#endif
4567	····return·PyType_Ready(t);	4526	····PyErr_SetObject(type,·value);
		4527	····if·(tb)·{
Max diff block lines reached; 71880/115727 bytes (62.11%) of diff not shown.

Generated by diffoscope 330