PR#9: F30 sync with master - rpms/python-twisted

rpms / python-twisted

#9 F30 sync with master

Merged 4 years ago by churchyard. Opened 4 years ago by churchyard.

rpms/ churchyard/python-twisted f30-sync into f30

Security fix for CVE-2019-12855 (Check remote certificates for XMPP TLS)

Miro Hrončok • 4 years ago

46be2f0

Force recythonize

Miro Hrončok • 4 years ago

2e900ff

Remove .0 from BuildRequires

Miro Hrončok • 4 years ago

a49de42

Rebuilt to update automatic Python dependencies

Miro Hrončok • 4 years ago

fd35a2b

0001-Regenerate-raiser.c-with-Cython-3.0a0.patch

file removed

-1531

		`@@ -1,1531 +0,0 @@`
		`- From ad0ed4966e03ab05b4f61995c5e7c9143b0deb93 Mon Sep 17 00:00:00 2001`
		`- From: =?UTF-8?q?Robert-Andr=C3=A9=20Mauchin?= <zebob.m@gmail.com>`
		`- Date: Tue, 14 May 2019 15:57:30 +0200`
		`- Subject: [PATCH] Regenerate raiser.c with Cython 3.0a0`
		`- MIME-Version: 1.0`
		`- Content-Type: text/plain; charset=UTF-8`
		`- Content-Transfer-Encoding: 8bit`
		`-`
		`- Signed-off-by: Robert-André Mauchin <zebob.m@gmail.com>`
		`- ---`
		`- src/twisted/test/raiser.c \| 876 ++++++++++++++++++++++++++++++--------`
		`- 1 file changed, 704 insertions(+), 172 deletions(-)`
		`-`
		`- diff --git a/src/twisted/test/raiser.c b/src/twisted/test/raiser.c`
		`- index 15b0d2231..3fb55a227 100644`
		`- --- a/src/twisted/test/raiser.c`
		`- +++ b/src/twisted/test/raiser.c`
		`- @@ -1,14 +1,15 @@`
		`- -/* Generated by Cython 0.28.5 */`
		`- +/* Generated by Cython 3.0a0 */`
		`-`
		`- #define PY_SSIZE_T_CLEAN`
		`- #include "Python.h"`
		`- #ifndef Py_PYTHON_H`
		`- #error Python headers needed to compile C extensions, please install development version of Python.`
		`- -#elif PY_VERSION_HEX < 0x02060000 \|\| (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)`
		`- - #error Cython requires Python 2.6+ or Python 3.3+.`
		`- +#elif PY_VERSION_HEX < 0x02070000 \|\| (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)`
		`- + #error Cython requires Python 2.7+ or Python 3.3+.`
		`- #else`
		`- -#define CYTHON_ABI "0_28_5"`
		`- -#define CYTHON_FUTURE_DIVISION 0`
		`- +#define CYTHON_ABI "3_0a0"`
		`- +#define CYTHON_HEX_VERSION 0x030000A0`
		`- +#define CYTHON_FUTURE_DIVISION 1`
		`- #include <stddef.h>`
		`- #ifndef offsetof`
		`- #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )`
		`- @@ -32,9 +33,7 @@`
		`- #endif`
		`- #define __PYX_COMMA ,`
		`- #ifndef HAVE_LONG_LONG`
		`- - #if PY_VERSION_HEX >= 0x02070000`
		`- - #define HAVE_LONG_LONG`
		`- - #endif`
		`- + #define HAVE_LONG_LONG`
		`- #endif`
		`- #ifndef PY_LONG_LONG`
		`- #define PY_LONG_LONG LONG_LONG`
		`- @@ -72,12 +71,18 @@`
		`- #define CYTHON_UNPACK_METHODS 0`
		`- #undef CYTHON_FAST_THREAD_STATE`
		`- #define CYTHON_FAST_THREAD_STATE 0`
		`- + #undef CYTHON_FAST_GIL`
		`- + #define CYTHON_FAST_GIL 0`
		`- #undef CYTHON_FAST_PYCALL`
		`- #define CYTHON_FAST_PYCALL 0`
		`- #undef CYTHON_PEP489_MULTI_PHASE_INIT`
		`- #define CYTHON_PEP489_MULTI_PHASE_INIT 0`
		`- #undef CYTHON_USE_TP_FINALIZE`
		`- #define CYTHON_USE_TP_FINALIZE 0`
		`- + #undef CYTHON_USE_DICT_VERSIONS`
		`- + #define CYTHON_USE_DICT_VERSIONS 0`
		`- + #undef CYTHON_USE_EXC_INFO_STACK`
		`- + #define CYTHON_USE_EXC_INFO_STACK 0`
		`- #elif defined(PYSTON_VERSION)`
		`- #define CYTHON_COMPILING_IN_PYPY 0`
		`- #define CYTHON_COMPILING_IN_PYSTON 1`
		`- @@ -109,12 +114,18 @@`
		`- #endif`
		`- #undef CYTHON_FAST_THREAD_STATE`
		`- #define CYTHON_FAST_THREAD_STATE 0`
		`- + #undef CYTHON_FAST_GIL`
		`- + #define CYTHON_FAST_GIL 0`
		`- #undef CYTHON_FAST_PYCALL`
		`- #define CYTHON_FAST_PYCALL 0`
		`- #undef CYTHON_PEP489_MULTI_PHASE_INIT`
		`- #define CYTHON_PEP489_MULTI_PHASE_INIT 0`
		`- #undef CYTHON_USE_TP_FINALIZE`
		`- #define CYTHON_USE_TP_FINALIZE 0`
		`- + #undef CYTHON_USE_DICT_VERSIONS`
		`- + #define CYTHON_USE_DICT_VERSIONS 0`
		`- + #undef CYTHON_USE_EXC_INFO_STACK`
		`- + #define CYTHON_USE_EXC_INFO_STACK 0`
		`- #else`
		`- #define CYTHON_COMPILING_IN_PYPY 0`
		`- #define CYTHON_COMPILING_IN_PYSTON 0`
		`- @@ -122,10 +133,7 @@`
		`- #ifndef CYTHON_USE_TYPE_SLOTS`
		`- #define CYTHON_USE_TYPE_SLOTS 1`
		`- #endif`
		`- - #if PY_VERSION_HEX < 0x02070000`
		`- - #undef CYTHON_USE_PYTYPE_LOOKUP`
		`- - #define CYTHON_USE_PYTYPE_LOOKUP 0`
		`- - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)`
		`- + #ifndef CYTHON_USE_PYTYPE_LOOKUP`
		`- #define CYTHON_USE_PYTYPE_LOOKUP 1`
		`- #endif`
		`- #if PY_MAJOR_VERSION < 3`
		`- @@ -134,10 +142,7 @@`
		`- #elif !defined(CYTHON_USE_ASYNC_SLOTS)`
		`- #define CYTHON_USE_ASYNC_SLOTS 1`
		`- #endif`
		`- - #if PY_VERSION_HEX < 0x02070000`
		`- - #undef CYTHON_USE_PYLONG_INTERNALS`
		`- - #define CYTHON_USE_PYLONG_INTERNALS 0`
		`- - #elif !defined(CYTHON_USE_PYLONG_INTERNALS)`
		`- + #ifndef CYTHON_USE_PYLONG_INTERNALS`
		`- #define CYTHON_USE_PYLONG_INTERNALS 1`
		`- #endif`
		`- #ifndef CYTHON_USE_PYLIST_INTERNALS`
		`- @@ -164,15 +169,24 @@`
		`- #ifndef CYTHON_FAST_THREAD_STATE`
		`- #define CYTHON_FAST_THREAD_STATE 1`
		`- #endif`
		`- + #ifndef CYTHON_FAST_GIL`
		`- + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 \|\| PY_VERSION_HEX >= 0x03060000)`
		`- + #endif`
		`- #ifndef CYTHON_FAST_PYCALL`
		`- #define CYTHON_FAST_PYCALL 1`
		`- #endif`
		`- #ifndef CYTHON_PEP489_MULTI_PHASE_INIT`
		`- - #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000)`
		`- + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)`
		`- #endif`
		`- #ifndef CYTHON_USE_TP_FINALIZE`
		`- #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)`
		`- #endif`
		`- + #ifndef CYTHON_USE_DICT_VERSIONS`
		`- + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)`
		`- + #endif`
		`- + #ifndef CYTHON_USE_EXC_INFO_STACK`
		`- + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)`
		`- + #endif`
		`- #endif`
		`- #if !defined(CYTHON_FAST_PYCCALL)`
		`- #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)`
		`- @@ -182,6 +196,9 @@`
		`- #undef SHIFT`
		`- #undef BASE`
		`- #undef MASK`
		`- + #ifdef SIZEOF_VOID_P`
		`- + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };`
		`- + #endif`
		`- #endif`
		`- #ifndef __has_attribute`
		`- #define __has_attribute(x) 0`
		`- @@ -231,15 +248,31 @@`
		`- #ifdef _MSC_VER`
		`- #ifndef _MSC_STDINT_H_`
		`- #if _MSC_VER < 1300`
		`- - typedef unsigned char uint8_t;`
		`- - typedef unsigned int uint32_t;`
		`- + typedef unsigned char uint8_t;`
		`- + typedef unsigned short uint16_t;`
		`- + typedef unsigned int uint32_t;`
		`- #else`
		`- - typedef unsigned __int8 uint8_t;`
		`- - typedef unsigned __int32 uint32_t;`
		`- + typedef unsigned __int8 uint8_t;`
		`- + typedef unsigned __int16 uint16_t;`
		`- + typedef unsigned __int32 uint32_t;`
		`- + #endif`
		`- + #endif`
		`- + #if _MSC_VER < 1300`
		`- + #ifdef _WIN64`
		`- + typedef unsigned long long __pyx_uintptr_t;`
		`- + #else`
		`- + typedef unsigned int __pyx_uintptr_t;`
		`- + #endif`
		`- + #else`
		`- + #ifdef _WIN64`
		`- + typedef unsigned __int64 __pyx_uintptr_t;`
		`- + #else`
		`- + typedef unsigned __int32 __pyx_uintptr_t;`
		`- #endif`
		`- #endif`
		`- #else`
		`- - #include <stdint.h>`
		`- + #include <stdint.h>`
		`- + typedef uintptr_t __pyx_uintptr_t;`
		`- #endif`
		`- #ifndef CYTHON_FALLTHROUGH`
		`- #if defined(__cplusplus) && __cplusplus >= 201103L`
		`- @@ -287,13 +320,18 @@`
		`- #define CYTHON_FORMAT_SSIZE_T "z"`
		`- #if PY_MAJOR_VERSION < 3`
		`- #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"`
		`- - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\`
		`- - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)`
		`- + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\`
		`- + PyCode_New(p+a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)`
		`- #define __Pyx_DefaultClassType PyClass_Type`
		`- #else`
		`- #define __Pyx_BUILTIN_MODULE_NAME "builtins"`
		`- - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\`
		`- - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)`
		`- +#if PY_VERSION_HEX < 0x030800A4`
		`- + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\`
		`- + PyCode_New(p+a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)`
		`- +#else`
		`- + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\`
		`- + PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)`
		`- +#endif`
		`- #define __Pyx_DefaultClassType PyType_Type`
		`- #endif`
		`- #ifndef Py_TPFLAGS_CHECKTYPES`
		`- @@ -308,6 +346,9 @@`
		`- #ifndef Py_TPFLAGS_HAVE_FINALIZE`
		`- #define Py_TPFLAGS_HAVE_FINALIZE 0`
		`- #endif`
		`- +#ifndef METH_STACKLESS`
		`- + #define METH_STACKLESS 0`
		`- +#endif`
		`- #if PY_VERSION_HEX <= 0x030700A3 \|\| !defined(METH_FASTCALL)`
		`- #ifndef METH_FASTCALL`
		`- #define METH_FASTCALL 0x80`
		`- @@ -321,7 +362,7 @@`
		`- #endif`
		`- #if CYTHON_FAST_PYCCALL`
		`- #define __Pyx_PyFastCFunction_Check(func)\`
		`- - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS \| METH_STATIC \| METH_COEXIST \| METH_KEYWORDS)))))`
		`- + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS \| METH_STATIC \| METH_COEXIST \| METH_KEYWORDS \| METH_STACKLESS)))))`
		`- #else`
		`- #define __Pyx_PyFastCFunction_Check(func) 0`
		`- #endif`
		`- @@ -330,6 +371,11 @@`
		`- #define PyObject_Free(p) PyMem_Free(p)`
		`- #define PyObject_Realloc(p) PyMem_Realloc(p)`
		`- #endif`
		`- +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1`
		`- + #define PyMem_RawMalloc(n) PyMem_Malloc(n)`
		`- + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n)`
		`- + #define PyMem_RawFree(p) PyMem_Free(p)`
		`- +#endif`
		`- #if CYTHON_COMPILING_IN_PYSTON`
		`- #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)`
		`- #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)`
		`- @@ -337,7 +383,7 @@`
		`- #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)`
		`- #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)`
		`- #endif`
		`- -#if !CYTHON_FAST_THREAD_STATE \|\| PY_VERSION_HEX < 0x02070000`
		`- +#if !CYTHON_FAST_THREAD_STATE`
		`- #define __Pyx_PyThreadState_Current PyThreadState_GET()`
		`- #elif PY_VERSION_HEX >= 0x03060000`
		`- #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()`
		`- @@ -352,7 +398,7 @@`
		`- typedef int Py_tss_t;`
		`- static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {`
		`- *key = PyThread_create_key();`
		`- - return 0; // PyThread_create_key reports success always`
		`- + return 0;`
		`- }`
		`- static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {`
		`- Py_tss_t key = (Py_tss_t )PyObject_Malloc(sizeof(Py_tss_t));`
		`- @@ -375,7 +421,7 @@ static CYTHON_INLINE int PyThread_tss_set(Py_tss_t key, void value) {`
		`- static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {`
		`- return PyThread_get_key_value(*key);`
		`- }`
		`- -#endif // TSS (Thread Specific Storage) API`
		`- +#endif`
		`- #if CYTHON_COMPILING_IN_CPYTHON \|\| defined(_PyDict_NewPresized)`
		`- #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))`
		`- #else`
		`- @@ -437,8 +483,8 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {`
		`- #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)`
		`- #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)`
		`- #endif`
		`- -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))`
		`- -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))`
		`- +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None \|\| (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))`
		`- +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None \|\| (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))`
		`- #if PY_MAJOR_VERSION >= 3`
		`- #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)`
		`- #else`
		`- @@ -453,8 +499,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {`
		`- #define PyString_Type PyUnicode_Type`
		`- #define PyString_Check PyUnicode_Check`
		`- #define PyString_CheckExact PyUnicode_CheckExact`
		`- +#ifndef PyObject_Unicode`
		`- #define PyObject_Unicode PyObject_Str`
		`- #endif`
		`- +#endif`
		`- #if PY_MAJOR_VERSION >= 3`
		`- #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)`
		`- #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)`
		`- @@ -498,10 +546,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {`
		`- #if PY_VERSION_HEX < 0x030200A4`
		`- typedef long Py_hash_t;`
		`- #define __Pyx_PyInt_FromHash_t PyInt_FromLong`
		`- - #define __Pyx_PyInt_AsHash_t PyInt_AsLong`
		`- + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t`
		`- #else`
		`- #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t`
		`- - #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t`
		`- + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t`
		`- #endif`
		`- #if PY_MAJOR_VERSION >= 3`
		`- #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func))`
		`- @@ -574,7 +622,8 @@ typedef struct {PyObject *p; const char s; const Py_ssize_t n; const char* enc`
		`- const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;`
		`-`
		`- #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0`
		`- -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0`
		`- +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0`
		`- +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)`
		`- #define __PYX_DEFAULT_STRING_ENCODING ""`
		`- #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString`
		`- #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize`
		`- @@ -590,6 +639,9 @@ typedef struct {PyObject *p; const char s; const Py_ssize_t n; const char* enc`
		`- (sizeof(type) == sizeof(Py_ssize_t) &&\`
		`- (is_signed \|\| likely(v < (type)PY_SSIZE_T_MAX \|\|\`
		`- v == (type)PY_SSIZE_T_MAX))) )`
		`- +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {`
		`- + return (size_t) i < (size_t) limit;`
		`- +}`
		`- #if defined (__cplusplus) && __cplusplus >= 201103L`
		`- #include <cstdlib>`
		`- #define __Pyx_sst_abs(value) std::abs(value)`
		`- @@ -626,9 +678,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);`
		`- #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))`
		`- #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))`
		`- #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))`
		`- -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s))`
		`- -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s))`
		`- -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))`
		`- +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))`
		`- +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))`
		`- +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))`
		`- #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))`
		`- #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))`
		`- #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)`
		`- @@ -648,11 +700,13 @@ static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {`
		`- #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)`
		`- static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);`
		`- static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);`
		`- +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);`
		`- static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);`
		`- #define __Pyx_PySequence_Tuple(obj)\`
		`- (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))`
		`- static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);`
		`- static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);`
		`- +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);`
		`- #if CYTHON_ASSUME_SAFE_MACROS`
		`- #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))`
		`- #else`
		`- @@ -728,7 +782,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {`
		`- if (!default_encoding) goto bad;`
		`- default_encoding_c = PyBytes_AsString(default_encoding);`
		`- if (!default_encoding_c) goto bad;`
		`- - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));`
		`- + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);`
		`- if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;`
		`- strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);`
		`- Py_DECREF(default_encoding);`
		`- @@ -765,7 +819,7 @@ static const char *__pyx_filename;`
		`-`
		`-`
		`- static const char *__pyx_f[] = {`
		`- - "src/twisted/test/raiser.pyx",`
		`- + "raiser.pyx",`
		`- };`
		`-`
		`- /--- Type declarations ---/`
		`- @@ -834,24 +888,12 @@ static const char *__pyx_f[] = {`
		`- #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)`
		`- #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)`
		`-`
		`- -/* PyObjectGetAttrStr.proto */`
		`- -#if CYTHON_USE_TYPE_SLOTS`
		`- -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);`
		`- -#else`
		`- -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)`
		`- -#endif`
		`- -`
		`- -/* GetBuiltinName.proto */`
		`- -static PyObject __Pyx_GetBuiltinName(PyObject name);`
		`- -`
		`- -/* GetModuleGlobalName.proto */`
		`- -static CYTHON_INLINE PyObject __Pyx_GetModuleGlobalName(PyObject name);`
		`- -`
		`- -/* PyObjectCall.proto */`
		`- -#if CYTHON_COMPILING_IN_CPYTHON`
		`- -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject func, PyObject arg, PyObject *kw);`
		`- +/* PyErrExceptionMatches.proto */`
		`- +#if CYTHON_FAST_THREAD_STATE`
		`- +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)`
		`- +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);`
		`- #else`
		`- -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)`
		`- +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)`
		`- #endif`
		`-`
		`- /* PyThreadStateGet.proto */`
		`- @@ -890,6 +932,114 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject`
		`- #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)`
		`- #endif`
		`-`
		`- +/* PyObjectGetAttrStr.proto */`
		`- +#if CYTHON_USE_TYPE_SLOTS`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);`
		`- +#else`
		`- +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)`
		`- +#endif`
		`- +`
		`- +/* PyObjectGetAttrStrNoError.proto */`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);`
		`- +`
		`- +/* GetBuiltinName.proto */`
		`- +static PyObject __Pyx_GetBuiltinName(PyObject name);`
		`- +`
		`- +/* PyDictVersioning.proto */`
		`- +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS`
		`- +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)`
		`- +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)`
		`- +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\`
		`- + (version_var) = __PYX_GET_DICT_VERSION(dict);\`
		`- + (cache_var) = (value);`
		`- +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\`
		`- + static PY_UINT64_T __pyx_dict_version = 0;\`
		`- + static PyObject *__pyx_dict_cached_value = NULL;\`
		`- + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\`
		`- + (VAR) = __pyx_dict_cached_value;\`
		`- + } else {\`
		`- + (VAR) = __pyx_dict_cached_value = (LOOKUP);\`
		`- + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\`
		`- + }\`
		`- +}`
		`- +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);`
		`- +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);`
		`- +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);`
		`- +#else`
		`- +#define __PYX_GET_DICT_VERSION(dict) (0)`
		`- +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)`
		`- +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);`
		`- +#endif`
		`- +`
		`- +/* GetModuleGlobalName.proto */`
		`- +#if CYTHON_USE_DICT_VERSIONS`
		`- +#define __Pyx_GetModuleGlobalName(var, name) {\`
		`- + static PY_UINT64_T __pyx_dict_version = 0;\`
		`- + static PyObject *__pyx_dict_cached_value = NULL;\`
		`- + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\`
		`- + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\`
		`- + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\`
		`- +}`
		`- +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\`
		`- + PY_UINT64_T __pyx_dict_version;\`
		`- + PyObject *__pyx_dict_cached_value;\`
		`- + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\`
		`- +}`
		`- +static PyObject __Pyx__GetModuleGlobalName(PyObject name, PY_UINT64_T dict_version, PyObject *dict_cached_value);`
		`- +#else`
		`- +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name)`
		`- +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name)`
		`- +static CYTHON_INLINE PyObject __Pyx__GetModuleGlobalName(PyObject name);`
		`- +#endif`
		`- +`
		`- +/* PyCFunctionFastCall.proto */`
		`- +#if CYTHON_FAST_PYCCALL`
		`- +static CYTHON_INLINE PyObject __Pyx_PyCFunction_FastCall(PyObject func, PyObject **args, Py_ssize_t nargs);`
		`- +#else`
		`- +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL)`
		`- +#endif`
		`- +`
		`- +/* PyFunctionFastCall.proto */`
		`- +#if CYTHON_FAST_PYCALL`
		`- +#define __Pyx_PyFunction_FastCall(func, args, nargs)\`
		`- + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)`
		`- +#if 1 \|\| PY_VERSION_HEX < 0x030600B1`
		`- +static PyObject __Pyx_PyFunction_FastCallDict(PyObject func, PyObject *args, int nargs, PyObject kwargs);`
		`- +#else`
		`- +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)`
		`- +#endif`
		`- +#define __Pyx_BUILD_ASSERT_EXPR(cond)\`
		`- + (sizeof(char [1 - 2*!(cond)]) - 1)`
		`- +#ifndef Py_MEMBER_SIZE`
		`- +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)`
		`- +#endif`
		`- + static size_t __pyx_pyframe_localsplus_offset = 0;`
		`- + #include "frameobject.h"`
		`- + #define __Pxy_PyFrame_Initialize_Offsets()\`
		`- + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\`
		`- + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))`
		`- + #define __Pyx_PyFrame_GetLocalsplus(frame)\`
		`- + (assert(__pyx_pyframe_localsplus_offset), (PyObject *)(((char )(frame)) + __pyx_pyframe_localsplus_offset))`
		`- +#endif`
		`- +`
		`- +/* PyObjectCall.proto */`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject func, PyObject arg, PyObject *kw);`
		`- +#else`
		`- +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)`
		`- +#endif`
		`- +`
		`- +/* PyObjectCall2Args.proto */`
		`- +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);`
		`- +`
		`- +/* PyObjectCallMethO.proto */`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject func, PyObject arg);`
		`- +#endif`
		`- +`
		`- +/* PyObjectCallOneArg.proto */`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject func, PyObject arg);`
		`- +`
		`- /* RaiseException.proto */`
		`- static void __Pyx_Raise(PyObject type, PyObject value, PyObject tb, PyObject cause);`
		`-`
		`- @@ -965,16 +1115,17 @@ int __pyx_module_is_main_twisted__test__raiser = 0;`
		`- /* Implementation of 'twisted.test.raiser' */`
		`- static const char __pyx_k_doc[] = "__doc__";`
		`- static const char __pyx_k_main[] = "__main__";`
		`- +static const char __pyx_k_name[] = "__name__";`
		`- static const char __pyx_k_test[] = "__test__";`
		`- static const char __pyx_k_module[] = "__module__";`
		`- static const char __pyx_k_prepare[] = "__prepare__";`
		`- static const char __pyx_k_qualname[] = "__qualname__";`
		`- static const char __pyx_k_metaclass[] = "__metaclass__";`
		`- +static const char __pyx_k_raiser_pyx[] = "raiser.pyx";`
		`- static const char __pyx_k_raiseException[] = "raiseException";`
		`- static const char __pyx_k_RaiserException[] = "RaiserException";`
		`- static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";`
		`- static const char __pyx_k_twisted_test_raiser[] = "twisted.test.raiser";`
		`- -static const char __pyx_k_src_twisted_test_raiser_pyx[] = "src/twisted/test/raiser.pyx";`
		`- static const char __pyx_k_A_speficic_exception_only_used[] = "\n A speficic exception only used to be identified in tests.\n ";`
		`- static const char __pyx_k_A_trivial_extension_that_just_r[] = "\nA trivial extension that just raises an exception.\nSee L{twisted.test.test_failure.test_failureConstructionWithMungedStackSucceeds}.\n";`
		`- static const char __pyx_k_This_function_is_intentionally_b[] = "This function is intentionally broken";`
		`- @@ -986,15 +1137,15 @@ static PyObject *__pyx_n_s_doc;`
		`- static PyObject *__pyx_n_s_main;`
		`- static PyObject *__pyx_n_s_metaclass;`
		`- static PyObject *__pyx_n_s_module;`
		`- +static PyObject *__pyx_n_s_name;`
		`- static PyObject *__pyx_n_s_prepare;`
		`- static PyObject *__pyx_n_s_qualname;`
		`- static PyObject *__pyx_n_s_raiseException;`
		`- -static PyObject *__pyx_kp_s_src_twisted_test_raiser_pyx;`
		`- +static PyObject *__pyx_kp_s_raiser_pyx;`
		`- static PyObject *__pyx_n_s_test;`
		`- static PyObject *__pyx_n_s_twisted_test_raiser;`
		`- static PyObject __pyx_pf_7twisted_4test_6raiser_raiseException(CYTHON_UNUSED PyObject __pyx_self); /* proto */`
		`- -static PyObject *__pyx_tuple_;`
		`- -static PyObject *__pyx_codeobj__2;`
		`- +static PyObject *__pyx_codeobj_;`
		`- /* Late includes */`
		`-`
		`- /* "twisted/test/raiser.pyx":17`
		`- @@ -1007,7 +1158,7 @@ static PyObject *__pyx_codeobj__2;`
		`-`
		`- /* Python wrapper */`
		`- static PyObject __pyx_pw_7twisted_4test_6raiser_1raiseException(PyObject __pyx_self, CYTHON_UNUSED PyObject unused); /proto*/`
		`- -static char __pyx_doc_7twisted_4test_6raiser_raiseException[] = "\n Raise L{RaiserException}.\n ";`
		`- +PyDoc_STRVAR(__pyx_doc_7twisted_4test_6raiser_raiseException, "\n Raise L{RaiserException}.\n ");`
		`- static PyMethodDef __pyx_mdef_7twisted_4test_6raiser_1raiseException = {"raiseException", (PyCFunction)__pyx_pw_7twisted_4test_6raiser_1raiseException, METH_NOARGS, __pyx_doc_7twisted_4test_6raiser_raiseException};`
		`- static PyObject __pyx_pw_7twisted_4test_6raiser_1raiseException(PyObject __pyx_self, CYTHON_UNUSED PyObject *unused) {`
		`- PyObject *__pyx_r = 0;`
		`- @@ -1025,6 +1176,7 @@ static PyObject *__pyx_pf_7twisted_4test_6raiser_raiseException(CYTHON_UNUSED Py`
		`- __Pyx_RefNannyDeclarations`
		`- PyObject *__pyx_t_1 = NULL;`
		`- PyObject *__pyx_t_2 = NULL;`
		`- + PyObject *__pyx_t_3 = NULL;`
		`- __Pyx_RefNannySetupContext("raiseException", 0);`
		`-`
		`- /* "twisted/test/raiser.pyx":21`
		`- @@ -1032,13 +1184,25 @@ static PyObject *__pyx_pf_7twisted_4test_6raiser_raiseException(CYTHON_UNUSED Py`
		`- * """`
		`- * raise RaiserException("This function is intentionally broken") # <<<<<<<<<<<<<<`
		`- */`
		`- - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_RaiserException); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)`
		`- - __Pyx_GOTREF(__pyx_t_1);`
		`- - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)`
		`- + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_RaiserException); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)`
		`- __Pyx_GOTREF(__pyx_t_2);`
		`- - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;`
		`- - __Pyx_Raise(__pyx_t_2, 0, 0, 0);`
		`- + __pyx_t_3 = NULL;`
		`- + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {`
		`- + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);`
		`- + if (likely(__pyx_t_3)) {`
		`- + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);`
		`- + __Pyx_INCREF(__pyx_t_3);`
		`- + __Pyx_INCREF(function);`
		`- + __Pyx_DECREF_SET(__pyx_t_2, function);`
		`- + }`
		`- + }`
		`- + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s_This_function_is_intentionally_b) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s_This_function_is_intentionally_b);`
		`- + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;`
		`- + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)`
		`- + __Pyx_GOTREF(__pyx_t_1);`
		`- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;`
		`- + __Pyx_Raise(__pyx_t_1, 0, 0, 0);`
		`- + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;`
		`- __PYX_ERR(0, 21, __pyx_L1_error)`
		`-`
		`- /* "twisted/test/raiser.pyx":17`
		`- @@ -1053,6 +1217,7 @@ static PyObject *__pyx_pf_7twisted_4test_6raiser_raiseException(CYTHON_UNUSED Py`
		`- __pyx_L1_error:;`
		`- __Pyx_XDECREF(__pyx_t_1);`
		`- __Pyx_XDECREF(__pyx_t_2);`
		`- + __Pyx_XDECREF(__pyx_t_3);`
		`- __Pyx_AddTraceback("twisted.test.raiser.raiseException", __pyx_clineno, __pyx_lineno, __pyx_filename);`
		`- __pyx_r = NULL;`
		`- __Pyx_XGIVEREF(__pyx_r);`
		`- @@ -1095,6 +1260,15 @@ static struct PyModuleDef __pyx_moduledef = {`
		`- NULL /* m_free */`
		`- };`
		`- #endif`
		`- +#ifndef CYTHON_SMALL_CODE`
		`- +#if defined(__clang__)`
		`- + #define CYTHON_SMALL_CODE`
		`- +#elif defined(__GNUC__) && (__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))`
		`- + #define CYTHON_SMALL_CODE __attribute__((cold))`
		`- +#else`
		`- + #define CYTHON_SMALL_CODE`
		`- +#endif`
		`- +#endif`
		`-`
		`- static __Pyx_StringTabEntry __pyx_string_tab[] = {`
		`- {&__pyx_kp_s_A_speficic_exception_only_used, __pyx_k_A_speficic_exception_only_used, sizeof(__pyx_k_A_speficic_exception_only_used), 0, 0, 1, 0},`
		`- @@ -1105,31 +1279,23 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {`
		`- {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},`
		`- {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},`
		`- {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},`
		`- + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},`
		`- {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},`
		`- {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},`
		`- {&__pyx_n_s_raiseException, __pyx_k_raiseException, sizeof(__pyx_k_raiseException), 0, 0, 1, 1},`
		`- - {&__pyx_kp_s_src_twisted_test_raiser_pyx, __pyx_k_src_twisted_test_raiser_pyx, sizeof(__pyx_k_src_twisted_test_raiser_pyx), 0, 0, 1, 0},`
		`- + {&__pyx_kp_s_raiser_pyx, __pyx_k_raiser_pyx, sizeof(__pyx_k_raiser_pyx), 0, 0, 1, 0},`
		`- {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},`
		`- {&__pyx_n_s_twisted_test_raiser, __pyx_k_twisted_test_raiser, sizeof(__pyx_k_twisted_test_raiser), 0, 0, 1, 1},`
		`- {0, 0, 0, 0, 0, 0, 0}`
		`- };`
		`- -static int __Pyx_InitCachedBuiltins(void) {`
		`- +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {`
		`- return 0;`
		`- }`
		`-`
		`- -static int __Pyx_InitCachedConstants(void) {`
		`- +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {`
		`- __Pyx_RefNannyDeclarations`
		`- __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);`
		`-`
		`- - /* "twisted/test/raiser.pyx":21`
		`- - * Raise L{RaiserException}.`
		`- - * """`
		`- - * raise RaiserException("This function is intentionally broken") # <<<<<<<<<<<<<<`
		`- - */`
		`- - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_This_function_is_intentionally_b); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 21, __pyx_L1_error)`
		`- - __Pyx_GOTREF(__pyx_tuple_);`
		`- - __Pyx_GIVEREF(__pyx_tuple_);`
		`- -`
		`- /* "twisted/test/raiser.pyx":17`
		`- *`
		`- *`
		`- @@ -1137,7 +1303,7 @@ static int __Pyx_InitCachedConstants(void) {`
		`- * """`
		`- * Raise L{RaiserException}.`
		`- */`
		`- - __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED\|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_twisted_test_raiser_pyx, __pyx_n_s_raiseException, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 17, __pyx_L1_error)`
		`- + __pyx_codeobj_ = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, CO_OPTIMIZED\|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_raiser_pyx, __pyx_n_s_raiseException, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj_)) __PYX_ERR(0, 17, __pyx_L1_error)`
		`- __Pyx_RefNannyFinishContext();`
		`- return 0;`
		`- __pyx_L1_error:;`
		`- @@ -1145,20 +1311,20 @@ static int __Pyx_InitCachedConstants(void) {`
		`- return -1;`
		`- }`
		`-`
		`- -static int __Pyx_InitGlobals(void) {`
		`- +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {`
		`- if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);`
		`- return 0;`
		`- __pyx_L1_error:;`
		`- return -1;`
		`- }`
		`-`
		`- -static int __Pyx_modinit_global_init_code(void); /proto/`
		`- -static int __Pyx_modinit_variable_export_code(void); /proto/`
		`- -static int __Pyx_modinit_function_export_code(void); /proto/`
		`- -static int __Pyx_modinit_type_init_code(void); /proto/`
		`- -static int __Pyx_modinit_type_import_code(void); /proto/`
		`- -static int __Pyx_modinit_variable_import_code(void); /proto/`
		`- -static int __Pyx_modinit_function_import_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /proto/`
		`- +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /proto/`
		`-`
		`- static int __Pyx_modinit_global_init_code(void) {`
		`- __Pyx_RefNannyDeclarations`
		`- @@ -1230,15 +1396,6 @@ static int __Pyx_modinit_function_import_code(void) {`
		`- #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC`
		`- #endif`
		`- #endif`
		`- -#ifndef CYTHON_SMALL_CODE`
		`- -#if defined(__clang__)`
		`- - #define CYTHON_SMALL_CODE`
		`- -#elif defined(__GNUC__) && (!(defined(__cplusplus)) \|\| (__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ > 4)))`
		`- - #define CYTHON_SMALL_CODE __attribute__((cold))`
		`- -#else`
		`- - #define CYTHON_SMALL_CODE`
		`- -#endif`
		`- -#endif`
		`-`
		`-`
		`- #if PY_MAJOR_VERSION < 3`
		`- @@ -1251,11 +1408,36 @@ __Pyx_PyMODINIT_FUNC PyInit_raiser(void)`
		`- {`
		`- return PyModuleDef_Init(&__pyx_moduledef);`
		`- }`
		`- -static int __Pyx_copy_spec_to_module(PyObject spec, PyObject moddict, const char* from_name, const char* to_name) {`
		`- +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {`
		`- + #if PY_VERSION_HEX >= 0x030700A1`
		`- + static PY_INT64_T main_interpreter_id = -1;`
		`- + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);`
		`- + if (main_interpreter_id == -1) {`
		`- + main_interpreter_id = current_id;`
		`- + return (unlikely(current_id == -1)) ? -1 : 0;`
		`- + } else if (unlikely(main_interpreter_id != current_id))`
		`- + #else`
		`- + static PyInterpreterState *main_interpreter = NULL;`
		`- + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;`
		`- + if (!main_interpreter) {`
		`- + main_interpreter = current_interpreter;`
		`- + } else if (unlikely(main_interpreter != current_interpreter))`
		`- + #endif`
		`- + {`
		`- + PyErr_SetString(`
		`- + PyExc_ImportError,`
		`- + "Interpreter change detected - this module can only be loaded into one interpreter per process.");`
		`- + return -1;`
		`- + }`
		`- + return 0;`
		`- +}`
		`- +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject spec, PyObject moddict, const char* from_name, const char* to_name, int allow_none) {`
		`- PyObject *value = PyObject_GetAttrString(spec, from_name);`
		`- int result = 0;`
		`- if (likely(value)) {`
		`- - result = PyDict_SetItemString(moddict, to_name, value);`
		`- + if (allow_none \|\| value != Py_None) {`
		`- + result = PyDict_SetItemString(moddict, to_name, value);`
		`- + }`
		`- Py_DECREF(value);`
		`- } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {`
		`- PyErr_Clear();`
		`- @@ -1264,8 +1446,10 @@ static int __Pyx_copy_spec_to_module(PyObject spec, PyObject moddict, const ch`
		`- }`
		`- return result;`
		`- }`
		`- -static PyObject* __pyx_pymod_create(PyObject spec, CYTHON_UNUSED PyModuleDef def) {`
		`- +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject spec, CYTHON_UNUSED PyModuleDef def) {`
		`- PyObject module = NULL, moddict, *modname;`
		`- + if (__Pyx_check_single_interpreter())`
		`- + return NULL;`
		`- if (__pyx_m)`
		`- return __Pyx_NewRef(__pyx_m);`
		`- modname = PyObject_GetAttrString(spec, "name");`
		`- @@ -1275,10 +1459,10 @@ static PyObject* __pyx_pymod_create(PyObject spec, CYTHON_UNUSED PyModuleDef d`
		`- if (unlikely(!module)) goto bad;`
		`- moddict = PyModule_GetDict(module);`
		`- if (unlikely(!moddict)) goto bad;`
		`- - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad;`
		`- - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad;`
		`- - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad;`
		`- - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad;`
		`- + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;`
		`- + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;`
		`- + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;`
		`- + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;`
		`- return module;`
		`- bad:`
		`- Py_XDECREF(module);`
		`- @@ -1286,7 +1470,7 @@ bad:`
		`- }`
		`-`
		`-`
		`- -static int __pyx_pymod_exec_raiser(PyObject *__pyx_pyinit_module)`
		`- +static CYTHON_SMALL_CODE int __pyx_pymod_exec_raiser(PyObject *__pyx_pyinit_module)`
		`- #endif`
		`- #endif`
		`- {`
		`- @@ -1296,7 +1480,11 @@ static int __pyx_pymod_exec_raiser(PyObject *__pyx_pyinit_module)`
		`- PyObject *__pyx_t_4 = NULL;`
		`- __Pyx_RefNannyDeclarations`
		`- #if CYTHON_PEP489_MULTI_PHASE_INIT`
		`- - if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0;`
		`- + if (__pyx_m) {`
		`- + if (__pyx_m == __pyx_pyinit_module) return 0;`
		`- + PyErr_SetString(PyExc_RuntimeError, "Module 'raiser' has already been imported. Re-initialisation is not supported.");`
		`- + return -1;`
		`- + }`
		`- #elif PY_MAJOR_VERSION >= 3`
		`- if (__pyx_m) return __Pyx_NewRef(__pyx_m);`
		`- #endif`
		`- @@ -1311,6 +1499,9 @@ if (!__Pyx_RefNanny) {`
		`- #endif`
		`- __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_raiser(void)", 0);`
		`- if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- + #ifdef __Pxy_PyFrame_Initialize_Offsets`
		`- + __Pxy_PyFrame_Initialize_Offsets();`
		`- + #endif`
		`- __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- @@ -1354,10 +1545,9 @@ if (!__Pyx_RefNanny) {`
		`- __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- Py_INCREF(__pyx_d);`
		`- __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- - #if CYTHON_COMPILING_IN_PYPY`
		`- Py_INCREF(__pyx_b);`
		`- - #endif`
		`- + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- + Py_INCREF(__pyx_cython_runtime);`
		`- if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);`
		`- /--- Initialize various global constants etc. ---/`
		`- if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- @@ -1365,7 +1555,7 @@ if (!__Pyx_RefNanny) {`
		`- if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- #endif`
		`- if (__pyx_module_is_main_twisted__test__raiser) {`
		`- - if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)`
		`- }`
		`- #if PY_MAJOR_VERSION >= 3`
		`- {`
		`- @@ -1408,7 +1598,7 @@ if (!__Pyx_RefNanny) {`
		`- __Pyx_GOTREF(__pyx_t_2);`
		`- __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_RaiserException, __pyx_n_s_RaiserException, (PyObject *) NULL, __pyx_n_s_twisted_test_raiser, __pyx_kp_s_A_speficic_exception_only_used); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 11, __pyx_L1_error)`
		`- __Pyx_GOTREF(__pyx_t_3);`
		`- - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_RaiserException, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 11, __pyx_L1_error)`
		`- + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_RaiserException, __pyx_t_1, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 11, __pyx_L1_error)`
		`- __Pyx_GOTREF(__pyx_t_4);`
		`- if (PyDict_SetItem(__pyx_d, __pyx_n_s_RaiserException, __pyx_t_4) < 0) __PYX_ERR(0, 11, __pyx_L1_error)`
		`- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;`
		`- @@ -1448,9 +1638,9 @@ if (!__Pyx_RefNanny) {`
		`- __Pyx_XDECREF(__pyx_t_4);`
		`- if (__pyx_m) {`
		`- if (__pyx_d) {`
		`- - __Pyx_AddTraceback("init twisted.test.raiser", 0, __pyx_lineno, __pyx_filename);`
		`- + __Pyx_AddTraceback("init twisted.test.raiser", __pyx_clineno, __pyx_lineno, __pyx_filename);`
		`- }`
		`- - Py_DECREF(__pyx_m); __pyx_m = 0;`
		`- + Py_CLEAR(__pyx_m);`
		`- } else if (!PyErr_Occurred()) {`
		`- PyErr_SetString(PyExc_ImportError, "init twisted.test.raiser");`
		`- }`
		`- @@ -1471,9 +1661,9 @@ if (!__Pyx_RefNanny) {`
		`- static __Pyx_RefNannyAPIStruct __Pyx_RefNannyImportAPI(const char modname) {`
		`- PyObject m = NULL, p = NULL;`
		`- void *r = NULL;`
		`- - m = PyImport_ImportModule((char *)modname);`
		`- + m = PyImport_ImportModule(modname);`
		`- if (!m) goto end;`
		`- - p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");`
		`- + p = PyObject_GetAttrString(m, "RefNannyAPI");`
		`- if (!p) goto end;`
		`- r = PyLong_AsVoidPtr(p);`
		`- end:`
		`- @@ -1483,6 +1673,55 @@ end:`
		`- }`
		`- #endif`
		`-`
		`- +/* PyErrExceptionMatches */`
		`- +#if CYTHON_FAST_THREAD_STATE`
		`- +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject exc_type, PyObject tuple) {`
		`- + Py_ssize_t i, n;`
		`- + n = PyTuple_GET_SIZE(tuple);`
		`- +#if PY_MAJOR_VERSION >= 3`
		`- + for (i=0; i<n; i++) {`
		`- + if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;`
		`- + }`
		`- +#endif`
		`- + for (i=0; i<n; i++) {`
		`- + if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;`
		`- + }`
		`- + return 0;`
		`- +}`
		`- +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {`
		`- + PyObject *exc_type = tstate->curexc_type;`
		`- + if (exc_type == err) return 1;`
		`- + if (unlikely(!exc_type)) return 0;`
		`- + if (unlikely(PyTuple_Check(err)))`
		`- + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);`
		`- + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);`
		`- +}`
		`- +#endif`
		`- +`
		`- +/* PyErrFetchRestore */`
		`- +#if CYTHON_FAST_THREAD_STATE`
		`- +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState tstate, PyObject type, PyObject value, PyObject tb) {`
		`- + PyObject tmp_type, tmp_value, *tmp_tb;`
		`- + tmp_type = tstate->curexc_type;`
		`- + tmp_value = tstate->curexc_value;`
		`- + tmp_tb = tstate->curexc_traceback;`
		`- + tstate->curexc_type = type;`
		`- + tstate->curexc_value = value;`
		`- + tstate->curexc_traceback = tb;`
		`- + Py_XDECREF(tmp_type);`
		`- + Py_XDECREF(tmp_value);`
		`- + Py_XDECREF(tmp_tb);`
		`- +}`
		`- +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState tstate, PyObject type, PyObject value, PyObject *tb) {`
		`- + *type = tstate->curexc_type;`
		`- + *value = tstate->curexc_value;`
		`- + *tb = tstate->curexc_traceback;`
		`- + tstate->curexc_type = 0;`
		`- + tstate->curexc_value = 0;`
		`- + tstate->curexc_traceback = 0;`
		`- +}`
		`- +#endif`
		`- +`
		`- /* PyObjectGetAttrStr */`
		`- #if CYTHON_USE_TYPE_SLOTS`
		`- static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {`
		`- @@ -1497,10 +1736,32 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject`
		`- }`
		`- #endif`
		`-`
		`- +/* PyObjectGetAttrStrNoError */`
		`- +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {`
		`- + __Pyx_PyThreadState_declare`
		`- + __Pyx_PyThreadState_assign`
		`- + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))`
		`- + __Pyx_PyErr_Clear();`
		`- +}`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {`
		`- + PyObject *result;`
		`- +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1`
		`- + PyTypeObject* tp = Py_TYPE(obj);`
		`- + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {`
		`- + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);`
		`- + }`
		`- +#endif`
		`- + result = __Pyx_PyObject_GetAttrStr(obj, attr_name);`
		`- + if (unlikely(!result)) {`
		`- + __Pyx_PyObject_GetAttrStr_ClearAttributeError();`
		`- + }`
		`- + return result;`
		`- +}`
		`- +`
		`- /* GetBuiltinName */`
		`- static PyObject __Pyx_GetBuiltinName(PyObject name) {`
		`- - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);`
		`- - if (unlikely(!result)) {`
		`- + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);`
		`- + if (unlikely(!result) && !PyErr_Occurred()) {`
		`- PyErr_Format(PyExc_NameError,`
		`- #if PY_MAJOR_VERSION >= 3`
		`- "name '%U' is not defined", name);`
		`- @@ -1511,35 +1772,211 @@ static PyObject __Pyx_GetBuiltinName(PyObject name) {`
		`- return result;`
		`- }`
		`-`
		`- +/* PyDictVersioning */`
		`- +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS`
		`- +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {`
		`- + PyObject *dict = Py_TYPE(obj)->tp_dict;`
		`- + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;`
		`- +}`
		`- +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {`
		`- + PyObject **dictptr = NULL;`
		`- + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;`
		`- + if (offset) {`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- + dictptr = (likely(offset > 0)) ? (PyObject *) ((char )obj + offset) : _PyObject_GetDictPtr(obj);`
		`- +#else`
		`- + dictptr = _PyObject_GetDictPtr(obj);`
		`- +#endif`
		`- + }`
		`- + return (dictptr && dictptr) ? __PYX_GET_DICT_VERSION(dictptr) : 0;`
		`- +}`
		`- +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {`
		`- + PyObject *dict = Py_TYPE(obj)->tp_dict;`
		`- + if (unlikely(!dict) \|\| unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))`
		`- + return 0;`
		`- + return obj_dict_version == __Pyx_get_object_dict_version(obj);`
		`- +}`
		`- +#endif`
		`- +`
		`- /* GetModuleGlobalName */`
		`- -static CYTHON_INLINE PyObject __Pyx_GetModuleGlobalName(PyObject name) {`
		`- +#if CYTHON_USE_DICT_VERSIONS`
		`- +static PyObject __Pyx__GetModuleGlobalName(PyObject name, PY_UINT64_T dict_version, PyObject *dict_cached_value)`
		`- +#else`
		`- +static CYTHON_INLINE PyObject __Pyx__GetModuleGlobalName(PyObject name)`
		`- +#endif`
		`- +{`
		`- PyObject *result;`
		`- #if !CYTHON_AVOID_BORROWED_REFS`
		`- #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1`
		`- result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);`
		`- + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, dict_cached_value, dict_version)`
		`- if (likely(result)) {`
		`- - Py_INCREF(result);`
		`- + return __Pyx_NewRef(result);`
		`- } else if (unlikely(PyErr_Occurred())) {`
		`- - result = NULL;`
		`- - } else {`
		`- + return NULL;`
		`- + }`
		`- #else`
		`- result = PyDict_GetItem(__pyx_d, name);`
		`- + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, dict_cached_value, dict_version)`
		`- if (likely(result)) {`
		`- - Py_INCREF(result);`
		`- - } else {`
		`- + return __Pyx_NewRef(result);`
		`- + }`
		`- #endif`
		`- #else`
		`- result = PyObject_GetItem(__pyx_d, name);`
		`- - if (!result) {`
		`- - PyErr_Clear();`
		`- + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, dict_cached_value, dict_version)`
		`- + if (likely(result)) {`
		`- + return __Pyx_NewRef(result);`
		`- + }`
		`- + PyErr_Clear();`
		`- +#endif`
		`- + return __Pyx_GetBuiltinName(name);`
		`- +}`
		`- +`
		`- +/* PyCFunctionFastCall */`
		`- +#if CYTHON_FAST_PYCCALL`
		`- +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject func_obj, PyObject *args, Py_ssize_t nargs) {`
		`- + PyCFunctionObject func = (PyCFunctionObject)func_obj;`
		`- + PyCFunction meth = PyCFunction_GET_FUNCTION(func);`
		`- + PyObject *self = PyCFunction_GET_SELF(func);`
		`- + int flags = PyCFunction_GET_FLAGS(func);`
		`- + assert(PyCFunction_Check(func));`
		`- + assert(METH_FASTCALL == (flags & ~(METH_CLASS \| METH_STATIC \| METH_COEXIST \| METH_KEYWORDS \| METH_STACKLESS)));`
		`- + assert(nargs >= 0);`
		`- + assert(nargs == 0 \|\| args != NULL);`
		`- + /* _PyCFunction_FastCallDict() must not be called with an exception set,`
		`- + because it may clear it (directly or indirectly) and so the`
		`- + caller loses its exception */`
		`- + assert(!PyErr_Occurred());`
		`- + if ((PY_VERSION_HEX < 0x030700A0) \|\| unlikely(flags & METH_KEYWORDS)) {`
		`- + return (((__Pyx_PyCFunctionFastWithKeywords)(void)meth)) (self, args, nargs, NULL);`
		`- + } else {`
		`- + return (((__Pyx_PyCFunctionFast)(void)meth)) (self, args, nargs);`
		`- + }`
		`- +}`
		`- +#endif`
		`- +`
		`- +/* PyFunctionFastCall */`
		`- +#if CYTHON_FAST_PYCALL`
		`- +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject co, PyObject *args, Py_ssize_t na,`
		`- + PyObject *globals) {`
		`- + PyFrameObject *f;`
		`- + PyThreadState *tstate = __Pyx_PyThreadState_Current;`
		`- + PyObject **fastlocals;`
		`- + Py_ssize_t i;`
		`- + PyObject *result;`
		`- + assert(globals != NULL);`
		`- + /* XXX Perhaps we should create a specialized`
		`- + PyFrame_New() that doesn't take locals, but does`
		`- + take builtins without sanity checking them.`
		`- + */`
		`- + assert(tstate != NULL);`
		`- + f = PyFrame_New(tstate, co, globals, NULL);`
		`- + if (f == NULL) {`
		`- + return NULL;`
		`- + }`
		`- + fastlocals = __Pyx_PyFrame_GetLocalsplus(f);`
		`- + for (i = 0; i < na; i++) {`
		`- + Py_INCREF(*args);`
		`- + fastlocals[i] = *args++;`
		`- + }`
		`- + result = PyEval_EvalFrameEx(f,0);`
		`- + ++tstate->recursion_depth;`
		`- + Py_DECREF(f);`
		`- + --tstate->recursion_depth;`
		`- + return result;`
		`- +}`
		`- +#if 1 \|\| PY_VERSION_HEX < 0x030600B1`
		`- +static PyObject __Pyx_PyFunction_FastCallDict(PyObject func, PyObject *args, int nargs, PyObject kwargs) {`
		`- + PyCodeObject co = (PyCodeObject )PyFunction_GET_CODE(func);`
		`- + PyObject *globals = PyFunction_GET_GLOBALS(func);`
		`- + PyObject *argdefs = PyFunction_GET_DEFAULTS(func);`
		`- + PyObject *closure;`
		`- +#if PY_MAJOR_VERSION >= 3`
		`- + PyObject *kwdefs;`
		`- +#endif`
		`- + PyObject kwtuple, *k;`
		`- + PyObject **d;`
		`- + Py_ssize_t nd;`
		`- + Py_ssize_t nk;`
		`- + PyObject *result;`
		`- + assert(kwargs == NULL \|\| PyDict_Check(kwargs));`
		`- + nk = kwargs ? PyDict_Size(kwargs) : 0;`
		`- + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {`
		`- + return NULL;`
		`- + }`
		`- + if (`
		`- +#if PY_MAJOR_VERSION >= 3`
		`- + co->co_kwonlyargcount == 0 &&`
		`- +#endif`
		`- + likely(kwargs == NULL \|\| nk == 0) &&`
		`- + co->co_flags == (CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE)) {`
		`- + if (argdefs == NULL && co->co_argcount == nargs) {`
		`- + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);`
		`- + goto done;`
		`- + }`
		`- + else if (nargs == 0 && argdefs != NULL`
		`- + && co->co_argcount == Py_SIZE(argdefs)) {`
		`- + /* function called with no arguments, but all parameters have`
		`- + a default value: use default values as arguments .*/`
		`- + args = &PyTuple_GET_ITEM(argdefs, 0);`
		`- + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);`
		`- + goto done;`
		`- + }`
		`- + }`
		`- + if (kwargs != NULL) {`
		`- + Py_ssize_t pos, i;`
		`- + kwtuple = PyTuple_New(2 * nk);`
		`- + if (kwtuple == NULL) {`
		`- + result = NULL;`
		`- + goto done;`
		`- + }`
		`- + k = &PyTuple_GET_ITEM(kwtuple, 0);`
		`- + pos = i = 0;`
		`- + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {`
		`- + Py_INCREF(k[i]);`
		`- + Py_INCREF(k[i+1]);`
		`- + i += 2;`
		`- + }`
		`- + nk = i / 2;`
		`- + }`
		`- + else {`
		`- + kwtuple = NULL;`
		`- + k = NULL;`
		`- + }`
		`- + closure = PyFunction_GET_CLOSURE(func);`
		`- +#if PY_MAJOR_VERSION >= 3`
		`- + kwdefs = PyFunction_GET_KW_DEFAULTS(func);`
		`- #endif`
		`- - result = __Pyx_GetBuiltinName(name);`
		`- + if (argdefs != NULL) {`
		`- + d = &PyTuple_GET_ITEM(argdefs, 0);`
		`- + nd = Py_SIZE(argdefs);`
		`- + }`
		`- + else {`
		`- + d = NULL;`
		`- + nd = 0;`
		`- }`
		`- +#if PY_MAJOR_VERSION >= 3`
		`- + result = PyEval_EvalCodeEx((PyObject)co, globals, (PyObject )NULL,`
		`- + args, nargs,`
		`- + k, (int)nk,`
		`- + d, (int)nd, kwdefs, closure);`
		`- +#else`
		`- + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,`
		`- + args, nargs,`
		`- + k, (int)nk,`
		`- + d, (int)nd, closure);`
		`- +#endif`
		`- + Py_XDECREF(kwtuple);`
		`- +done:`
		`- + Py_LeaveRecursiveCall();`
		`- return result;`
		`- }`
		`- +#endif`
		`- +#endif`
		`-`
		`- /* PyObjectCall */`
		`- - #if CYTHON_COMPILING_IN_CPYTHON`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject func, PyObject arg, PyObject *kw) {`
		`- PyObject *result;`
		`- ternaryfunc call = func->ob_type->tp_call;`
		`- @@ -1558,32 +1995,97 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject func, PyObject arg`
		`- }`
		`- #endif`
		`-`
		`- -/* PyErrFetchRestore */`
		`- - #if CYTHON_FAST_THREAD_STATE`
		`- -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState tstate, PyObject type, PyObject value, PyObject tb) {`
		`- - PyObject tmp_type, tmp_value, *tmp_tb;`
		`- - tmp_type = tstate->curexc_type;`
		`- - tmp_value = tstate->curexc_value;`
		`- - tmp_tb = tstate->curexc_traceback;`
		`- - tstate->curexc_type = type;`
		`- - tstate->curexc_value = value;`
		`- - tstate->curexc_traceback = tb;`
		`- - Py_XDECREF(tmp_type);`
		`- - Py_XDECREF(tmp_value);`
		`- - Py_XDECREF(tmp_tb);`
		`- +/* PyObjectCall2Args */`
		`- +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {`
		`- + PyObject args, result = NULL;`
		`- + #if CYTHON_FAST_PYCALL`
		`- + if (PyFunction_Check(function)) {`
		`- + PyObject *args[2] = {arg1, arg2};`
		`- + return __Pyx_PyFunction_FastCall(function, args, 2);`
		`- + }`
		`- + #endif`
		`- + #if CYTHON_FAST_PYCCALL`
		`- + if (__Pyx_PyFastCFunction_Check(function)) {`
		`- + PyObject *args[2] = {arg1, arg2};`
		`- + return __Pyx_PyCFunction_FastCall(function, args, 2);`
		`- + }`
		`- + #endif`
		`- + args = PyTuple_New(2);`
		`- + if (unlikely(!args)) goto done;`
		`- + Py_INCREF(arg1);`
		`- + PyTuple_SET_ITEM(args, 0, arg1);`
		`- + Py_INCREF(arg2);`
		`- + PyTuple_SET_ITEM(args, 1, arg2);`
		`- + Py_INCREF(function);`
		`- + result = __Pyx_PyObject_Call(function, args, NULL);`
		`- + Py_DECREF(args);`
		`- + Py_DECREF(function);`
		`- +done:`
		`- + return result;`
		`- }`
		`- -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState tstate, PyObject type, PyObject value, PyObject *tb) {`
		`- - *type = tstate->curexc_type;`
		`- - *value = tstate->curexc_value;`
		`- - *tb = tstate->curexc_traceback;`
		`- - tstate->curexc_type = 0;`
		`- - tstate->curexc_value = 0;`
		`- - tstate->curexc_traceback = 0;`
		`- +`
		`- +/* PyObjectCallMethO */`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject func, PyObject arg) {`
		`- + PyObject self, result;`
		`- + PyCFunction cfunc;`
		`- + cfunc = PyCFunction_GET_FUNCTION(func);`
		`- + self = PyCFunction_GET_SELF(func);`
		`- + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))`
		`- + return NULL;`
		`- + result = cfunc(self, arg);`
		`- + Py_LeaveRecursiveCall();`
		`- + if (unlikely(!result) && unlikely(!PyErr_Occurred())) {`
		`- + PyErr_SetString(`
		`- + PyExc_SystemError,`
		`- + "NULL result without error in PyObject_Call");`
		`- + }`
		`- + return result;`
		`- +}`
		`- +#endif`
		`- +`
		`- +/* PyObjectCallOneArg */`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- +static PyObject* __Pyx__PyObject_CallOneArg(PyObject func, PyObject arg) {`
		`- + PyObject *result;`
		`- + PyObject *args = PyTuple_New(1);`
		`- + if (unlikely(!args)) return NULL;`
		`- + Py_INCREF(arg);`
		`- + PyTuple_SET_ITEM(args, 0, arg);`
		`- + result = __Pyx_PyObject_Call(func, args, NULL);`
		`- + Py_DECREF(args);`
		`- + return result;`
		`- +}`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject func, PyObject arg) {`
		`- +#if CYTHON_FAST_PYCALL`
		`- + if (PyFunction_Check(func)) {`
		`- + return __Pyx_PyFunction_FastCall(func, &arg, 1);`
		`- + }`
		`- +#endif`
		`- + if (likely(PyCFunction_Check(func))) {`
		`- + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {`
		`- + return __Pyx_PyObject_CallMethO(func, arg);`
		`- +#if CYTHON_FAST_PYCCALL`
		`- + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {`
		`- + return __Pyx_PyCFunction_FastCall(func, &arg, 1);`
		`- +#endif`
		`- + }`
		`- + }`
		`- + return __Pyx__PyObject_CallOneArg(func, arg);`
		`- +}`
		`- +#else`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject func, PyObject arg) {`
		`- + PyObject *result;`
		`- + PyObject *args = PyTuple_Pack(1, arg);`
		`- + if (unlikely(!args)) return NULL;`
		`- + result = __Pyx_PyObject_Call(func, args, NULL);`
		`- + Py_DECREF(args);`
		`- + return result;`
		`- }`
		`- #endif`
		`-`
		`- /* RaiseException */`
		`- - #if PY_MAJOR_VERSION < 3`
		`- +#if PY_MAJOR_VERSION < 3`
		`- static void __Pyx_Raise(PyObject type, PyObject value, PyObject *tb,`
		`- CYTHON_UNUSED PyObject *cause) {`
		`- __Pyx_PyThreadState_declare`
		`- @@ -1742,7 +2244,7 @@ bad:`
		`- #endif`
		`-`
		`- /* CalculateMetaclass */`
		`- - static PyObject __Pyx_CalculateMetaclass(PyTypeObject metaclass, PyObject *bases) {`
		`- +static PyObject __Pyx_CalculateMetaclass(PyTypeObject metaclass, PyObject *bases) {`
		`- Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);`
		`- for (i=0; i < nbases; i++) {`
		`- PyTypeObject *tmptype;`
		`- @@ -1781,11 +2283,11 @@ bad:`
		`- }`
		`-`
		`- /* Py3ClassCreate */`
		`- - static PyObject __Pyx_Py3MetaclassPrepare(PyObject metaclass, PyObject bases, PyObject name,`
		`- +static PyObject __Pyx_Py3MetaclassPrepare(PyObject metaclass, PyObject bases, PyObject name,`
		`- PyObject qualname, PyObject mkw, PyObject modname, PyObject doc) {`
		`- PyObject *ns;`
		`- if (metaclass) {`
		`- - PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);`
		`- + PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare);`
		`- if (prep) {`
		`- PyObject *pargs = PyTuple_Pack(2, name, bases);`
		`- if (unlikely(!pargs)) {`
		`- @@ -1796,9 +2298,8 @@ bad:`
		`- Py_DECREF(prep);`
		`- Py_DECREF(pargs);`
		`- } else {`
		`- - if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))`
		`- + if (unlikely(PyErr_Occurred()))`
		`- return NULL;`
		`- - PyErr_Clear();`
		`- ns = PyDict_New();`
		`- }`
		`- } else {`
		`- @@ -1807,7 +2308,11 @@ bad:`
		`- if (unlikely(!ns))`
		`- return NULL;`
		`- if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;`
		`- +#if PY_VERSION_HEX >= 0x03030000`
		`- if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;`
		`- +#else`
		`- + CYTHON_MAYBE_UNUSED_VAR(qualname);`
		`- +#endif`
		`- if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;`
		`- return ns;`
		`- bad:`
		`- @@ -1848,8 +2353,8 @@ static PyObject __Pyx_Py3ClassCreate(PyObject metaclass, PyObject *name, PyObj`
		`- }`
		`-`
		`- /* CLineInTraceback */`
		`- - #ifndef CYTHON_CLINE_IN_TRACEBACK`
		`- -static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) {`
		`- +#ifndef CYTHON_CLINE_IN_TRACEBACK`
		`- +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {`
		`- PyObject *use_cline;`
		`- PyObject ptype, pvalue, *ptraceback;`
		`- #if CYTHON_COMPILING_IN_CPYTHON`
		`- @@ -1862,11 +2367,13 @@ static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_li`
		`- #if CYTHON_COMPILING_IN_CPYTHON`
		`- cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);`
		`- if (likely(cython_runtime_dict)) {`
		`- - use_cline = __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback);`
		`- + __PYX_PY_DICT_LOOKUP_IF_MODIFIED(`
		`- + use_cline, *cython_runtime_dict,`
		`- + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))`
		`- } else`
		`- #endif`
		`- {`
		`- - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);`
		`- + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);`
		`- if (use_cline_obj) {`
		`- use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;`
		`- Py_DECREF(use_cline_obj);`
		`- @@ -1879,7 +2386,7 @@ static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_li`
		`- c_line = 0;`
		`- PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);`
		`- }`
		`- - else if (PyObject_Not(use_cline) != 0) {`
		`- + else if (use_cline == Py_False \|\| (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {`
		`- c_line = 0;`
		`- }`
		`- __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);`
		`- @@ -1888,7 +2395,7 @@ static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_li`
		`- #endif`
		`-`
		`- /* CodeObjectCache */`
		`- - static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {`
		`- +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {`
		`- int start = 0, mid = 0, end = count - 1;`
		`- if (end >= 0 && code_line > entries[end].code_line) {`
		`- return count;`
		`- @@ -1951,7 +2458,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {`
		`- if (__pyx_code_cache.count == __pyx_code_cache.max_count) {`
		`- int new_max = __pyx_code_cache.max_count + 64;`
		`- entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(`
		`- - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));`
		`- + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));`
		`- if (unlikely(!entries)) {`
		`- return;`
		`- }`
		`- @@ -1968,7 +2475,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {`
		`- }`
		`-`
		`- /* AddTraceback */`
		`- - #include "compile.h"`
		`- +#include "compile.h"`
		`- #include "frameobject.h"`
		`- #include "traceback.h"`
		`- static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(`
		`- @@ -2004,6 +2511,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(`
		`- 0,`
		`- 0,`
		`- 0,`
		`- + 0,`
		`- __pyx_empty_bytes, /PyObject code,*/`
		`- __pyx_empty_tuple, /PyObject consts,*/`
		`- __pyx_empty_tuple, /PyObject names,*/`
		`- @@ -2053,8 +2561,8 @@ bad:`
		`- }`
		`-`
		`- /* CIntToPy */`
		`- - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {`
		`- - const long neg_one = (long) -1, const_zero = (long) 0;`
		`- +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {`
		`- + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;`
		`- const int is_unsigned = neg_one > const_zero;`
		`- if (is_unsigned) {`
		`- if (sizeof(long) < sizeof(long)) {`
		`- @@ -2084,7 +2592,7 @@ bad:`
		`- }`
		`-`
		`- /* CIntFromPyVerify */`
		`- - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\`
		`- +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\`
		`- __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)`
		`- #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\`
		`- __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)`
		`- @@ -2106,8 +2614,8 @@ bad:`
		`- }`
		`-`
		`- /* CIntFromPy */`
		`- - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {`
		`- - const long neg_one = (long) -1, const_zero = (long) 0;`
		`- +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {`
		`- + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;`
		`- const int is_unsigned = neg_one > const_zero;`
		`- #if PY_MAJOR_VERSION < 3`
		`- if (likely(PyInt_Check(x))) {`
		`- @@ -2295,8 +2803,8 @@ raise_neg_overflow:`
		`- }`
		`-`
		`- /* CIntFromPy */`
		`- - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {`
		`- - const int neg_one = (int) -1, const_zero = (int) 0;`
		`- +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {`
		`- + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;`
		`- const int is_unsigned = neg_one > const_zero;`
		`- #if PY_MAJOR_VERSION < 3`
		`- if (likely(PyInt_Check(x))) {`
		`- @@ -2484,7 +2992,7 @@ raise_neg_overflow:`
		`- }`
		`-`
		`- /* FastTypeChecks */`
		`- - #if CYTHON_COMPILING_IN_CPYTHON`
		`- +#if CYTHON_COMPILING_IN_CPYTHON`
		`- static int __Pyx_InBases(PyTypeObject a, PyTypeObject b) {`
		`- while (a) {`
		`- a = a->tp_base;`
		`- @@ -2584,7 +3092,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj`
		`- #endif`
		`-`
		`- /* CheckBinaryVersion */`
		`- - static int __Pyx_check_binary_version(void) {`
		`- +static int __Pyx_check_binary_version(void) {`
		`- char ctversion[4], rtversion[4];`
		`- PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);`
		`- PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());`
		`- @@ -2600,7 +3108,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj`
		`- }`
		`-`
		`- /* InitStrings */`
		`- - static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {`
		`- +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {`
		`- while (t->p) {`
		`- #if PY_MAJOR_VERSION < 3`
		`- if (t->is_unicode) {`
		`- @@ -2709,6 +3217,13 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {`
		`- if (is_true \| (x == Py_False) \| (x == Py_None)) return is_true;`
		`- else return PyObject_IsTrue(x);`
		`- }`
		`- +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {`
		`- + int retval;`
		`- + if (unlikely(!x)) return -1;`
		`- + retval = __Pyx_PyObject_IsTrue(x);`
		`- + Py_DECREF(x);`
		`- + return retval;`
		`- +}`
		`- static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {`
		`- #if PY_MAJOR_VERSION >= 3`
		`- if (PyLong_Check(result)) {`
		`- @@ -2786,7 +3301,7 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {`
		`- if (sizeof(Py_ssize_t) >= sizeof(long))`
		`- return PyInt_AS_LONG(b);`
		`- else`
		`- - return PyInt_AsSsize_t(x);`
		`- + return PyInt_AsSsize_t(b);`
		`- }`
		`- #endif`
		`- if (likely(PyLong_CheckExact(b))) {`
		`- @@ -2840,6 +3355,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {`
		`- Py_DECREF(x);`
		`- return ival;`
		`- }`
		`- +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {`
		`- + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {`
		`- + return __Pyx_PyIndex_AsSsize_t(o);`
		`- +#if PY_MAJOR_VERSION < 3`
		`- + } else if (likely(PyInt_CheckExact(o))) {`
		`- + return PyInt_AS_LONG(o);`
		`- +#endif`
		`- + } else {`
		`- + Py_ssize_t ival;`
		`- + PyObject *x;`
		`- + x = PyNumber_Index(o);`
		`- + if (!x) return -1;`
		`- + ival = PyInt_AsLong(x);`
		`- + Py_DECREF(x);`
		`- + return ival;`
		`- + }`
		`- +}`
		`- static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {`
		`- return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);`
		`- }`
		`- --`
		`- 2.21.0`
		`-`

