#define PY_SSIZE_T_CLEAN

#ifndef CYTHON_USE_PYLONG_INTERNALS

#ifdef PYLONG_BITS_IN_DIGIT

#define CYTHON_USE_PYLONG_INTERNALS 0

#include "pyconfig.h"

#ifdef PYLONG_BITS_IN_DIGIT

#define CYTHON_USE_PYLONG_INTERNALS 1

#define CYTHON_USE_PYLONG_INTERNALS 0

#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 < 0x02040000

#error Cython requires Python 2.4+.

#define CYTHON_ABI "0_20_1post0"

#include <stddef.h> /* For offsetof */

#ifndef offsetof

#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )

#if !defined(WIN32) && !defined(MS_WINDOWS)

#ifndef __stdcall

#define __stdcall

#endif

#ifndef __cdecl

#define __cdecl

#endif

#ifndef __fastcall

#define __fastcall

#endif

#ifndef DL_IMPORT

#define DL_IMPORT(t) t

#ifndef DL_EXPORT

#define DL_EXPORT(t) t

#ifndef PY_LONG_LONG

#define PY_LONG_LONG LONG_LONG

#ifndef Py_HUGE_VAL

#define Py_HUGE_VAL HUGE_VAL

#ifdef PYPY_VERSION

#define CYTHON_COMPILING_IN_PYPY 1

#define CYTHON_COMPILING_IN_CPYTHON 0

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_CPYTHON 1

#if CYTHON_COMPILING_IN_PYPY

#define Py_OptimizeFlag 0

#if PY_VERSION_HEX < 0x02050000

typedef int Py_ssize_t;

#define PY_SSIZE_T_MAX INT_MAX

#define PY_SSIZE_T_MIN INT_MIN

#define PY_FORMAT_SIZE_T ""

#define CYTHON_FORMAT_SSIZE_T ""

#define PyInt_FromSsize_t(z) PyInt_FromLong(z)

#define PyInt_AsSsize_t(o) __Pyx_PyInt_As_int(o)

#define PyNumber_Index(o) ((PyNumber_Check(o) && !PyFloat_Check(o)) ? PyNumber_Int(o) : \

(PyErr_Format(PyExc_TypeError, \

"expected index value, got %.200s", Py_TYPE(o)->tp_name), \

(PyObject*)0))

#define __Pyx_PyIndex_Check(o) (PyNumber_Check(o) && !PyFloat_Check(o) && \

!PyComplex_Check(o))

#define PyIndex_Check __Pyx_PyIndex_Check

#define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message)

#define __PYX_BUILD_PY_SSIZE_T "i"

#define __PYX_BUILD_PY_SSIZE_T "n"

#define CYTHON_FORMAT_SSIZE_T "z"

#define __Pyx_PyIndex_Check PyIndex_Check

#if PY_VERSION_HEX < 0x02060000

#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)

#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size)

#define PyVarObject_HEAD_INIT(type, size) \

PyObject_HEAD_INIT(type) size,

#define PyType_Modified(t)

typedef struct {

void *buf;

PyObject *obj;

Py_ssize_t len;

Py_ssize_t itemsize;

int readonly;

int ndim;

char *format;

Py_ssize_t *shape;

Py_ssize_t *strides;

Py_ssize_t *suboffsets;

void *internal;

} Py_buffer;

#define PyBUF_SIMPLE 0

#define PyBUF_WRITABLE 0x0001

#define PyBUF_FORMAT 0x0004

#define PyBUF_ND 0x0008

#define PyBUF_STRIDES (0x0010 | PyBUF_ND)

#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)

#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)

#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)

#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)

#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE)

#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE)

typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);

typedef void (*releasebufferproc)(PyObject *, Py_buffer *);

#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_DefaultClassType PyClass_Type

#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)

#define __Pyx_DefaultClassType PyType_Type

#if PY_VERSION_HEX < 0x02060000

#define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict")

#if PY_MAJOR_VERSION >= 3

