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

#error Cython requires Python 2.6+ or Python 3.2+.

#define CYTHON_ABI "0_24"

#include <stddef.h>

#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 !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000

#define CYTHON_USE_PYLONG_INTERNALS 1

#if CYTHON_USE_PYLONG_INTERNALS

#include "longintrepr.h"

#undef SHIFT

#undef BASE

#undef MASK

#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)

#define Py_OptimizeFlag 0

#define __PYX_BUILD_PY_SSIZE_T "n"

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

#ifndef Py_TPFLAGS_CHECKTYPES

#define Py_TPFLAGS_CHECKTYPES 0

#ifndef Py_TPFLAGS_HAVE_INDEX

#define Py_TPFLAGS_HAVE_INDEX 0

#ifndef Py_TPFLAGS_HAVE_NEWBUFFER

#define Py_TPFLAGS_HAVE_NEWBUFFER 0

#ifndef 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 __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))

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

#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))

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

#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)

#define PyUnicode_Contains(u, s) PySequence_Contains(u, s)

#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)

#define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)

#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)

#define PyObject_Malloc(s) PyMem_Malloc(s)

#define PyObject_Free(p) PyMem_Free(p)

#define PyObject_Realloc(p) PyMem_Realloc(p)

#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 && !defined(PyObject_ASCII)

#define PyObject_ASCII(o) PyObject_Repr(o)

#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_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_Check(obj) || PyUnicode_Check(obj))

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

#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_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY

#ifndef PyUnicode_InternFromString

#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)

#endif

#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

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

#define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)

#if PY_VERSION_HEX >= 0x030500B1

#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods

#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)

#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3

typedef struct {

unaryfunc am_await;

unaryfunc am_aiter;

unaryfunc am_anext;

} __Pyx_PyAsyncMethodsStruct;

#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))

#define __Pyx_PyType_AsAsync(obj) NULL

#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

#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)

#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

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

#define _USE_MATH_DEFINES

#include <math.h>

#ifdef NAN

#define __PYX_NAN() ((float) NAN)

static CYTHON_INLINE float __PYX_NAN() {

float value;

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

return value;

}

#define __PYX_ERR(f_index, lineno, Ln_error) \

{ \

__pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \

}

#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

#define __PYX_HAVE__netfilterqueue

#define __PYX_HAVE_API__netfilterqueue

#include "sys/types.h"

#include <errno.h>

#include "netinet/ip.h"

#include "sys/time.h"

#include "netinet/in.h"

#include "libnfnetlink/linux_nfnetlink.h"

#include "libnfnetlink/libnfnetlink.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

#ifndef CYTHON_NCP_UNUSED

# if CYTHON_COMPILING_IN_CPYTHON

# define CYTHON_NCP_UNUSED

# define CYTHON_NCP_UNUSED CYTHON_UNUSED

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

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 ""

#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString

#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize

#define __Pyx_uchar_cast(c) ((unsigned char)c)

#define __Pyx_long_cast(x) ((long)x)

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

#if defined (__cplusplus) && __cplusplus >= 201103L

#include <cstdlib>

#define __Pyx_sst_abs(value) std::abs(value)

#elif SIZEOF_INT >= SIZEOF_SIZE_T

#define __Pyx_sst_abs(value) abs(value)

#elif SIZEOF_LONG >= SIZEOF_SIZE_T

#define __Pyx_sst_abs(value) labs(value)

#elif defined (_MSC_VER) && defined (_M_X64)

#define __Pyx_sst_abs(value) _abs64(value)

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

#define __Pyx_sst_abs(value) llabs(value)

#elif defined (__GNUC__)

#define __Pyx_sst_abs(value) __builtin_llabs(value)

#define __Pyx_sst_abs(value) ((value<0) ? -value : value)

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_FromCString(s) __Pyx_PyObject_FromString((const char*)s)

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

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

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

#define __Pyx_PyUnicode_FromCString(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 (size_t)(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_NewRef(obj) (Py_INCREF(obj), obj)

#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)

#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))

static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);

static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(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

#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))

#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))

#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(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;

PyObject* default_encoding = NULL;

PyObject* ascii_chars_u = NULL;

PyObject* ascii_chars_b = NULL;

const char* default_encoding_c;

sys = PyImport_ImportModule("sys");

if (!sys) goto bad;

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

Py_DECREF(sys);

if (!default_encoding) goto bad;

default_encoding_c = PyBytes_AsString(default_encoding);

if (!default_encoding_c) goto bad;

if (strcmp(default_encoding_c, "ascii") == 0) {

__Pyx_sys_getdefaultencoding_not_ascii = 0;

} else {

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) goto bad;

ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);

if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(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_DECREF(ascii_chars_u);

Py_DECREF(ascii_chars_b);

}

Py_DECREF(default_encoding);

return 0;

bad:

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;

PyObject* default_encoding = NULL;

char* default_encoding_c;

sys = PyImport_ImportModule("sys");

if (!sys) goto bad;

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

Py_DECREF(sys);

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

if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;

strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);

Py_DECREF(default_encoding);

return 0;