1147.patch

file added

+1307

The added file is too large to be shown here, see it at: 1147.patch

python-twisted.spec

file modified

+33 -24

		`@@ -7,19 +7,19 @@`

		`Name: python-%{pypi_name}`
		`Version: 19.2.1`
		`- Release: 1%{?dist}`
		`+ Release: 3%{?dist}`
		`Summary: Twisted is a networking engine written in Python`

		`License: MIT`
		`URL: http://twistedmatrix.com/`
		`Source0: https://files.pythonhosted.org/packages/source/T/Twisted/Twisted-%{version}.tar.bz2`
		`- # Regenerate raiser.c with Cython 3.0a0 for Python >= 3.8a4`
		`- # https://twistedmatrix.com/trac/ticket/9640`
		`- Patch0: 0001-Regenerate-raiser.c-with-Cython-3.0a0.patch`
		`# Import gobject from gi.repository for Python 3`
		`# https://twistedmatrix.com/trac/ticket/9642`
		`Patch1: 0001-Import-gobject-from-gi.repository-in-Python-3.patch`

		`+ # CVE-2019-12855: Check remote certificates for XMPP TLS`
		`+ Patch2: https://github.com/twisted/twisted/pull/1147.patch`
		`+`
		`%{?python_enable_dependency_generator}`

		`%description`
		`@@ -32,25 +32,25 @@`

		`BuildRequires: gcc`
		`BuildRequires: python2-devel >= 2.6`
		`- BuildRequires: python2dist(appdirs) >= 1.4.0`
		`- BuildRequires: python2dist(automat) >= 0.3.0`
		`- BuildRequires: python2dist(attrs) >= 17.4.0`
		`+ BuildRequires: python2dist(appdirs) >= 1.4`
		`+ BuildRequires: python2dist(automat) >= 0.3`
		`+ BuildRequires: python2dist(attrs) >= 17.4`
		`BuildRequires: python2dist(constantly) >= 15.1`
		`BuildRequires: python2dist(cryptography) >= 2.5`
		`- BuildRequires: (python2dist(h2) >= 3.0 with python2dist(h2) < 4.0)`
		`+ BuildRequires: (python2dist(h2) >= 3 with python2dist(h2) < 4)`
		`BuildRequires: python2dist(hyperlink) >= 17.1.1`
		`BuildRequires: python2dist(idna) >= 2.5`
		`BuildRequires: python2dist(incremental) >= 16.10.1`
		`- BuildRequires: (python2dist(priority) >= 1.1.0 with python2dist(priority) < 2.0)`
		`+ BuildRequires: (python2dist(priority) >= 1.1 with python2dist(priority) < 2)`
		`BuildRequires: python2dist(pyasn1)`
		`- BuildRequires: python2dist(pyopenssl) >= 16.0.0`
		`- BuildRequires: python2dist(pyserial) >= 3.0`
		`- BuildRequires: python2dist(service-identity) >= 18.1.0`
		`+ BuildRequires: python2dist(pyopenssl) >= 16`
		`+ BuildRequires: python2dist(pyserial) >= 3`
		`+ BuildRequires: python2dist(service-identity) >= 18.1`
		`BuildRequires: python2dist(setuptools)`
		`BuildRequires: python2dist(zope.interface) >= 4.4.2`
		`- BuildRequires: python2dist(pyhamcrest) >= 1.9.0`
		`+ BuildRequires: python2dist(pyhamcrest) >= 1.9`

		`- Recommends: python2dist(service-identity) >= 18.1.0`
		`+ Recommends: python2dist(service-identity) >= 18.1`

		`%description -n python2-%{pypi_name}`
		`%{common_description}`
		`@@ -62,26 +62,27 @@`

		`BuildRequires: gcc`
		`BuildRequires: python3-devel >= 3.3`
		`- BuildRequires: python3dist(appdirs) >= 1.4.0`
		`- BuildRequires: python3dist(automat) >= 0.3.0`
		`- BuildRequires: python3dist(attrs) >= 17.4.0`
		`+ BuildRequires: python3-Cython`
		`+ BuildRequires: python3dist(appdirs) >= 1.4`
		`+ BuildRequires: python3dist(automat) >= 0.3`
		`+ BuildRequires: python3dist(attrs) >= 17.4`
		`BuildRequires: python3dist(constantly) >= 15.1`
		`BuildRequires: python3dist(cryptography) >= 2.5`
		`- BuildRequires: (python3dist(h2) >= 3.0 with python3dist(h2) < 4.0)`
		`+ BuildRequires: (python3dist(h2) >= 3 with python3dist(h2) < 4)`
		`BuildRequires: python3dist(hyperlink) >= 17.1.1`
		`BuildRequires: python3dist(idna) >= 2.5`
		`BuildRequires: python3dist(incremental) >= 16.10.1`
		`- BuildRequires: (python3dist(priority) >= 1.1.0 with python3dist(priority) < 2.0)`
		`+ BuildRequires: (python3dist(priority) >= 1.1 with python3dist(priority) < 2)`
		`BuildRequires: python3dist(pyasn1)`
		`- BuildRequires: python3dist(pyopenssl) >= 16.0.0`
		`- BuildRequires: python3dist(pyserial) >= 3.0`
		`- BuildRequires: python3dist(service-identity) >= 18.1.0`
		`+ BuildRequires: python3dist(pyopenssl) >= 16`
		`+ BuildRequires: python3dist(pyserial) >= 3`
		`+ BuildRequires: python3dist(service-identity) >= 18.1`
		`BuildRequires: python3dist(setuptools)`
		`BuildRequires: python3dist(sphinx) >= 1.3.1`
		`BuildRequires: python3dist(zope.interface) >= 4.4.2`
		`- BuildRequires: python3dist(pyhamcrest) >= 1.9.0`
		`+ BuildRequires: python3dist(pyhamcrest) >= 1.9`

		`- Recommends: python3dist(service-identity) >= 18.1.0`
		`+ Recommends: python3dist(service-identity) >= 18.1`

		`%description -n python3-%{pypi_name}`
		`%{common_description}`
		`@@ -89,9 +90,11 @@`

		`%prep`
		`%autosetup -p1 -n Twisted-%{version}`
		`+ rm -v $(grep -lr "Generated by Cython")`


		`%build`
		`+ find -name '*.pyx' -exec cython {} \;`
		`%py2_build`
		`%py3_build`

		`@@ -202,6 +205,12 @@`


		`%changelog`
		`+ * Tue Jul 09 2019 Miro Hrončok <mhroncok@redhat.com> - 19.2.1-3`
		`+ - Security fix for CVE-2019-12855 (Check certificates for XMPP TLS) (#1728206) (#1728207)`
		`+`
		`+ * Wed Jul 03 2019 Miro Hrončok <mhroncok@redhat.com> - 19.2.1-2`
		`+ - Rebuilt to update automatic Python dependencies`
		`+`
		`* Sun Jun 09 18:40:31 CEST 2019 Robert-André Mauchin <zebob.m@gmail.com> - 19.2.1-1`
		`- Release 19.2.1`