#define Py_TPFLAGS_CHECKTYPES 0

#define Py_TPFLAGS_HAVE_INDEX 0

#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)

#define Py_TPFLAGS_HAVE_NEWBUFFER 0

#if PY_VERSION_HEX < 0x02060000

#define Py_TPFLAGS_HAVE_VERSION_TAG 0

#if PY_VERSION_HEX < 0x02060000 && !defined(Py_TPFLAGS_IS_ABSTRACT)

#define Py_TPFLAGS_IS_ABSTRACT 0

#if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE)

#define Py_TPFLAGS_HAVE_FINALIZE 0

#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)

#define CYTHON_PEP393_ENABLED 1

#define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \

0 : _PyUnicode_Ready((PyObject *)(op)))

#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)

#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)

#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)

#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)

#define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)

#define CYTHON_PEP393_ENABLED 0

#define __Pyx_PyUnicode_READY(op) (0)

#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)

#define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))

#define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))

#define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))

#define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))

#if CYTHON_COMPILING_IN_PYPY

#define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)

#define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)

#define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)

#define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \

PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))

#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))

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)

#define __Pyx_PyString_Format(a, b) PyString_Format(a, b)

#if PY_MAJOR_VERSION >= 3

#define PyBaseString_Type PyUnicode_Type

#define PyStringObject PyUnicodeObject

#define PyString_Type PyUnicode_Type

#define PyString_Check PyUnicode_Check

#define PyString_CheckExact PyUnicode_CheckExact

#if PY_VERSION_HEX < 0x02060000

#define PyBytesObject PyStringObject

#define PyBytes_Type PyString_Type

#define PyBytes_Check PyString_Check

#define PyBytes_CheckExact PyString_CheckExact

#define PyBytes_FromString PyString_FromString

#define PyBytes_FromStringAndSize PyString_FromStringAndSize

#define PyBytes_FromFormat PyString_FromFormat

#define PyBytes_DecodeEscape PyString_DecodeEscape

#define PyBytes_AsString PyString_AsString

#define PyBytes_AsStringAndSize PyString_AsStringAndSize

#define PyBytes_Size PyString_Size

#define PyBytes_AS_STRING PyString_AS_STRING

#define PyBytes_GET_SIZE PyString_GET_SIZE

#define PyBytes_Repr PyString_Repr

#define PyBytes_Concat PyString_Concat

#define PyBytes_ConcatAndDel PyString_ConcatAndDel

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)

#define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)

#define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \

PyString_Check(obj) || PyUnicode_Check(obj))

#define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))

#if PY_VERSION_HEX < 0x02060000

#define PySet_Check(obj) PyObject_TypeCheck(obj, &PySet_Type)

#define PyFrozenSet_Check(obj) PyObject_TypeCheck(obj, &PyFrozenSet_Type)

#ifndef PySet_CheckExact

#define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)

#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)

#if PY_MAJOR_VERSION >= 3

#define PyIntObject PyLongObject

#define PyInt_Type PyLong_Type

#define PyInt_Check(op) PyLong_Check(op)

#define PyInt_CheckExact(op) PyLong_CheckExact(op)

#define PyInt_FromString PyLong_FromString

#define PyInt_FromUnicode PyLong_FromUnicode

#define PyInt_FromLong PyLong_FromLong

#define PyInt_FromSize_t PyLong_FromSize_t

#define PyInt_FromSsize_t PyLong_FromSsize_t

#define PyInt_AsLong PyLong_AsLong

#define PyInt_AS_LONG PyLong_AS_LONG

#define PyInt_AsSsize_t PyLong_AsSsize_t

#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask

#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask

#define PyNumber_Int PyNumber_Long

#if PY_MAJOR_VERSION >= 3

#define PyBoolObject PyLongObject

#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_FromHash_t PyInt_FromSsize_t

#define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t

#if (PY_MAJOR_VERSION < 3) || (PY_VERSION_HEX >= 0x03010300)