bad:

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 PyObject *__pyx_empty_unicode;

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 {

/* "netfilterqueue.pxd":12

__pyx_e_14netfilterqueue_EAGAIN = 11,

__pyx_e_14netfilterqueue_EWOULDBLOCK = __pyx_e_14netfilterqueue_EAGAIN,

__pyx_e_14netfilterqueue_ENOBUFS = 0x69

};

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 = 0x67,

__pyx_e_14netfilterqueue_IPPROTO_COMP = 0x6C,

__pyx_e_14netfilterqueue_IPPROTO_SCTP = 0x84,

__pyx_e_14netfilterqueue_IPPROTO_RAW = 0xFF,

__pyx_e_14netfilterqueue_IPPROTO_MAX

};

enum {

__pyx_e_14netfilterqueue_PF_INET = 2,

__pyx_e_14netfilterqueue_PF_INET6 = 10

};

enum {

/* "netfilterqueue.pxd":167

__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;

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

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

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

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

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

#if CYTHON_COMPILING_IN_CPYTHON

static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);

static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

#if CYTHON_COMPILING_IN_CPYTHON

#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;

#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET();

#define __Pyx_PyThreadState_declare

#define __Pyx_PyThreadState_assign

#if CYTHON_COMPILING_IN_CPYTHON

#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)

#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)

#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)

#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)

static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);

static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);

#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)

#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)

#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)

#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)

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

int lineno, const char *filename,

int full_traceback, int nogil);

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

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

static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);

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

#if CYTHON_COMPILING_IN_CPYTHON

static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);

#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)

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

const char *name, int exact);

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

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

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

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

const char* function_name);

#if CYTHON_COMPILING_IN_CPYTHON

#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)

static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);

#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)

static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);

#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)

#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)

#if CYTHON_COMPILING_IN_CPYTHON

#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)

static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);

#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)

#if CYTHON_COMPILING_IN_CPYTHON

#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)

static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);

static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);

#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\

(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\

__Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\

(is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\

__Pyx_GetItemInt_Generic(o, to_py_func(i))))

#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\

(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\

__Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\

(PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,

int wraparound, int boundscheck);

#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\

(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\

__Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\

(PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,

int wraparound, int boundscheck);

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,

int is_list, int wraparound, int boundscheck);

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

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

typedef struct {

PyCodeObject* code_object;

int code_line;

} __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);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_u_int8_t(u_int8_t value);

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_int(int value);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);

static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long 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 u_int16_t __Pyx_PyInt_As_u_int16_t(PyObject *);

static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

static int __Pyx_check_binary_version(void);

static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);

static PyObject *__pyx_f_14netfilterqueue_6Packet_set_nfq_data(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, struct nfq_q_handle *__pyx_v_qh, struct nfq_data *__pyx_v_nfa); /* proto*/

static void __pyx_f_14netfilterqueue_6Packet_verdict(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, u_int8_t __pyx_v_verdict); /* proto*/

static Py_ssize_t __pyx_f_14netfilterqueue_6Packet_get_payload_len(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/

static double __pyx_f_14netfilterqueue_6Packet_get_timestamp(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_set_payload(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, PyObject *__pyx_v_payload, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_set_mark(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, u_int32_t __pyx_v_mark, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_get_mark(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_accept(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_drop(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/

static PyObject *__pyx_f_14netfilterqueue_6Packet_repeat(struct __pyx_obj_14netfilterqueue_Packet *__pyx_v_self, int __pyx_skip_dispatch); /* 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 const char __pyx_k_AH[] = "AH";

static const char __pyx_k_FC[] = "FC";

static const char __pyx_k_IL[] = "IL";

static const char __pyx_k_IP[] = "IP";

static const char __pyx_k_SM[] = "SM";

static const char __pyx_k_ST[] = "ST";

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

static const char __pyx_k_af[] = "af";

static const char __pyx_k_3PC[] = "3PC";

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

static const char __pyx_k_BNA[] = "BNA";

static const char __pyx_k_CBT[] = "CBT";

static const char __pyx_k_DDP[] = "DDP";

static const char __pyx_k_DDX[] = "DDX";

static const char __pyx_k_DGP[] = "DGP";

static const char __pyx_k_DSR[] = "DSR";

static const char __pyx_k_EGP[] = "EGP";

static const char __pyx_k_ESP[] = "ESP";

static const char __pyx_k_GGP[] = "GGP";

static const char __pyx_k_GRE[] = "GRE";

static const char __pyx_k_HIP[] = "HIP";

static const char __pyx_k_HMP[] = "HMP";

static const char __pyx_k_IGP[] = "IGP";

static const char __pyx_k_MTP[] = "MTP";

static const char __pyx_k_MUX[] = "MUX";

static const char __pyx_k_PGM[] = "PGM";

static const char __pyx_k_PIM[] = "PIM";

static const char __pyx_k_PRM[] = "PRM";

static const char __pyx_k_PTP[] = "PTP";

static const char __pyx_k_PUP[] = "PUP";

static const char __pyx_k_PVP[] = "PVP";

static const char __pyx_k_QNX[] = "QNX";

static const char __pyx_k_RDP[] = "RDP";

static const char __pyx_k_RVD[] = "RVD";

static const char __pyx_k_SMP[] = "SMP";

static const char __pyx_k_SNP[] = "SNP";

static const char __pyx_k_SPS[] = "SPS";