#define __Pyx_PySequence_GetSlice(obj, a, b) PySequence_GetSlice(obj, a, b)

#define __Pyx_PySequence_SetSlice(obj, a, b, value) PySequence_SetSlice(obj, a, b, value)

#define __Pyx_PySequence_DelSlice(obj, a, b) PySequence_DelSlice(obj, a, b)

#define __Pyx_PySequence_GetSlice(obj, a, b) (unlikely(!(obj)) ? \

(PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), (PyObject*)0) : \

(likely((obj)->ob_type->tp_as_mapping) ? (PySequence_GetSlice(obj, a, b)) : \

(PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", (obj)->ob_type->tp_name), (PyObject*)0)))

#define __Pyx_PySequence_SetSlice(obj, a, b, value) (unlikely(!(obj)) ? \

(PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \

(likely((obj)->ob_type->tp_as_mapping) ? (PySequence_SetSlice(obj, a, b, value)) : \

(PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice assignment", (obj)->ob_type->tp_name), -1)))

#define __Pyx_PySequence_DelSlice(obj, a, b) (unlikely(!(obj)) ? \

(PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \

(likely((obj)->ob_type->tp_as_mapping) ? (PySequence_DelSlice(obj, a, b)) : \

(PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice deletion", (obj)->ob_type->tp_name), -1)))

#if PY_MAJOR_VERSION >= 3

#define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))

#if PY_VERSION_HEX < 0x02050000

#define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),((char *)(n)))

#define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a))

#define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),((char *)(n)))

#define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),(n))

#define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a))

#define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),(n))

#if PY_VERSION_HEX < 0x02050000

#define __Pyx_NAMESTR(n) ((char *)(n))

#define __Pyx_DOCSTR(n) ((char *)(n))

#define __Pyx_NAMESTR(n) (n)

#define __Pyx_DOCSTR(n) (n)

#ifndef CYTHON_INLINE

#if defined(__GNUC__)

#define CYTHON_INLINE __inline__

#elif defined(_MSC_VER)

#define CYTHON_INLINE __inline

#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

#define CYTHON_INLINE inline

#else

#define CYTHON_INLINE

#endif

#ifndef CYTHON_RESTRICT

#if defined(__GNUC__)

#define CYTHON_RESTRICT __restrict__

#elif defined(_MSC_VER) && _MSC_VER >= 1400

#define CYTHON_RESTRICT __restrict

#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

#define CYTHON_RESTRICT restrict

#else

#define CYTHON_RESTRICT

#endif

#ifdef NAN

#define __PYX_NAN() ((float) NAN)

static CYTHON_INLINE float __PYX_NAN() {

/* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and

float value;

memset(&value, 0xFF, sizeof(value));

return value;

}

#ifdef __cplusplus

template<typename T>

void __Pyx_call_destructor(T* x) {

x->~T();

}

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)

#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)

#define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)

#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)

#ifndef __PYX_EXTERN_C

#ifdef __cplusplus

#define __PYX_EXTERN_C extern "C"

#else

#define __PYX_EXTERN_C extern

#endif

#if defined(WIN32) || defined(MS_WINDOWS)

#define _USE_MATH_DEFINES

#include <math.h>

#define __PYX_HAVE__netfilterqueue

#define __PYX_HAVE_API__netfilterqueue

#include "sys/types.h"

#include "netinet/ip.h"

#include "sys/time.h"

#include "netinet/in.h"

#include "libnfnetlink/linux_nfnetlink.h"

#include "libnetfilter_queue/linux_nfnetlink_queue.h"

#include "libnetfilter_queue/libnetfilter_queue.h"

#include "sys/socket.h"

#ifdef _OPENMP

#include <omp.h>

#endif /* _OPENMP */

#ifdef PYREX_WITHOUT_ASSERTIONS

#define CYTHON_WITHOUT_ASSERTIONS

#ifndef CYTHON_UNUSED

# if defined(__GNUC__)

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

# define CYTHON_UNUSED __attribute__ ((__unused__))

# define CYTHON_UNUSED

# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))

# define CYTHON_UNUSED __attribute__ ((__unused__))

# define CYTHON_UNUSED

typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding;

const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0

#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0

#define __PYX_DEFAULT_STRING_ENCODING ""

#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString

#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize

#define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \

(sizeof(type) < sizeof(Py_ssize_t)) || \

(sizeof(type) > sizeof(Py_ssize_t) && \

likely(v < (type)PY_SSIZE_T_MAX || \

v == (type)PY_SSIZE_T_MAX) && \

(!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \

v == (type)PY_SSIZE_T_MIN))) || \

(sizeof(type) == sizeof(Py_ssize_t) && \

(is_signed || likely(v < (type)PY_SSIZE_T_MAX || \

v == (type)PY_SSIZE_T_MAX))) )

static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);

static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);

#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))

#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)

#define __Pyx_PyBytes_FromString PyBytes_FromString

#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);

#if PY_MAJOR_VERSION < 3

#define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString

#define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize

#define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString

#define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize

#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s)

#define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s)

#define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s)

#define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s)

#define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s)

#if PY_MAJOR_VERSION < 3

static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)

{

const Py_UNICODE *u_end = u;

while (*u_end++) ;

return u_end - u - 1;

}

#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen

#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))

#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode

#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode

#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None)

#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False))

static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);

static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);

static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);

static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);

#if CYTHON_COMPILING_IN_CPYTHON

#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))

#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)

#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))

#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII

static int __Pyx_sys_getdefaultencoding_not_ascii;

static int __Pyx_init_sys_getdefaultencoding_params(void) {

PyObject* sys = NULL;

PyObject* default_encoding = NULL;

PyObject* ascii_chars_u = NULL;

PyObject* ascii_chars_b = NULL;

sys = PyImport_ImportModule("sys");

if (sys == NULL) goto bad;

default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);

if (default_encoding == NULL) goto bad;

if (strcmp(PyBytes_AsString(default_encoding), "ascii") == 0) {

__Pyx_sys_getdefaultencoding_not_ascii = 0;

} else {

const char* default_encoding_c = PyBytes_AS_STRING(default_encoding);

char ascii_chars[128];

int c;

for (c = 0; c < 128; c++) {

ascii_chars[c] = c;

}

__Pyx_sys_getdefaultencoding_not_ascii = 1;

ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);

if (ascii_chars_u == NULL) goto bad;

ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);

if (ascii_chars_b == NULL || strncmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {

PyErr_Format(

PyExc_ValueError,

"This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",

default_encoding_c);

goto bad;

}

}

Py_XDECREF(sys);

Py_XDECREF(default_encoding);

Py_XDECREF(ascii_chars_u);

Py_XDECREF(ascii_chars_b);

return 0;

bad:

Py_XDECREF(sys);

Py_XDECREF(default_encoding);

Py_XDECREF(ascii_chars_u);

Py_XDECREF(ascii_chars_b);

return -1;

}

#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3

#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)

#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)

#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT

static char* __PYX_DEFAULT_STRING_ENCODING;

static int __Pyx_init_sys_getdefaultencoding_params(void) {

PyObject* sys = NULL;

PyObject* default_encoding = NULL;

char* default_encoding_c;

sys = PyImport_ImportModule("sys");

if (sys == NULL) goto bad;

default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);

if (default_encoding == NULL) goto bad;

default_encoding_c = PyBytes_AS_STRING(default_encoding);

__PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));

strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);

Py_DECREF(sys);

Py_DECREF(default_encoding);

return 0;

bad:

Py_XDECREF(sys);

Py_XDECREF(default_encoding);

return -1;

}

#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))

#define likely(x) __builtin_expect(!!(x), 1)

#define unlikely(x) __builtin_expect(!!(x), 0)

#else /* !__GNUC__ or GCC < 2.95 */

#define likely(x) (x)

#define unlikely(x) (x)

#endif /* __GNUC__ */

static PyObject *__pyx_m;

static PyObject *__pyx_d;

static PyObject *__pyx_b;

static PyObject *__pyx_empty_tuple;

static PyObject *__pyx_empty_bytes;

static int __pyx_lineno;

static int __pyx_clineno = 0;

static const char * __pyx_cfilenm= __FILE__;

static const char *__pyx_filename;

static const char *__pyx_f[] = {

"netfilterqueue.pyx",

"netfilterqueue.pxd",

};

struct __pyx_obj_14netfilterqueue_Packet;

struct __pyx_obj_14netfilterqueue_NetfilterQueue;

enum {

__pyx_e_14netfilterqueue_IPPROTO_IP = 0,

__pyx_e_14netfilterqueue_IPPROTO_HOPOPTS = 0,

__pyx_e_14netfilterqueue_IPPROTO_ICMP = 1,

__pyx_e_14netfilterqueue_IPPROTO_IGMP = 2,

__pyx_e_14netfilterqueue_IPPROTO_IPIP = 4,

__pyx_e_14netfilterqueue_IPPROTO_TCP = 6,

__pyx_e_14netfilterqueue_IPPROTO_EGP = 8,

__pyx_e_14netfilterqueue_IPPROTO_PUP = 12,

__pyx_e_14netfilterqueue_IPPROTO_UDP = 17,

__pyx_e_14netfilterqueue_IPPROTO_IDP = 22,

__pyx_e_14netfilterqueue_IPPROTO_TP = 29,

__pyx_e_14netfilterqueue_IPPROTO_IPV6 = 41,

__pyx_e_14netfilterqueue_IPPROTO_ROUTING = 43,

__pyx_e_14netfilterqueue_IPPROTO_FRAGMENT = 44,

__pyx_e_14netfilterqueue_IPPROTO_RSVP = 46,

__pyx_e_14netfilterqueue_IPPROTO_GRE = 47,

__pyx_e_14netfilterqueue_IPPROTO_ESP = 50,

__pyx_e_14netfilterqueue_IPPROTO_AH = 51,

__pyx_e_14netfilterqueue_IPPROTO_ICMPV6 = 58,

__pyx_e_14netfilterqueue_IPPROTO_NONE = 59,

__pyx_e_14netfilterqueue_IPPROTO_DSTOPTS = 60,

__pyx_e_14netfilterqueue_IPPROTO_MTP = 92,

__pyx_e_14netfilterqueue_IPPROTO_ENCAP = 98,

__pyx_e_14netfilterqueue_IPPROTO_PIM = 103,

__pyx_e_14netfilterqueue_IPPROTO_COMP = 108,

__pyx_e_14netfilterqueue_IPPROTO_SCTP = 132,

__pyx_e_14netfilterqueue_IPPROTO_RAW = 255,

__pyx_e_14netfilterqueue_IPPROTO_MAX

};

enum {

__pyx_e_14netfilterqueue_PF_INET = 2,

__pyx_e_14netfilterqueue_PF_INET6 = 10

};

enum {

/* "netfilterqueue.pxd":150

__pyx_e_14netfilterqueue_NF_DROP,

__pyx_e_14netfilterqueue_NF_ACCEPT,

__pyx_e_14netfilterqueue_NF_STOLEN,

__pyx_e_14netfilterqueue_NF_QUEUE,

__pyx_e_14netfilterqueue_NF_REPEAT,

__pyx_e_14netfilterqueue_NF_STOP,

__pyx_e_14netfilterqueue_NF_MAX_VERDICT = __pyx_e_14netfilterqueue_NF_STOP

};

struct __pyx_obj_14netfilterqueue_Packet {

};

struct __pyx_obj_14netfilterqueue_NetfilterQueue {

};

struct __pyx_vtabstruct_14netfilterqueue_Packet {

};

static struct __pyx_vtabstruct_14netfilterqueue_Packet *__pyx_vtabptr_14netfilterqueue_Packet;

struct __pyx_vtabstruct_14netfilterqueue_NetfilterQueue {

PyObject *(*run2)(struct __pyx_obj_14netfilterqueue_NetfilterQueue *, int __pyx_skip_dispatch);

};

static struct __pyx_vtabstruct_14netfilterqueue_NetfilterQueue *__pyx_vtabptr_14netfilterqueue_NetfilterQueue;

#ifndef CYTHON_REFNANNY

#define CYTHON_REFNANNY 0

#if CYTHON_REFNANNY

typedef struct {

void (*INCREF)(void*, PyObject*, int);

void (*DECREF)(void*, PyObject*, int);

void (*GOTREF)(void*, PyObject*, int);

void (*GIVEREF)(void*, PyObject*, int);

void* (*SetupContext)(const char*, int, const char*);

void (*FinishContext)(void**);

} __Pyx_RefNannyAPIStruct;

static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;

static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/

#define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;

#ifdef WITH_THREAD

#define __Pyx_RefNannySetupContext(name, acquire_gil) \

if (acquire_gil) { \

PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \

PyGILState_Release(__pyx_gilstate_save); \

} else { \

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \

}

#define __Pyx_RefNannySetupContext(name, acquire_gil) \

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)

#define __Pyx_RefNannyFinishContext() \

__Pyx_RefNanny->FinishContext(&__pyx_refnanny)

#define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)

#define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)

#define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)

#define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)

#define __Pyx_RefNannyDeclarations

#define __Pyx_RefNannySetupContext(name, acquire_gil)

#define __Pyx_RefNannyFinishContext()

#define __Pyx_INCREF(r) Py_INCREF(r)

#define __Pyx_DECREF(r) Py_DECREF(r)

#define __Pyx_GOTREF(r)

#define __Pyx_GIVEREF(r)

#define __Pyx_XINCREF(r) Py_XINCREF(r)

#define __Pyx_XDECREF(r) Py_XDECREF(r)

#define __Pyx_XGOTREF(r)

#define __Pyx_XGIVEREF(r)

#endif /* CYTHON_REFNANNY */

#define __Pyx_XDECREF_SET(r, v) do { \

PyObject *tmp = (PyObject *) r; \

r = v; __Pyx_XDECREF(tmp); \

} while (0)

#define __Pyx_DECREF_SET(r, v) do { \

PyObject *tmp = (PyObject *) r; \

r = v; __Pyx_DECREF(tmp); \

} while (0)

#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)

#if CYTHON_COMPILING_IN_CPYTHON

static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {

PyTypeObject* tp = Py_TYPE(obj);

if (likely(tp->tp_getattro))

return tp->tp_getattro(obj, attr_name);

#if PY_MAJOR_VERSION < 3

if (likely(tp->tp_getattr))

return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));

return PyObject_GetAttr(obj, attr_name);

}

#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)

static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/

#ifndef __PYX_FORCE_INIT_THREADS

#define __PYX_FORCE_INIT_THREADS 0

#if CYTHON_COMPILING_IN_CPYTHON

static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); /*proto*/

#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)

static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/

static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/

static void __Pyx_WriteUnraisable(const char *name, int clineno,

int lineno, const char *filename,

int full_traceback); /*proto*/

static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,

Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/

static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /*proto*/

static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/

static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /*proto*/

static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,

const char *name, int exact); /*proto*/

static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); /*proto*/

static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /*proto*/

static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \

PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \

const char* function_name); /*proto*/

static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/

static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/

static int __Pyx_SetVtable(PyObject *dict, void *vtable); /*proto*/

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_u_int32_t(u_int32_t value);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_u_int16_t(u_int16_t value);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_u_int8_t(u_int8_t value);

static CYTHON_INLINE u_int32_t __Pyx_PyInt_As_u_int32_t(PyObject *);

static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

static CYTHON_INLINE u_int8_t __Pyx_PyInt_As_u_int8_t(PyObject *);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);

static CYTHON_INLINE u_int16_t __Pyx_PyInt_As_u_int16_t(PyObject *);

static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /*proto*/

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

static int __Pyx_check_binary_version(void);

typedef struct {

int code_line;

PyCodeObject* code_object;

} __Pyx_CodeObjectCacheEntry;

struct __Pyx_CodeObjectCache {

};

static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};

static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);

static PyCodeObject *__pyx_find_code_object(int code_line);

static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

static void __Pyx_AddTraceback(const char *funcname, int c_line,

int py_line, const char *filename); /*proto*/

static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/

static PyTypeObject *__pyx_ptype_14netfilterqueue_Packet = 0;

static PyTypeObject *__pyx_ptype_14netfilterqueue_NetfilterQueue = 0;

static int __pyx_f_14netfilterqueue_global_callback(struct nfq_q_handle *, struct nfgenmsg *, struct nfq_data *, void *); /*proto*/

#define __Pyx_MODULE_NAME "netfilterqueue"

int __pyx_module_is_main_netfilterqueue = 0;

static PyObject *__pyx_builtin_OSError;

static PyObject *__pyx_builtin_RuntimeWarning;

static int __pyx_pf_14netfilterqueue_6Packet___cinit__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_2__str__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_4get_payload(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_6get_payload_len(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_8get_timestamp(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_10set_payload(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, PyObject *__pyx_v_payload); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_12set_mark(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, u_int32_t __pyx_v_mark); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_14get_mark(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_16accept(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_18drop(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_20repeat(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_2id___get__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_11hw_protocol___get__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_4hook___get__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_4mark___get__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_6Packet_7payload___get__(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self); /* proto */

static int __pyx_pf_14netfilterqueue_14NetfilterQueue___cinit__(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */

static void __pyx_pf_14netfilterqueue_14NetfilterQueue_2__dealloc__(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_14NetfilterQueue_4bind(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self, int __pyx_v_queue_num, PyObject *__pyx_v_user_callback, u_int32_t __pyx_v_max_len, u_int8_t __pyx_v_mode, u_int32_t __pyx_v_range); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_14NetfilterQueue_6unbind(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_14NetfilterQueue_8run(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self); /* proto */

static PyObject *__pyx_pf_14netfilterqueue_14NetfilterQueue_10run2(struct __pyx_obj_14netfilterqueue_NetfilterQueue *__pyx_v_self); /* proto */

static PyObject *__pyx_tp_new_14netfilterqueue_Packet(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/

static PyObject *__pyx_tp_new_14netfilterqueue_NetfilterQueue(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/

static char __pyx_k_AH[] = "AH";

static char __pyx_k_FC[] = "FC";

static char __pyx_k_IL[] = "IL";

static char __pyx_k_IP[] = "IP";

static char __pyx_k_SM[] = "SM";

static char __pyx_k_ST[] = "ST";

static char __pyx_k_TP[] = "TP++";

static char __pyx_k_af[] = "af";

static char __pyx_k_3PC[] = "3PC";

static char __pyx_k_A_N[] = "A/N";

static char __pyx_k_BNA[] = "BNA";

static char __pyx_k_CBT[] = "CBT";

static char __pyx_k_DDP[] = "DDP";

static char __pyx_k_DDX[] = "DDX";

static char __pyx_k_DGP[] = "DGP";

static char __pyx_k_DSR[] = "DSR";

static char __pyx_k_EGP[] = "EGP";

static char __pyx_k_ESP[] = "ESP";

static char __pyx_k_GGP[] = "GGP";

static char __pyx_k_GRE[] = "GRE";

static char __pyx_k_HIP[] = "HIP";

static char __pyx_k_HMP[] = "HMP";

static char __pyx_k_IGP[] = "IGP";

static char __pyx_k_MTP[] = "MTP";

static char __pyx_k_MUX[] = "MUX";

static char __pyx_k_PGM[] = "PGM";

static char __pyx_k_PIM[] = "PIM";

static char __pyx_k_PRM[] = "PRM";

static char __pyx_k_PTP[] = "PTP";

static char __pyx_k_PUP[] = "PUP";

static char __pyx_k_PVP[] = "PVP";

static char __pyx_k_QNX[] = "QNX";

static char __pyx_k_RDP[] = "RDP";

static char __pyx_k_RVD[] = "RVD";

static char __pyx_k_SMP[] = "SMP";

static char __pyx_k_SNP[] = "SNP";

static char __pyx_k_SPS[] = "SPS";

static char __pyx_k_SRP[] = "SRP";

static char __pyx_k_STP[] = "STP";

static char __pyx_k_TCF[] = "TCF";

static char __pyx_k_TCP[] = "TCP";

static char __pyx_k_TTP[] = "TTP";

static char __pyx_k_UDP[] = "UDP";

static char __pyx_k_UTI[] = "UTI";

static char __pyx_k_WSN[] = "WSN";

static char __pyx_k_XTP[] = "XTP";

static char __pyx_k_get[] = "get";

static char __pyx_k_ARIS[] = "ARIS";

static char __pyx_k_CFTP[] = "CFTP";

static char __pyx_k_CPHB[] = "CPHB";

static char __pyx_k_CPNX[] = "CPNX";

static char __pyx_k_CRTP[] = "CRTP";

static char __pyx_k_DCCP[] = "DCCP";

static char __pyx_k_FIRE[] = "FIRE";

static char __pyx_k_GMTP[] = "GMTP";

static char __pyx_k_IATP[] = "IATP";

static char __pyx_k_ICMP[] = "ICMP";

static char __pyx_k_IDPR[] = "IDPR";

static char __pyx_k_IDRP[] = "IDRP";

static char __pyx_k_IFMP[] = "IFMP";

static char __pyx_k_IGMP[] = "IGMP";

static char __pyx_k_IPCV[] = "IPCV";

static char __pyx_k_IPIP[] = "IPIP";

static char __pyx_k_IPLT[] = "IPLT";

static char __pyx_k_IPPC[] = "IPPC";

static char __pyx_k_IPv6[] = "IPv6";

static char __pyx_k_IRTP[] = "IRTP";

static char __pyx_k_ISIS[] = "ISIS";

static char __pyx_k_L2TP[] = "L2TP";

static char __pyx_k_LARP[] = "LARP";

static char __pyx_k_MICP[] = "MICP";

static char __pyx_k_NARP[] = "NARP";

static char __pyx_k_PIPE[] = "PIPE";

static char __pyx_k_PNNI[] = "PNNI";

static char __pyx_k_RSVP[] = "RSVP";

static char __pyx_k_SCPS[] = "SCPS";

static char __pyx_k_SCTP[] = "SCTP";

static char __pyx_k_SDRP[] = "SDRP";

static char __pyx_k_SKIP[] = "SKIP";

static char __pyx_k_TLSP[] = "TLSP";

static char __pyx_k_VISA[] = "VISA";

static char __pyx_k_VMTP[] = "VMTP";

static char __pyx_k_VRRP[] = "VRRP";

static char __pyx_k_XNET[] = "XNET";

static char __pyx_k_drop[] = "drop";

static char __pyx_k_main[] = "__main__";

static char __pyx_k_mode[] = "mode";

static char __pyx_k_run2[] = "run2";

static char __pyx_k_test[] = "__test__";

static char __pyx_k_ARGUS[] = "ARGUS";

static char __pyx_k_AX_25[] = "AX.25";

static char __pyx_k_CHAOS[] = "CHAOS";

static char __pyx_k_CRUDP[] = "CRUDP";

static char __pyx_k_EIGRP[] = "EIGRP";

static char __pyx_k_EMCON[] = "EMCON";

static char __pyx_k_ENCAP[] = "ENCAP";

static char __pyx_k_SWIPE[] = "SWIPE";

static char __pyx_k_Shim6[] = "Shim6";

static char __pyx_k_VINES[] = "VINES";

static char __pyx_k_close[] = "close";

static char __pyx_k_manet[] = "manet";