/* Generated by Cython 0.19.1 on Wed Jun 28 05:32:00 2017 */

#define PY_SSIZE_T_CLEAN
#ifndef CYTHON_USE_PYLONG_INTERNALS
#ifdef PYLONG_BITS_IN_DIGIT
#define CYTHON_USE_PYLONG_INTERNALS 0
#else
#include "pyconfig.h"
#ifdef PYLONG_BITS_IN_DIGIT
#define CYTHON_USE_PYLONG_INTERNALS 1
#else
#define CYTHON_USE_PYLONG_INTERNALS 0
#endif
#endif
#endif
#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+.
#else
#include <stddef.h> /* For offsetof */
#ifndef offsetof
#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
#define CYTHON_COMPILING_IN_PYPY 1
#define CYTHON_COMPILING_IN_CPYTHON 0
#else
#define CYTHON_COMPILING_IN_PYPY 0
#define CYTHON_COMPILING_IN_CPYTHON 1
#endif
#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_AsInt(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"
#else
  #define __PYX_BUILD_PY_SSIZE_T "n"
  #define CYTHON_FORMAT_SSIZE_T "z"
  #define __Pyx_PyIndex_Check PyIndex_Check
#endif
#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 *);
#endif
#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, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#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)
#endif
#if PY_MAJOR_VERSION < 3 && PY_MINOR_VERSION < 6
  #define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict")
#endif
#if PY_MAJOR_VERSION >= 3
  #define Py_TPFLAGS_CHECKTYPES 0
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#if PY_VERSION_HEX < 0x02060000
  #define Py_TPFLAGS_HAVE_VERSION_TAG 0
#endif
#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_READ(k, d, i)   PyUnicode_READ(k, d, i)
#else
  #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_READ(k, d, i)   ((k=k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
#endif
#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
#endif
#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
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \
                                         PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (Py_TYPE(obj) == &PyBaseString_Type)
#endif
#if PY_VERSION_HEX < 0x02060000
  #define PySet_Check(obj)             PyObject_TypeCheck(obj, &PySet_Type)
  #define PyFrozenSet_Check(obj)       PyObject_TypeCheck(obj, &PyFrozenSet_Type)
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#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
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_VERSION_HEX < 0x03020000
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
#endif
#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)
#else
  #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)))
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
#endif
#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)))
#else
  #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))
#endif
#if PY_VERSION_HEX < 0x02050000
  #define __Pyx_NAMESTR(n) ((char *)(n))
  #define __Pyx_DOCSTR(n)  ((char *)(n))
#else
  #define __Pyx_NAMESTR(n) (n)
  #define __Pyx_DOCSTR(n)  (n)
#endif
#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
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER)
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and
   a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is
   a quiet NaN. */
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif


#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)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#endif

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#if defined(WIN32) || defined(MS_WINDOWS)
#define _USE_MATH_DEFINES
#endif
#include <math.h>
#define __PYX_HAVE__calign
#define __PYX_HAVE_API__calign
#include "string.h"
#include "stdio.h"
#include "pythread.h"
#include "stdlib.h"
#include "math.h"
#include "ctype.h"
#include "stdint.h"
#include "htslib/bgzf.h"
#include "htslib/hts.h"
#include "htslib/sam.h"
#include "align.h"
#ifdef _OPENMP
#include <omp.h>
#endif /* _OPENMP */

#ifdef PYREX_WITHOUT_ASSERTIONS
#define CYTHON_WITHOUT_ASSERTIONS
#endif

#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
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
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(char*);
#if PY_MAJOR_VERSION < 3
    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromUString(s)  __Pyx_PyObject_FromString((char*)s)
#define __Pyx_PyBytes_FromUString(s)   __Pyx_PyBytes_FromString((char*)s)
#define __Pyx_PyStr_FromUString(s)     __Pyx_PyStr_FromString((char*)s)
#define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((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;
}
#else
#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
#endif
#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);
static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*);
#if CYTHON_COMPILING_IN_CPYTHON
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#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() {
    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 '%s' 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;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#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() {
    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;
}
#endif
#endif


#ifdef __GNUC__
  /* Test for GCC > 2.95 */
  #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
    #define likely(x)   __builtin_expect(!!(x), 1)
    #define unlikely(x) __builtin_expect(!!(x), 0)
  #else /* __GNUC__ > 2 ... */
    #define likely(x)   (x)
    #define unlikely(x) (x)
  #endif /* __GNUC__ > 2 ... */
#else /* __GNUC__ */
  #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[] = {
  "calign.pyx",
  "type.pxd",
  "bool.pxd",
  "complex.pxd",
  "htslibWrapper.pxd",
};

/* "calign.pyx":30
 * cdef int mask = (1 << 2*hash_nucs) - 1
 * 
 * ctypedef long long size_t             # <<<<<<<<<<<<<<
 * cdef double mLTOT = -0.23025850929940459    # Minus log ten over ten
 * 
 */
typedef PY_LONG_LONG __pyx_t_6calign_size_t;

/*--- Type declarations ---*/
struct __pyx_obj_13htslibWrapper_Samfile;
struct __pyx_obj_13htslibWrapper_ReadIterator;
struct __pyx_t_13htslibWrapper_cAlignedRead;
typedef struct __pyx_t_13htslibWrapper_cAlignedRead __pyx_t_13htslibWrapper_cAlignedRead;
struct __pyx_opt_args_13htslibWrapper_7Samfile__open;

/* "htslibWrapper.pxd":187
 *     int bam_cigar_oplen(uint32_t c)
 * 
 * ctypedef struct cAlignedRead:             # <<<<<<<<<<<<<<
 *     char* seq
 *     char* qual
 */
struct __pyx_t_13htslibWrapper_cAlignedRead {
  char *seq;
  char *qual;
  short *cigarOps;
  short *hash;
  short mateChromID;
  short cigarLen;
  short chromID;
  short rlen;
  int pos;
  int end;
  int insertSize;
  int matePos;
  int bitFlag;
  unsigned char mapq;
};

/* "htslibWrapper.pxd":211
 *     cdef _hasIndex(self)
 *     cdef void openBAMFile(self, mode)
 *     cpdef _open(self, mode, loadIndex=*)             # <<<<<<<<<<<<<<
 *     cdef char* getrname(self, int tid)
 *     cpdef ReadIterator fetch(self, const char *region)
 */
struct __pyx_opt_args_13htslibWrapper_7Samfile__open {
  int __pyx_n;
  PyObject *loadIndex;
};

/* "htslibWrapper.pxd":203
 *     unsigned char mapq
 * 
 * cdef class Samfile:             # <<<<<<<<<<<<<<
 *     cdef void clearHeader(self)
 *     cdef void clearIndex(self)
 */
struct __pyx_obj_13htslibWrapper_Samfile {
  PyObject_HEAD
  struct __pyx_vtabstruct_13htslibWrapper_Samfile *__pyx_vtab;
  char *filename;
  samFile *samfile;
  bam_hdr_t *theHeader;
  hts_idx_t *index;
  PyObject *lock;
};


/* "htslibWrapper.pxd":222
 *     cdef object lock
 * 
 * cdef class ReadIterator:             # <<<<<<<<<<<<<<
 *     cdef cAlignedRead* get(self, int storeRgID, char** rgID)
 *     cdef int cnext(self) nogil
 */
struct __pyx_obj_13htslibWrapper_ReadIterator {
  PyObject_HEAD
  struct __pyx_vtabstruct_13htslibWrapper_ReadIterator *__pyx_vtab;
  samFile *theSamfile;
  hts_itr_t *theIterator;
  bam1_t *b;
};



/* "htslibWrapper.pxd":203
 *     unsigned char mapq
 * 
 * cdef class Samfile:             # <<<<<<<<<<<<<<
 *     cdef void clearHeader(self)
 *     cdef void clearIndex(self)
 */

struct __pyx_vtabstruct_13htslibWrapper_Samfile {
  void (*clearHeader)(struct __pyx_obj_13htslibWrapper_Samfile *);
  void (*clearIndex)(struct __pyx_obj_13htslibWrapper_Samfile *);
  int (*_isBam)(struct __pyx_obj_13htslibWrapper_Samfile *);
  int (*_isCram)(struct __pyx_obj_13htslibWrapper_Samfile *);
  int (*_isOpen)(struct __pyx_obj_13htslibWrapper_Samfile *);
  PyObject *(*_hasIndex)(struct __pyx_obj_13htslibWrapper_Samfile *);
  void (*openBAMFile)(struct __pyx_obj_13htslibWrapper_Samfile *, PyObject *);
  PyObject *(*_open)(struct __pyx_obj_13htslibWrapper_Samfile *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_13htslibWrapper_7Samfile__open *__pyx_optional_args);
  char *(*getrname)(struct __pyx_obj_13htslibWrapper_Samfile *, int);
  struct __pyx_obj_13htslibWrapper_ReadIterator *(*fetch)(struct __pyx_obj_13htslibWrapper_Samfile *, char const *, int __pyx_skip_dispatch);
  PyObject *(*close)(struct __pyx_obj_13htslibWrapper_Samfile *, int __pyx_skip_dispatch);
};
static struct __pyx_vtabstruct_13htslibWrapper_Samfile *__pyx_vtabptr_13htslibWrapper_Samfile;


/* "htslibWrapper.pxd":222
 *     cdef object lock
 * 
 * cdef class ReadIterator:             # <<<<<<<<<<<<<<
 *     cdef cAlignedRead* get(self, int storeRgID, char** rgID)
 *     cdef int cnext(self) nogil
 */

struct __pyx_vtabstruct_13htslibWrapper_ReadIterator {
  __pyx_t_13htslibWrapper_cAlignedRead *(*get)(struct __pyx_obj_13htslibWrapper_ReadIterator *, int, char **);
  int (*cnext)(struct __pyx_obj_13htslibWrapper_ReadIterator *);
  char (*_getBase)(struct __pyx_obj_13htslibWrapper_ReadIterator *, uint8_t *, int);
};
static struct __pyx_vtabstruct_13htslibWrapper_ReadIterator *__pyx_vtabptr_13htslibWrapper_ReadIterator;
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#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__); \
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil) \
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #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)
#else
  #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_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));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

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

static void* __Pyx_GetVtable(PyObject *dict); /*proto*/

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

static CYTHON_INLINE long __Pyx_pow_long(long, long); /* proto */

static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject *);

static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject *);

static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject *);

static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject *);

static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject *);

static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject *);

static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject *);

static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject *);

static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject *);

static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject *);

static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject *);

static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject *);

static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject *);

static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject *);

static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject *);

static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject *);

static int __Pyx_check_binary_version(void);

#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_setattro))
        return tp->tp_setattro(obj, attr_name, value);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_setattr))
        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
#endif
    return PyObject_SetAttr(obj, attr_name, value);
}
#else
#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif

static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig); /*proto*/

static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/

#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif

static PyObject *__Pyx_ImportModule(const char *name); /*proto*/

static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);  /*proto*/

typedef struct {
    int code_line;
    PyCodeObject* code_object;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
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*/


/* Module declarations from 'cython' */

/* Module declarations from 'cpython.version' */

/* Module declarations from 'cpython.ref' */

/* Module declarations from 'cpython.exc' */

/* Module declarations from 'cpython.module' */

/* Module declarations from 'cpython.mem' */

/* Module declarations from 'cpython.tuple' */

/* Module declarations from 'cpython.list' */

/* Module declarations from 'libc.string' */

/* Module declarations from 'libc.stdio' */

/* Module declarations from 'cpython.object' */

/* Module declarations from 'cpython.sequence' */

/* Module declarations from 'cpython.mapping' */

/* Module declarations from 'cpython.iterator' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;

/* Module declarations from 'cpython.number' */

/* Module declarations from 'cpython.int' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.bool' */
static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;

/* Module declarations from 'cpython.long' */

/* Module declarations from 'cpython.float' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.complex' */
static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;

/* Module declarations from 'cpython.string' */

/* Module declarations from 'cpython.unicode' */

/* Module declarations from 'cpython.dict' */

/* Module declarations from 'cpython.instance' */

/* Module declarations from 'cpython.function' */

/* Module declarations from 'cpython.method' */

/* Module declarations from 'cpython.weakref' */

/* Module declarations from 'cpython.getargs' */

/* Module declarations from 'cpython.pythread' */

/* Module declarations from 'cpython.pystate' */

/* Module declarations from 'cpython.cobject' */

/* Module declarations from 'cpython.oldbuffer' */

/* Module declarations from 'cpython.set' */

/* Module declarations from 'cpython.buffer' */

/* Module declarations from 'cpython.bytes' */

/* Module declarations from 'cpython.pycapsule' */

/* Module declarations from 'cpython' */

/* Module declarations from 'htslibWrapper' */
static PyTypeObject *__pyx_ptype_13htslibWrapper_Samfile = 0;
static PyTypeObject *__pyx_ptype_13htslibWrapper_ReadIterator = 0;

/* Module declarations from 'cerrormodel' */

/* Module declarations from 'calign' */
static int __pyx_v_6calign_hash_nucs;
static int __pyx_v_6calign_hash_size;
static int __pyx_v_6calign_max_sequence_length;
static int __pyx_v_6calign_mask;
static double __pyx_v_6calign_mLTOT;
static CYTHON_INLINE unsigned int __pyx_f_6calign_my_hash(char *); /*proto*/
static CYTHON_INLINE unsigned int __pyx_f_6calign_my_hash_update(char, int); /*proto*/
#define __Pyx_MODULE_NAME "calign"
int __pyx_module_is_main_calign = 0;

/* Implementation of 'calign' */
static PyObject *__pyx_builtin_range;
static char __pyx_k_1[] = "\nCython module containing glue code for the alignment routines used in\nPlatypus.\n";
static char __pyx_k__range[] = "range";
static char __pyx_k__logging[] = "logging";
static char __pyx_k____main__[] = "__main__";
static char __pyx_k____test__[] = "__test__";
static char __pyx_k__hash_nucs[] = "hash_nucs";
static char __pyx_k__hash_size[] = "hash_size";
static char __pyx_k____import__[] = "__import__";
static char __pyx_k____pyx_capi__[] = "__pyx_capi__";
static char __pyx_k__htslibWrapper[] = "htslibWrapper";
static char __pyx_k____pyx_vtable__[] = "__pyx_vtable__";
static char __pyx_k__max_sequence_length[] = "max_sequence_length";
static PyObject *__pyx_n_s____import__;
static PyObject *__pyx_n_s____main__;
static PyObject *__pyx_n_s____pyx_capi__;
static PyObject *__pyx_n_s____pyx_vtable__;
static PyObject *__pyx_n_s____test__;
static PyObject *__pyx_n_s__hash_nucs;
static PyObject *__pyx_n_s__hash_size;
static PyObject *__pyx_n_s__htslibWrapper;
static PyObject *__pyx_n_s__logging;
static PyObject *__pyx_n_s__max_sequence_length;
static PyObject *__pyx_n_s__range;

/* "calign.pyx":61
 * ###################################################################################################
 * 
 * cdef inline unsigned int my_hash(char* seq) nogil:             # <<<<<<<<<<<<<<
 *     """
 *     Encodes first hash_nucs nucleotides (A,C,G,T or a,c,g,t) into an integer
 */

static CYTHON_INLINE unsigned int __pyx_f_6calign_my_hash(char *__pyx_v_seq) {
  int __pyx_v_i;
  int __pyx_v_c;
  unsigned int __pyx_v_h;
  unsigned int __pyx_r;
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;

  /* "calign.pyx":66
 *     """
 *     cdef int i, c
 *     cdef unsigned int h = 0             # <<<<<<<<<<<<<<
 * 
 *     for i in range(hash_nucs):
 */
  __pyx_v_h = 0;

  /* "calign.pyx":68
 *     cdef unsigned int h = 0
 * 
 *     for i in range(hash_nucs):             # <<<<<<<<<<<<<<
 *         c = seq[i] & 7   # a,A->1  c,C->3  g,G->7  t,T->4
 * 
 */
  __pyx_t_1 = __pyx_v_6calign_hash_nucs;
  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
    __pyx_v_i = __pyx_t_2;

    /* "calign.pyx":69
 * 
 *     for i in range(hash_nucs):
 *         c = seq[i] & 7   # a,A->1  c,C->3  g,G->7  t,T->4             # <<<<<<<<<<<<<<
 * 
 *         if c == 7:
 */
    __pyx_v_c = ((__pyx_v_seq[__pyx_v_i]) & 7);

    /* "calign.pyx":71
 *         c = seq[i] & 7   # a,A->1  c,C->3  g,G->7  t,T->4
 * 
 *         if c == 7:             # <<<<<<<<<<<<<<
 *             c = 2
 * 
 */
    __pyx_t_3 = ((__pyx_v_c == 7) != 0);
    if (__pyx_t_3) {

      /* "calign.pyx":72
 * 
 *         if c == 7:
 *             c = 2             # <<<<<<<<<<<<<<
 * 
 *         h = (h << 2) + <unsigned int>(c & 3)
 */
      __pyx_v_c = 2;
      goto __pyx_L5;
    }
    __pyx_L5:;

    /* "calign.pyx":74
 *             c = 2
 * 
 *         h = (h << 2) + <unsigned int>(c & 3)             # <<<<<<<<<<<<<<
 * 
 *     return h
 */
    __pyx_v_h = ((__pyx_v_h << 2) + ((unsigned int)(__pyx_v_c & 3)));
  }

  /* "calign.pyx":76
 *         h = (h << 2) + <unsigned int>(c & 3)
 * 
 *     return h             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
  __pyx_r = __pyx_v_h;
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "calign.pyx":80
 * ###################################################################################################
 * 
 * cdef inline unsigned int my_hash_update(char character, int oldVal) nogil:             # <<<<<<<<<<<<<<
 *     """
 *     Incrementally update hash value with one new character
 */

static CYTHON_INLINE unsigned int __pyx_f_6calign_my_hash_update(char __pyx_v_character, int __pyx_v_oldVal) {
  int __pyx_v_c;
  unsigned int __pyx_r;
  int __pyx_t_1;

  /* "calign.pyx":85
 *     """
 *     global mask
 *     cdef int c = character & 7   # a,A->1  c,C->3  g,G->7  t,T->4             # <<<<<<<<<<<<<<
 * 
 *     if c == 7:
 */
  __pyx_v_c = (__pyx_v_character & 7);

  /* "calign.pyx":87
 *     cdef int c = character & 7   # a,A->1  c,C->3  g,G->7  t,T->4
 * 
 *     if c == 7:             # <<<<<<<<<<<<<<
 *         c = 2
 * 
 */
  __pyx_t_1 = ((__pyx_v_c == 7) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":88
 * 
 *     if c == 7:
 *         c = 2             # <<<<<<<<<<<<<<
 * 
 *     return ((oldVal << 2) & mask) + <unsigned int>(c & 3)
 */
    __pyx_v_c = 2;
    goto __pyx_L3;
  }
  __pyx_L3:;

  /* "calign.pyx":90
 *         c = 2
 * 
 *     return ((oldVal << 2) & mask) + <unsigned int>(c & 3)             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
  __pyx_r = (((__pyx_v_oldVal << 2) & __pyx_v_6calign_mask) + ((unsigned int)(__pyx_v_c & 3)));
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "calign.pyx":94
 * ###################################################################################################
 * 
 * cdef void hash_sequence_multihit(char* sequence, int sequenceLength, short** hash_table, short** next_array) nogil:             # <<<<<<<<<<<<<<
 *     """
 *     Builds a hash table of the byte sequence, allowing multiple hits
 */

static void __pyx_f_6calign_hash_sequence_multihit(char *__pyx_v_sequence, int __pyx_v_sequenceLength, short **__pyx_v_hash_table, short **__pyx_v_next_array) {
  int __pyx_v_next_empty;
  int __pyx_v_hidx;
  int __pyx_v_i;
  int __pyx_v_j;
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;

  /* "calign.pyx":98
 *     Builds a hash table of the byte sequence, allowing multiple hits
 *     """
 *     hash_table[0] = <short*>(calloc(hash_size, sizeof(short)))             # <<<<<<<<<<<<<<
 *     next_array[0] = <short*>(calloc(hash_size, sizeof(short)))
 * 
 */
  (__pyx_v_hash_table[0]) = ((short *)calloc(__pyx_v_6calign_hash_size, (sizeof(short))));

  /* "calign.pyx":99
 *     """
 *     hash_table[0] = <short*>(calloc(hash_size, sizeof(short)))
 *     next_array[0] = <short*>(calloc(hash_size, sizeof(short)))             # <<<<<<<<<<<<<<
 * 
 *     if sequenceLength < hash_nucs:
 */
  (__pyx_v_next_array[0]) = ((short *)calloc(__pyx_v_6calign_hash_size, (sizeof(short))));

  /* "calign.pyx":101
 *     next_array[0] = <short*>(calloc(hash_size, sizeof(short)))
 * 
 *     if sequenceLength < hash_nucs:             # <<<<<<<<<<<<<<
 *         return
 * 
 */
  __pyx_t_1 = ((__pyx_v_sequenceLength < __pyx_v_6calign_hash_nucs) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":102
 * 
 *     if sequenceLength < hash_nucs:
 *         return             # <<<<<<<<<<<<<<
 * 
 *     cdef int next_empty = 1
 */
    goto __pyx_L0;
    goto __pyx_L3;
  }
  __pyx_L3:;

  /* "calign.pyx":104
 *         return
 * 
 *     cdef int next_empty = 1             # <<<<<<<<<<<<<<
 *     cdef int hidx
 *     cdef int i
 */
  __pyx_v_next_empty = 1;

  /* "calign.pyx":109
 *     cdef int j
 * 
 *     for i in range(sequenceLength - hash_nucs):             # <<<<<<<<<<<<<<
 *         hidx = my_hash(sequence + i)
 * 
 */
  __pyx_t_2 = (__pyx_v_sequenceLength - __pyx_v_6calign_hash_nucs);
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

    /* "calign.pyx":110
 * 
 *     for i in range(sequenceLength - hash_nucs):
 *         hidx = my_hash(sequence + i)             # <<<<<<<<<<<<<<
 * 
 *         # add position i into hash table under hash hidx
 */
    __pyx_v_hidx = __pyx_f_6calign_my_hash((__pyx_v_sequence + __pyx_v_i));

    /* "calign.pyx":115
 *         #*position[next_empty] = i
 *         # invariant: next_empty == i+1; therefore the position array is not necessary
 *         if hash_table[0][hidx] == 0:             # <<<<<<<<<<<<<<
 *             hash_table[0][hidx] = next_empty
 *         else:
 */
    __pyx_t_1 = ((((__pyx_v_hash_table[0])[__pyx_v_hidx]) == 0) != 0);
    if (__pyx_t_1) {

      /* "calign.pyx":116
 *         # invariant: next_empty == i+1; therefore the position array is not necessary
 *         if hash_table[0][hidx] == 0:
 *             hash_table[0][hidx] = next_empty             # <<<<<<<<<<<<<<
 *         else:
 *             # find the end of the list
 */
      ((__pyx_v_hash_table[0])[__pyx_v_hidx]) = __pyx_v_next_empty;
      goto __pyx_L6;
    }
    /*else*/ {

      /* "calign.pyx":119
 *         else:
 *             # find the end of the list
 *             j = hash_table[0][hidx]             # <<<<<<<<<<<<<<
 *             while next_array[0][j] != 0:
 *                 j = next_array[0][j]
 */
      __pyx_v_j = ((__pyx_v_hash_table[0])[__pyx_v_hidx]);

      /* "calign.pyx":120
 *             # find the end of the list
 *             j = hash_table[0][hidx]
 *             while next_array[0][j] != 0:             # <<<<<<<<<<<<<<
 *                 j = next_array[0][j]
 *             next_array[0][j] = next_empty
 */
      while (1) {
        __pyx_t_1 = ((((__pyx_v_next_array[0])[__pyx_v_j]) != 0) != 0);
        if (!__pyx_t_1) break;

        /* "calign.pyx":121
 *             j = hash_table[0][hidx]
 *             while next_array[0][j] != 0:
 *                 j = next_array[0][j]             # <<<<<<<<<<<<<<
 *             next_array[0][j] = next_empty
 *         # point to next empty location
 */
        __pyx_v_j = ((__pyx_v_next_array[0])[__pyx_v_j]);
      }

      /* "calign.pyx":122
 *             while next_array[0][j] != 0:
 *                 j = next_array[0][j]
 *             next_array[0][j] = next_empty             # <<<<<<<<<<<<<<
 *         # point to next empty location
 *         next_empty += 1
 */
      ((__pyx_v_next_array[0])[__pyx_v_j]) = __pyx_v_next_empty;
    }
    __pyx_L6:;

    /* "calign.pyx":124
 *             next_array[0][j] = next_empty
 *         # point to next empty location
 *         next_empty += 1             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
    __pyx_v_next_empty = (__pyx_v_next_empty + 1);
  }

  __pyx_L0:;
}

/* "calign.pyx":128
 * ###################################################################################################
 * 
 * cdef short* hash_sequence(char* sequence, int sequenceLength) nogil:             # <<<<<<<<<<<<<<
 *     """
 *     Returns a hash of the byte sequence
 */

static short *__pyx_f_6calign_hash_sequence(char *__pyx_v_sequence, int __pyx_v_sequenceLength) {
  char *__pyx_v_seq;
  short *__pyx_v_h;
  int __pyx_v_i;
  unsigned int __pyx_v_hidx;
  short *__pyx_r;
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;

  /* "calign.pyx":132
 *     Returns a hash of the byte sequence
 *     """
 *     cdef char* seq = sequence             # <<<<<<<<<<<<<<
 *     cdef short* h = <short*>(calloc(hash_size, sizeof(short)))
 *     cdef int i
 */
  __pyx_v_seq = __pyx_v_sequence;

  /* "calign.pyx":133
 *     """
 *     cdef char* seq = sequence
 *     cdef short* h = <short*>(calloc(hash_size, sizeof(short)))             # <<<<<<<<<<<<<<
 *     cdef int i
 *     cdef unsigned int hidx
 */
  __pyx_v_h = ((short *)calloc(__pyx_v_6calign_hash_size, (sizeof(short))));

  /* "calign.pyx":137
 *     cdef unsigned int hidx
 * 
 *     if sequenceLength < hash_nucs:             # <<<<<<<<<<<<<<
 *         return h
 * 
 */
  __pyx_t_1 = ((__pyx_v_sequenceLength < __pyx_v_6calign_hash_nucs) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":138
 * 
 *     if sequenceLength < hash_nucs:
 *         return h             # <<<<<<<<<<<<<<
 * 
 *     for i in range(sequenceLength - hash_nucs):
 */
    __pyx_r = __pyx_v_h;
    goto __pyx_L0;
    goto __pyx_L3;
  }
  __pyx_L3:;

  /* "calign.pyx":140
 *         return h
 * 
 *     for i in range(sequenceLength - hash_nucs):             # <<<<<<<<<<<<<<
 *         if i == 0:
 *             hidx = my_hash(seq + i)
 */
  __pyx_t_2 = (__pyx_v_sequenceLength - __pyx_v_6calign_hash_nucs);
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

    /* "calign.pyx":141
 * 
 *     for i in range(sequenceLength - hash_nucs):
 *         if i == 0:             # <<<<<<<<<<<<<<
 *             hidx = my_hash(seq + i)
 *         else:
 */
    __pyx_t_1 = ((__pyx_v_i == 0) != 0);
    if (__pyx_t_1) {

      /* "calign.pyx":142
 *     for i in range(sequenceLength - hash_nucs):
 *         if i == 0:
 *             hidx = my_hash(seq + i)             # <<<<<<<<<<<<<<
 *         else:
 *             hidx = my_hash_update(seq[i + hash_nucs - 1], hidx)
 */
      __pyx_v_hidx = __pyx_f_6calign_my_hash((__pyx_v_seq + __pyx_v_i));
      goto __pyx_L6;
    }
    /*else*/ {

      /* "calign.pyx":144
 *             hidx = my_hash(seq + i)
 *         else:
 *             hidx = my_hash_update(seq[i + hash_nucs - 1], hidx)             # <<<<<<<<<<<<<<
 * 
 *         if h[hidx] != 0:
 */
      __pyx_v_hidx = __pyx_f_6calign_my_hash_update((__pyx_v_seq[((__pyx_v_i + __pyx_v_6calign_hash_nucs) - 1)]), __pyx_v_hidx);
    }
    __pyx_L6:;

    /* "calign.pyx":146
 *             hidx = my_hash_update(seq[i + hash_nucs - 1], hidx)
 * 
 *         if h[hidx] != 0:             # <<<<<<<<<<<<<<
 *             h[hidx] = -1
 *         else:
 */
    __pyx_t_1 = (((__pyx_v_h[__pyx_v_hidx]) != 0) != 0);
    if (__pyx_t_1) {

      /* "calign.pyx":147
 * 
 *         if h[hidx] != 0:
 *             h[hidx] = -1             # <<<<<<<<<<<<<<
 *         else:
 *             h[hidx] = i + 1
 */
      (__pyx_v_h[__pyx_v_hidx]) = -1;
      goto __pyx_L7;
    }
    /*else*/ {

      /* "calign.pyx":149
 *             h[hidx] = -1
 *         else:
 *             h[hidx] = i + 1             # <<<<<<<<<<<<<<
 * 
 *     return h
 */
      (__pyx_v_h[__pyx_v_hidx]) = (__pyx_v_i + 1);
    }
    __pyx_L7:;
  }

  /* "calign.pyx":151
 *             h[hidx] = i + 1
 * 
 *     return h             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
  __pyx_r = __pyx_v_h;
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "calign.pyx":155
 * ###################################################################################################
 * 
 * cdef void hashReadForMapping(cAlignedRead* read) nogil:             # <<<<<<<<<<<<<<
 *     """
 *     Hash the read, and store the hash for use in the mapReadToHaplotype
 */

static void __pyx_f_6calign_hashReadForMapping(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_read) {
  int __pyx_v_i;
  int __pyx_t_1;
  int __pyx_t_2;

  /* "calign.pyx":161
 *     """
 *     cdef int i
 *     read.hash = <short*>(malloc( (read.rlen - hash_nucs)*sizeof(short) ))             # <<<<<<<<<<<<<<
 *     read.hash[0] = my_hash(read.seq)
 * 
 */
  __pyx_v_read->hash = ((short *)malloc(((__pyx_v_read->rlen - __pyx_v_6calign_hash_nucs) * (sizeof(short)))));

  /* "calign.pyx":162
 *     cdef int i
 *     read.hash = <short*>(malloc( (read.rlen - hash_nucs)*sizeof(short) ))
 *     read.hash[0] = my_hash(read.seq)             # <<<<<<<<<<<<<<
 * 
 *     for i in range(1, read.rlen - hash_nucs):
 */
  (__pyx_v_read->hash[0]) = __pyx_f_6calign_my_hash(__pyx_v_read->seq);

  /* "calign.pyx":164
 *     read.hash[0] = my_hash(read.seq)
 * 
 *     for i in range(1, read.rlen - hash_nucs):             # <<<<<<<<<<<<<<
 *         read.hash[i] = my_hash_update(read.seq[i + hash_nucs - 1], read.hash[i - 1])
 * 
 */
  __pyx_t_1 = (__pyx_v_read->rlen - __pyx_v_6calign_hash_nucs);
  for (__pyx_t_2 = 1; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
    __pyx_v_i = __pyx_t_2;

    /* "calign.pyx":165
 * 
 *     for i in range(1, read.rlen - hash_nucs):
 *         read.hash[i] = my_hash_update(read.seq[i + hash_nucs - 1], read.hash[i - 1])             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
    (__pyx_v_read->hash[__pyx_v_i]) = __pyx_f_6calign_my_hash_update((__pyx_v_read->seq[((__pyx_v_i + __pyx_v_6calign_hash_nucs) - 1)]), (__pyx_v_read->hash[(__pyx_v_i - 1)]));
  }

}

/* "calign.pyx":170
 * 
 * # remove 'nogil' when debugging (also in calign.pxd)
 * cdef int mapAndAlignReadToHaplotype(char* read, char* quals, int readStart, int hapStart, int readLen, int hapLen, short* haplotypeHash, short* haplotypeNextArray, short* readHash, char* haplotype, int gapExtend, int nucprior, char* localGapOpen, int* mapCounts, int mapCountsLen, int hapFlank, int doCalculateFlankScore) nogil:             # <<<<<<<<<<<<<<
 * 
 * 
 */

static int __pyx_f_6calign_mapAndAlignReadToHaplotype(char *__pyx_v_read, char *__pyx_v_quals, int __pyx_v_readStart, int __pyx_v_hapStart, int __pyx_v_readLen, int __pyx_v_hapLen, short *__pyx_v_haplotypeHash, short *__pyx_v_haplotypeNextArray, short *__pyx_v_readHash, char *__pyx_v_haplotype, int __pyx_v_gapExtend, int __pyx_v_nucprior, char *__pyx_v_localGapOpen, int *__pyx_v_mapCounts, int __pyx_v_mapCountsLen, int __pyx_v_hapFlank, int __pyx_v_doCalculateFlankScore) {
  int __pyx_v_maxcount;
  int __pyx_v_i;
  int __pyx_v_pos;
  int __pyx_v_hapIdx;
  int __pyx_v_bestMappingPosition;
  int __pyx_v_hapLenForAlignment;
  int __pyx_v_indexOfReadIntoHap;
  int __pyx_v_readStartInHap;
  int __pyx_v_bestScore;
  int __pyx_v_alignScore;
  char *__pyx_v_aln1;
  char *__pyx_v_aln2;
  int __pyx_v_firstpos;
  int __pyx_r;
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_t_6;
  long __pyx_t_7;
  long __pyx_t_8;
  long __pyx_t_9;
  int __pyx_t_10;

  /* "calign.pyx":179
 *     """
 * 
 *     if readLen < hash_nucs:             # <<<<<<<<<<<<<<
 *         return 0 # Don't even bother trying to align really short reads
 * 
 */
  __pyx_t_1 = ((__pyx_v_readLen < __pyx_v_6calign_hash_nucs) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":180
 * 
 *     if readLen < hash_nucs:
 *         return 0 # Don't even bother trying to align really short reads             # <<<<<<<<<<<<<<
 * 
 *     cdef int maxcount = 0
 */
    __pyx_r = 0;
    goto __pyx_L0;
    goto __pyx_L3;
  }
  __pyx_L3:;

  /* "calign.pyx":182
 *         return 0 # Don't even bother trying to align really short reads
 * 
 *     cdef int maxcount = 0             # <<<<<<<<<<<<<<
 *     cdef int i = -1
 *     cdef int pos = -1
 */
  __pyx_v_maxcount = 0;

  /* "calign.pyx":183
 * 
 *     cdef int maxcount = 0
 *     cdef int i = -1             # <<<<<<<<<<<<<<
 *     cdef int pos = -1
 *     cdef int hapIdx = 0
 */
  __pyx_v_i = -1;

  /* "calign.pyx":184
 *     cdef int maxcount = 0
 *     cdef int i = -1
 *     cdef int pos = -1             # <<<<<<<<<<<<<<
 *     cdef int hapIdx = 0
 *     cdef int bestMappingPosition = -1
 */
  __pyx_v_pos = -1;

  /* "calign.pyx":185
 *     cdef int i = -1
 *     cdef int pos = -1
 *     cdef int hapIdx = 0             # <<<<<<<<<<<<<<
 *     cdef int bestMappingPosition = -1
 *     cdef int hapLenForAlignment = 0
 */
  __pyx_v_hapIdx = 0;

  /* "calign.pyx":186
 *     cdef int pos = -1
 *     cdef int hapIdx = 0
 *     cdef int bestMappingPosition = -1             # <<<<<<<<<<<<<<
 *     cdef int hapLenForAlignment = 0
 *     cdef int indexOfReadIntoHap = -1
 */
  __pyx_v_bestMappingPosition = -1;

  /* "calign.pyx":187
 *     cdef int hapIdx = 0
 *     cdef int bestMappingPosition = -1
 *     cdef int hapLenForAlignment = 0             # <<<<<<<<<<<<<<
 *     cdef int indexOfReadIntoHap = -1
 *     cdef int readStartInHap = -1
 */
  __pyx_v_hapLenForAlignment = 0;

  /* "calign.pyx":188
 *     cdef int bestMappingPosition = -1
 *     cdef int hapLenForAlignment = 0
 *     cdef int indexOfReadIntoHap = -1             # <<<<<<<<<<<<<<
 *     cdef int readStartInHap = -1
 *     cdef int bestScore = 1000000
 */
  __pyx_v_indexOfReadIntoHap = -1;

  /* "calign.pyx":189
 *     cdef int hapLenForAlignment = 0
 *     cdef int indexOfReadIntoHap = -1
 *     cdef int readStartInHap = -1             # <<<<<<<<<<<<<<
 *     cdef int bestScore = 1000000
 *     cdef int alignScore = 1000000
 */
  __pyx_v_readStartInHap = -1;

  /* "calign.pyx":190
 *     cdef int indexOfReadIntoHap = -1
 *     cdef int readStartInHap = -1
 *     cdef int bestScore = 1000000             # <<<<<<<<<<<<<<
 *     cdef int alignScore = 1000000
 *     cdef char* aln1 = NULL
 */
  __pyx_v_bestScore = 1000000;

  /* "calign.pyx":191
 *     cdef int readStartInHap = -1
 *     cdef int bestScore = 1000000
 *     cdef int alignScore = 1000000             # <<<<<<<<<<<<<<
 *     cdef char* aln1 = NULL
 *     cdef char* aln2 = NULL
 */
  __pyx_v_alignScore = 1000000;

  /* "calign.pyx":192
 *     cdef int bestScore = 1000000
 *     cdef int alignScore = 1000000
 *     cdef char* aln1 = NULL             # <<<<<<<<<<<<<<
 *     cdef char* aln2 = NULL
 *     cdef int firstpos = 0
 */
  __pyx_v_aln1 = NULL;

  /* "calign.pyx":193
 *     cdef int alignScore = 1000000
 *     cdef char* aln1 = NULL
 *     cdef char* aln2 = NULL             # <<<<<<<<<<<<<<
 *     cdef int firstpos = 0
 * 
 */
  __pyx_v_aln2 = NULL;

  /* "calign.pyx":194
 *     cdef char* aln1 = NULL
 *     cdef char* aln2 = NULL
 *     cdef int firstpos = 0             # <<<<<<<<<<<<<<
 * 
 *     if strncmp(read, haplotype + indexOfReadIntoHap, readLen) == 0:
 */
  __pyx_v_firstpos = 0;

  /* "calign.pyx":196
 *     cdef int firstpos = 0
 * 
 *     if strncmp(read, haplotype + indexOfReadIntoHap, readLen) == 0:             # <<<<<<<<<<<<<<
 *         return 0
 * 
 */
  __pyx_t_1 = ((strncmp(__pyx_v_read, (__pyx_v_haplotype + __pyx_v_indexOfReadIntoHap), __pyx_v_readLen) == 0) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":197
 * 
 *     if strncmp(read, haplotype + indexOfReadIntoHap, readLen) == 0:
 *         return 0             # <<<<<<<<<<<<<<
 * 
 *     if hapFlank > 0:
 */
    __pyx_r = 0;
    goto __pyx_L0;
    goto __pyx_L4;
  }
  __pyx_L4:;

  /* "calign.pyx":199
 *         return 0
 * 
 *     if hapFlank > 0:             # <<<<<<<<<<<<<<
 *         # avoid allocating memory if there's no flank; this also stops the aligner from doing the backtrace
 *         aln1 = <char*>malloc(sizeof(char) * (2 * readLen + 16))
 */
  __pyx_t_1 = ((__pyx_v_hapFlank > 0) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":201
 *     if hapFlank > 0:
 *         # avoid allocating memory if there's no flank; this also stops the aligner from doing the backtrace
 *         aln1 = <char*>malloc(sizeof(char) * (2 * readLen + 16))             # <<<<<<<<<<<<<<
 *         aln2 = <char*>malloc(sizeof(char) * (2 * readLen + 16))
 * 
 */
    __pyx_v_aln1 = ((char *)malloc(((sizeof(char)) * ((2 * __pyx_v_readLen) + 16))));

    /* "calign.pyx":202
 *         # avoid allocating memory if there's no flank; this also stops the aligner from doing the backtrace
 *         aln1 = <char*>malloc(sizeof(char) * (2 * readLen + 16))
 *         aln2 = <char*>malloc(sizeof(char) * (2 * readLen + 16))             # <<<<<<<<<<<<<<
 * 
 *     indexOfReadIntoHap = readStart - hapStart
 */
    __pyx_v_aln2 = ((char *)malloc(((sizeof(char)) * ((2 * __pyx_v_readLen) + 16))));
    goto __pyx_L5;
  }
  __pyx_L5:;

  /* "calign.pyx":204
 *         aln2 = <char*>malloc(sizeof(char) * (2 * readLen + 16))
 * 
 *     indexOfReadIntoHap = readStart - hapStart             # <<<<<<<<<<<<<<
 * 
 *     memset(mapCounts, 0, sizeof(int) * mapCountsLen) # Reset counts
 */
  __pyx_v_indexOfReadIntoHap = (__pyx_v_readStart - __pyx_v_hapStart);

  /* "calign.pyx":206
 *     indexOfReadIntoHap = readStart - hapStart
 * 
 *     memset(mapCounts, 0, sizeof(int) * mapCountsLen) # Reset counts             # <<<<<<<<<<<<<<
 * 
 *     # Do the mapping.
 */
  memset(__pyx_v_mapCounts, 0, ((sizeof(int)) * __pyx_v_mapCountsLen));

  /* "calign.pyx":209
 * 
 *     # Do the mapping.
 *     for i in range(readLen - hash_nucs):             # <<<<<<<<<<<<<<
 *         hapIdx = haplotypeHash[readHash[i]]
 * 
 */
  __pyx_t_2 = (__pyx_v_readLen - __pyx_v_6calign_hash_nucs);
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

    /* "calign.pyx":210
 *     # Do the mapping.
 *     for i in range(readLen - hash_nucs):
 *         hapIdx = haplotypeHash[readHash[i]]             # <<<<<<<<<<<<<<
 * 
 *         while hapIdx != 0:
 */
    __pyx_v_hapIdx = (__pyx_v_haplotypeHash[(__pyx_v_readHash[__pyx_v_i])]);

    /* "calign.pyx":212
 *         hapIdx = haplotypeHash[readHash[i]]
 * 
 *         while hapIdx != 0:             # <<<<<<<<<<<<<<
 *             pos = hapIdx - i - 1 # account for index into read
 * 
 */
    while (1) {
      __pyx_t_1 = ((__pyx_v_hapIdx != 0) != 0);
      if (!__pyx_t_1) break;

      /* "calign.pyx":213
 * 
 *         while hapIdx != 0:
 *             pos = hapIdx - i - 1 # account for index into read             # <<<<<<<<<<<<<<
 * 
 *             mapCounts[pos + readLen] += 1
 */
      __pyx_v_pos = ((__pyx_v_hapIdx - __pyx_v_i) - 1);

      /* "calign.pyx":215
 *             pos = hapIdx - i - 1 # account for index into read
 * 
 *             mapCounts[pos + readLen] += 1             # <<<<<<<<<<<<<<
 * 
 *             if mapCounts[pos + readLen] > maxcount:
 */
      __pyx_t_4 = (__pyx_v_pos + __pyx_v_readLen);
      (__pyx_v_mapCounts[__pyx_t_4]) = ((__pyx_v_mapCounts[__pyx_t_4]) + 1);

      /* "calign.pyx":217
 *             mapCounts[pos + readLen] += 1
 * 
 *             if mapCounts[pos + readLen] > maxcount:             # <<<<<<<<<<<<<<
 *                 maxcount = mapCounts[pos + readLen]
 * 
 */
      __pyx_t_1 = (((__pyx_v_mapCounts[(__pyx_v_pos + __pyx_v_readLen)]) > __pyx_v_maxcount) != 0);
      if (__pyx_t_1) {

        /* "calign.pyx":218
 * 
 *             if mapCounts[pos + readLen] > maxcount:
 *                 maxcount = mapCounts[pos + readLen]             # <<<<<<<<<<<<<<
 * 
 *             hapIdx = haplotypeNextArray[hapIdx] # move to next hash hit
 */
        __pyx_v_maxcount = (__pyx_v_mapCounts[(__pyx_v_pos + __pyx_v_readLen)]);
        goto __pyx_L10;
      }
      __pyx_L10:;

      /* "calign.pyx":220
 *                 maxcount = mapCounts[pos + readLen]
 * 
 *             hapIdx = haplotypeNextArray[hapIdx] # move to next hash hit             # <<<<<<<<<<<<<<
 * 
 *     if maxcount > 0:
 */
      __pyx_v_hapIdx = (__pyx_v_haplotypeNextArray[__pyx_v_hapIdx]);
    }
  }

  /* "calign.pyx":222
 *             hapIdx = haplotypeNextArray[hapIdx] # move to next hash hit
 * 
 *     if maxcount > 0:             # <<<<<<<<<<<<<<
 *         for i in range(hapLen + readLen):
 *             if mapCounts[i] == maxcount:
 */
  __pyx_t_1 = ((__pyx_v_maxcount > 0) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":223
 * 
 *     if maxcount > 0:
 *         for i in range(hapLen + readLen):             # <<<<<<<<<<<<<<
 *             if mapCounts[i] == maxcount:
 *                 indexOfReadIntoHap = i - readLen
 */
    __pyx_t_2 = (__pyx_v_hapLen + __pyx_v_readLen);
    for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
      __pyx_v_i = __pyx_t_3;

      /* "calign.pyx":224
 *     if maxcount > 0:
 *         for i in range(hapLen + readLen):
 *             if mapCounts[i] == maxcount:             # <<<<<<<<<<<<<<
 *                 indexOfReadIntoHap = i - readLen
 * 
 */
      __pyx_t_1 = (((__pyx_v_mapCounts[__pyx_v_i]) == __pyx_v_maxcount) != 0);
      if (__pyx_t_1) {

        /* "calign.pyx":225
 *         for i in range(hapLen + readLen):
 *             if mapCounts[i] == maxcount:
 *                 indexOfReadIntoHap = i - readLen             # <<<<<<<<<<<<<<
 * 
 *                 # Align read around this position. Make sure we can't go off the end.
 */
        __pyx_v_indexOfReadIntoHap = (__pyx_v_i - __pyx_v_readLen);

        /* "calign.pyx":228
 * 
 *                 # Align read around this position. Make sure we can't go off the end.
 *                 if indexOfReadIntoHap >= -readLen and (indexOfReadIntoHap + readLen + 15 < hapLen):             # <<<<<<<<<<<<<<
 *                     readStartInHap     = max(0, indexOfReadIntoHap - 8)
 *                     hapLenForAlignment = readLen + 15 # This is fixed by the alignment algorithm
 */
        __pyx_t_1 = ((__pyx_v_indexOfReadIntoHap >= (-__pyx_v_readLen)) != 0);
        if (__pyx_t_1) {
          __pyx_t_5 = ((((__pyx_v_indexOfReadIntoHap + __pyx_v_readLen) + 15) < __pyx_v_hapLen) != 0);
          __pyx_t_6 = __pyx_t_5;
        } else {
          __pyx_t_6 = __pyx_t_1;
        }
        if (__pyx_t_6) {

          /* "calign.pyx":229
 *                 # Align read around this position. Make sure we can't go off the end.
 *                 if indexOfReadIntoHap >= -readLen and (indexOfReadIntoHap + readLen + 15 < hapLen):
 *                     readStartInHap     = max(0, indexOfReadIntoHap - 8)             # <<<<<<<<<<<<<<
 *                     hapLenForAlignment = readLen + 15 # This is fixed by the alignment algorithm
 * 
 */
          __pyx_t_7 = (__pyx_v_indexOfReadIntoHap - 8);
          __pyx_t_8 = 0;
          if (((__pyx_t_7 > __pyx_t_8) != 0)) {
            __pyx_t_9 = __pyx_t_7;
          } else {
            __pyx_t_9 = __pyx_t_8;
          }
          __pyx_v_readStartInHap = __pyx_t_9;

          /* "calign.pyx":230
 *                 if indexOfReadIntoHap >= -readLen and (indexOfReadIntoHap + readLen + 15 < hapLen):
 *                     readStartInHap     = max(0, indexOfReadIntoHap - 8)
 *                     hapLenForAlignment = readLen + 15 # This is fixed by the alignment algorithm             # <<<<<<<<<<<<<<
 * 
 *                     alignScore = fastAlignmentRoutine(haplotype + readStartInHap, read, quals, hapLenForAlignment, readLen,
 */
          __pyx_v_hapLenForAlignment = (__pyx_v_readLen + 15);

          /* "calign.pyx":233
 * 
 *                     alignScore = fastAlignmentRoutine(haplotype + readStartInHap, read, quals, hapLenForAlignment, readLen,
 *                                                       gapExtend, nucprior, localGapOpen + readStartInHap, aln1, aln2, &firstpos)             # <<<<<<<<<<<<<<
 * 
 *                     if doCalculateFlankScore == 1 and alignScore > 0 and hapFlank > 0:
 */
          __pyx_v_alignScore = fastAlignmentRoutine((__pyx_v_haplotype + __pyx_v_readStartInHap), __pyx_v_read, __pyx_v_quals, __pyx_v_hapLenForAlignment, __pyx_v_readLen, __pyx_v_gapExtend, __pyx_v_nucprior, (__pyx_v_localGapOpen + __pyx_v_readStartInHap), __pyx_v_aln1, __pyx_v_aln2, (&__pyx_v_firstpos));

          /* "calign.pyx":235
 *                                                       gapExtend, nucprior, localGapOpen + readStartInHap, aln1, aln2, &firstpos)
 * 
 *                     if doCalculateFlankScore == 1 and alignScore > 0 and hapFlank > 0:             # <<<<<<<<<<<<<<
 *                         alignScore -= calculateFlankScore(hapLen, hapFlank, quals, localGapOpen, gapExtend, nucprior,
 *                                                           firstpos + readStartInHap, aln1, aln2)
 */
          __pyx_t_6 = ((__pyx_v_doCalculateFlankScore == 1) != 0);
          if (__pyx_t_6) {
            __pyx_t_1 = ((__pyx_v_alignScore > 0) != 0);
            if (__pyx_t_1) {
              __pyx_t_5 = ((__pyx_v_hapFlank > 0) != 0);
              __pyx_t_10 = __pyx_t_5;
            } else {
              __pyx_t_10 = __pyx_t_1;
            }
            __pyx_t_1 = __pyx_t_10;
          } else {
            __pyx_t_1 = __pyx_t_6;
          }
          if (__pyx_t_1) {

            /* "calign.pyx":237
 *                     if doCalculateFlankScore == 1 and alignScore > 0 and hapFlank > 0:
 *                         alignScore -= calculateFlankScore(hapLen, hapFlank, quals, localGapOpen, gapExtend, nucprior,
 *                                                           firstpos + readStartInHap, aln1, aln2)             # <<<<<<<<<<<<<<
 * 
 *                     if alignScore < bestScore:
 */
            __pyx_v_alignScore = (__pyx_v_alignScore - calculateFlankScore(__pyx_v_hapLen, __pyx_v_hapFlank, __pyx_v_quals, __pyx_v_localGapOpen, __pyx_v_gapExtend, __pyx_v_nucprior, (__pyx_v_firstpos + __pyx_v_readStartInHap), __pyx_v_aln1, __pyx_v_aln2));
            goto __pyx_L16;
          }
          __pyx_L16:;

          /* "calign.pyx":239
 *                                                           firstpos + readStartInHap, aln1, aln2)
 * 
 *                     if alignScore < bestScore:             # <<<<<<<<<<<<<<
 *                         bestScore           = alignScore
 *                         bestMappingPosition = indexOfReadIntoHap
 */
          __pyx_t_1 = ((__pyx_v_alignScore < __pyx_v_bestScore) != 0);
          if (__pyx_t_1) {

            /* "calign.pyx":240
 * 
 *                     if alignScore < bestScore:
 *                         bestScore           = alignScore             # <<<<<<<<<<<<<<
 *                         bestMappingPosition = indexOfReadIntoHap
 * 
 */
            __pyx_v_bestScore = __pyx_v_alignScore;

            /* "calign.pyx":241
 *                     if alignScore < bestScore:
 *                         bestScore           = alignScore
 *                         bestMappingPosition = indexOfReadIntoHap             # <<<<<<<<<<<<<<
 * 
 *                         if bestScore == 0:
 */
            __pyx_v_bestMappingPosition = __pyx_v_indexOfReadIntoHap;

            /* "calign.pyx":243
 *                         bestMappingPosition = indexOfReadIntoHap
 * 
 *                         if bestScore == 0:             # <<<<<<<<<<<<<<
 *                             if hapFlank > 0:
 *                                 free (aln1)
 */
            __pyx_t_1 = ((__pyx_v_bestScore == 0) != 0);
            if (__pyx_t_1) {

              /* "calign.pyx":244
 * 
 *                         if bestScore == 0:
 *                             if hapFlank > 0:             # <<<<<<<<<<<<<<
 *                                 free (aln1)
 *                                 free (aln2)
 */
              __pyx_t_1 = ((__pyx_v_hapFlank > 0) != 0);
              if (__pyx_t_1) {

                /* "calign.pyx":245
 *                         if bestScore == 0:
 *                             if hapFlank > 0:
 *                                 free (aln1)             # <<<<<<<<<<<<<<
 *                                 free (aln2)
 *                             return bestScore # Short-circuit this loop if we find an exact match
 */
                free(__pyx_v_aln1);

                /* "calign.pyx":246
 *                             if hapFlank > 0:
 *                                 free (aln1)
 *                                 free (aln2)             # <<<<<<<<<<<<<<
 *                             return bestScore # Short-circuit this loop if we find an exact match
 * 
 */
                free(__pyx_v_aln2);
                goto __pyx_L19;
              }
              __pyx_L19:;

              /* "calign.pyx":247
 *                                 free (aln1)
 *                                 free (aln2)
 *                             return bestScore # Short-circuit this loop if we find an exact match             # <<<<<<<<<<<<<<
 * 
 *     # Now try original mapping position. If the read is past the end of the haplotype then
 */
              __pyx_r = __pyx_v_bestScore;
              goto __pyx_L0;
              goto __pyx_L18;
            }
            __pyx_L18:;
            goto __pyx_L17;
          }
          __pyx_L17:;
          goto __pyx_L15;
        }
        __pyx_L15:;
        goto __pyx_L14;
      }
      __pyx_L14:;
    }
    goto __pyx_L11;
  }
  __pyx_L11:;

  /* "calign.pyx":252
 *     # don't allow the algorithm to align off the end of the haplotype. This will only happen in the case
 *     # of very large deletions.
 *     indexOfReadIntoHap = min(readStart - hapStart, hapLen - readLen - 15)             # <<<<<<<<<<<<<<
 * 
 *     # Only try this if the mapper hasn't already found this position
 */
  __pyx_t_9 = ((__pyx_v_hapLen - __pyx_v_readLen) - 15);
  __pyx_t_2 = (__pyx_v_readStart - __pyx_v_hapStart);
  if (((__pyx_t_9 < __pyx_t_2) != 0)) {
    __pyx_t_7 = __pyx_t_9;
  } else {
    __pyx_t_7 = __pyx_t_2;
  }
  __pyx_v_indexOfReadIntoHap = __pyx_t_7;

  /* "calign.pyx":255
 * 
 *     # Only try this if the mapper hasn't already found this position
 *     if indexOfReadIntoHap != bestMappingPosition:             # <<<<<<<<<<<<<<
 *         readStartInHap = max(0, indexOfReadIntoHap - 8)
 * 
 */
  __pyx_t_1 = ((__pyx_v_indexOfReadIntoHap != __pyx_v_bestMappingPosition) != 0);
  if (__pyx_t_1) {

    /* "calign.pyx":256
 *     # Only try this if the mapper hasn't already found this position
 *     if indexOfReadIntoHap != bestMappingPosition:
 *         readStartInHap = max(0, indexOfReadIntoHap - 8)             # <<<<<<<<<<<<<<
 * 
 *         alignScore = fastAlignmentRoutine(haplotype + readStartInHap, read, quals, readLen + 15, readLen,
 */
    __pyx_t_7 = (__pyx_v_indexOfReadIntoHap - 8);
    __pyx_t_9 = 0;
    if (((__pyx_t_7 > __pyx_t_9) != 0)) {
      __pyx_t_8 = __pyx_t_7;
    } else {
      __pyx_t_8 = __pyx_t_9;
    }
    __pyx_v_readStartInHap = __pyx_t_8;

    /* "calign.pyx":259
 * 
 *         alignScore = fastAlignmentRoutine(haplotype + readStartInHap, read, quals, readLen + 15, readLen,
 *                                           gapExtend, nucprior, localGapOpen + readStartInHap, aln1, aln2, &firstpos)             # <<<<<<<<<<<<<<
 * 
 *         if doCalculateFlankScore == 1 and alignScore > 0 and hapLen > 0:
 */
    __pyx_v_alignScore = fastAlignmentRoutine((__pyx_v_haplotype + __pyx_v_readStartInHap), __pyx_v_read, __pyx_v_quals, (__pyx_v_readLen + 15), __pyx_v_readLen, __pyx_v_gapExtend, __pyx_v_nucprior, (__pyx_v_localGapOpen + __pyx_v_readStartInHap), __pyx_v_aln1, __pyx_v_aln2, (&__pyx_v_firstpos));

    /* "calign.pyx":261
 *                                           gapExtend, nucprior, localGapOpen + readStartInHap, aln1, aln2, &firstpos)
 * 
 *         if doCalculateFlankScore == 1 and alignScore > 0 and hapLen > 0:             # <<<<<<<<<<<<<<
 *             alignScore -= calculateFlankScore(hapLen, hapFlank, quals, localGapOpen, gapExtend, nucprior,
 *                                               firstpos + readStartInHap, aln1, aln2)
 */
    __pyx_t_1 = ((__pyx_v_doCalculateFlankScore == 1) != 0);
    if (__pyx_t_1) {
      __pyx_t_6 = ((__pyx_v_alignScore > 0) != 0);
      if (__pyx_t_6) {
        __pyx_t_10 = ((__pyx_v_hapLen > 0) != 0);
        __pyx_t_5 = __pyx_t_10;
      } else {
        __pyx_t_5 = __pyx_t_6;
      }
      __pyx_t_6 = __pyx_t_5;
    } else {
      __pyx_t_6 = __pyx_t_1;
    }
    if (__pyx_t_6) {

      /* "calign.pyx":263
 *         if doCalculateFlankScore == 1 and alignScore > 0 and hapLen > 0:
 *             alignScore -= calculateFlankScore(hapLen, hapFlank, quals, localGapOpen, gapExtend, nucprior,
 *                                               firstpos + readStartInHap, aln1, aln2)             # <<<<<<<<<<<<<<
 * 
 *         if alignScore < bestScore:
 */
      __pyx_v_alignScore = (__pyx_v_alignScore - calculateFlankScore(__pyx_v_hapLen, __pyx_v_hapFlank, __pyx_v_quals, __pyx_v_localGapOpen, __pyx_v_gapExtend, __pyx_v_nucprior, (__pyx_v_firstpos + __pyx_v_readStartInHap), __pyx_v_aln1, __pyx_v_aln2));
      goto __pyx_L21;
    }
    __pyx_L21:;

    /* "calign.pyx":265
 *                                               firstpos + readStartInHap, aln1, aln2)
 * 
 *         if alignScore < bestScore:             # <<<<<<<<<<<<<<
 *             bestScore           = alignScore
 *             bestMappingPosition = indexOfReadIntoHap
 */
    __pyx_t_6 = ((__pyx_v_alignScore < __pyx_v_bestScore) != 0);
    if (__pyx_t_6) {

      /* "calign.pyx":266
 * 
 *         if alignScore < bestScore:
 *             bestScore           = alignScore             # <<<<<<<<<<<<<<
 *             bestMappingPosition = indexOfReadIntoHap
 * 
 */
      __pyx_v_bestScore = __pyx_v_alignScore;

      /* "calign.pyx":267
 *         if alignScore < bestScore:
 *             bestScore           = alignScore
 *             bestMappingPosition = indexOfReadIntoHap             # <<<<<<<<<<<<<<
 * 
 *     free(aln1)
 */
      __pyx_v_bestMappingPosition = __pyx_v_indexOfReadIntoHap;
      goto __pyx_L22;
    }
    __pyx_L22:;
    goto __pyx_L20;
  }
  __pyx_L20:;

  /* "calign.pyx":269
 *             bestMappingPosition = indexOfReadIntoHap
 * 
 *     free(aln1)             # <<<<<<<<<<<<<<
 *     free(aln2)
 * 
 */
  free(__pyx_v_aln1);

  /* "calign.pyx":270
 * 
 *     free(aln1)
 *     free(aln2)             # <<<<<<<<<<<<<<
 * 
 *     return bestScore
 */
  free(__pyx_v_aln2);

  /* "calign.pyx":272
 *     free(aln2)
 * 
 *     return bestScore             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
  __pyx_r = __pyx_v_bestScore;
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":250
 * 
 * # And here are accessor functions for the bit-fields
 * cdef inline int Read_IsReverse(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FREVERSE) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsReverse(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":251
 * # And here are accessor functions for the bit-fields
 * cdef inline int Read_IsReverse(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FREVERSE) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsPaired(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 16) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":253
 *     return ( (theRead.bitFlag & BAM_FREVERSE) != 0)
 * 
 * cdef inline int Read_IsPaired(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FPAIRED) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsPaired(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":254
 * 
 * cdef inline int Read_IsPaired(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FPAIRED) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsProperPair(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 1) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":256
 *     return ( (theRead.bitFlag & BAM_FPAIRED) != 0)
 * 
 * cdef inline int Read_IsProperPair(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FPROPER_PAIR) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsProperPair(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":257
 * 
 * cdef inline int Read_IsProperPair(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FPROPER_PAIR) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsDuplicate(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 2) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":259
 *     return ( (theRead.bitFlag & BAM_FPROPER_PAIR) != 0)
 * 
 * cdef inline int Read_IsDuplicate(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FDUP) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsDuplicate(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":260
 * 
 * cdef inline int Read_IsDuplicate(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FDUP) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsUnmapped(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 1024) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":262
 *     return ( (theRead.bitFlag & BAM_FDUP) != 0)
 * 
 * cdef inline int Read_IsUnmapped(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FUNMAP) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsUnmapped(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":263
 * 
 * cdef inline int Read_IsUnmapped(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FUNMAP) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_MateIsUnmapped(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 4) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":265
 *     return ( (theRead.bitFlag & BAM_FUNMAP) != 0)
 * 
 * cdef inline int Read_MateIsUnmapped(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FMUNMAP) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_MateIsUnmapped(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":266
 * 
 * cdef inline int Read_MateIsUnmapped(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FMUNMAP) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_MateIsReverse(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 8) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":268
 *     return ( (theRead.bitFlag & BAM_FMUNMAP) != 0)
 * 
 * cdef inline int Read_MateIsReverse(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FMREVERSE) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_MateIsReverse(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":269
 * 
 * cdef inline int Read_MateIsReverse(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FMREVERSE) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsQCFail(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 32) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":271
 *     return ( (theRead.bitFlag & BAM_FMREVERSE) != 0)
 * 
 * cdef inline int Read_IsQCFail(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FQCFAIL) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsQCFail(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":272
 * 
 * cdef inline int Read_IsQCFail(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FQCFAIL) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsReadOne(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 512) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":274
 *     return ( (theRead.bitFlag & BAM_FQCFAIL) != 0)
 * 
 * cdef inline int Read_IsReadOne(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FREAD1) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsReadOne(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":275
 * 
 * cdef inline int Read_IsReadOne(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FREAD1) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsSecondaryAlignment(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 64) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":277
 *     return ( (theRead.bitFlag & BAM_FREAD1) != 0)
 * 
 * cdef inline int Read_IsSecondaryAlignment(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FSECONDARY) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsSecondaryAlignment(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":278
 * 
 * cdef inline int Read_IsSecondaryAlignment(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FSECONDARY) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_IsCompressed(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 256) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":280
 *     return ( (theRead.bitFlag & BAM_FSECONDARY) != 0)
 * 
 * cdef inline int Read_IsCompressed(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     return ( (theRead.bitFlag & BAM_FCOMPRESSED) != 0)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_IsCompressed(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":281
 * 
 * cdef inline int Read_IsCompressed(cAlignedRead* theRead) nogil:
 *     return ( (theRead.bitFlag & BAM_FCOMPRESSED) != 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_SetIsNotReverse(cAlignedRead* theRead) nogil:
 */
  __pyx_r = ((__pyx_v_theRead->bitFlag & 2048) != 0);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

/* "htslibWrapper.pxd":283
 *     return ( (theRead.bitFlag & BAM_FCOMPRESSED) != 0)
 * 
 * cdef inline int Read_SetIsNotReverse(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag &= (~BAM_FREVERSE)
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_SetIsNotReverse(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":284
 * 
 * cdef inline int Read_SetIsNotReverse(cAlignedRead* theRead) nogil:
 *     theRead.bitFlag &= (~BAM_FREVERSE)             # <<<<<<<<<<<<<<
 * 
 * cdef inline int Read_SetIsReverse(cAlignedRead* theRead) nogil:
 */
  __pyx_v_theRead->bitFlag = (__pyx_v_theRead->bitFlag & (~16));

  __pyx_r = 0;
  return __pyx_r;
}

/* "htslibWrapper.pxd":286
 *     theRead.bitFlag &= (~BAM_FREVERSE)
 * 
 * cdef inline int Read_SetIsReverse(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag |= BAM_FREVERSE
 * 
 */

static CYTHON_INLINE int __pyx_f_13htslibWrapper_Read_SetIsReverse(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {
  int __pyx_r;

  /* "htslibWrapper.pxd":287
 * 
 * cdef inline int Read_SetIsReverse(cAlignedRead* theRead) nogil:
 *     theRead.bitFlag |= BAM_FREVERSE             # <<<<<<<<<<<<<<
 * 
 * cdef inline void Read_SetQCFail(cAlignedRead* theRead) nogil:
 */
  __pyx_v_theRead->bitFlag = (__pyx_v_theRead->bitFlag | 16);

  __pyx_r = 0;
  return __pyx_r;
}

/* "htslibWrapper.pxd":289
 *     theRead.bitFlag |= BAM_FREVERSE
 * 
 * cdef inline void Read_SetQCFail(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag |= BAM_FQCFAIL
 * 
 */

static CYTHON_INLINE void __pyx_f_13htslibWrapper_Read_SetQCFail(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {

  /* "htslibWrapper.pxd":290
 * 
 * cdef inline void Read_SetQCFail(cAlignedRead* theRead) nogil:
 *     theRead.bitFlag |= BAM_FQCFAIL             # <<<<<<<<<<<<<<
 * 
 * cdef inline void Read_SetCompressed(cAlignedRead* theRead) nogil:
 */
  __pyx_v_theRead->bitFlag = (__pyx_v_theRead->bitFlag | 512);

}

/* "htslibWrapper.pxd":292
 *     theRead.bitFlag |= BAM_FQCFAIL
 * 
 * cdef inline void Read_SetCompressed(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag |= BAM_FCOMPRESSED
 * 
 */

static CYTHON_INLINE void __pyx_f_13htslibWrapper_Read_SetCompressed(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {

  /* "htslibWrapper.pxd":293
 * 
 * cdef inline void Read_SetCompressed(cAlignedRead* theRead) nogil:
 *     theRead.bitFlag |= BAM_FCOMPRESSED             # <<<<<<<<<<<<<<
 * 
 * cdef inline void Read_SetUnCompressed(cAlignedRead* theRead) nogil:
 */
  __pyx_v_theRead->bitFlag = (__pyx_v_theRead->bitFlag | 2048);

}

/* "htslibWrapper.pxd":295
 *     theRead.bitFlag |= BAM_FCOMPRESSED
 * 
 * cdef inline void Read_SetUnCompressed(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag &= (~BAM_FCOMPRESSED)
 * 
 */

static CYTHON_INLINE void __pyx_f_13htslibWrapper_Read_SetUnCompressed(__pyx_t_13htslibWrapper_cAlignedRead *__pyx_v_theRead) {

  /* "htslibWrapper.pxd":296
 * 
 * cdef inline void Read_SetUnCompressed(cAlignedRead* theRead) nogil:
 *     theRead.bitFlag &= (~BAM_FCOMPRESSED)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_v_theRead->bitFlag = (__pyx_v_theRead->bitFlag & (~2048));

}

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef __pyx_moduledef = {
  #if PY_VERSION_HEX < 0x03020000
    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
  #else
    PyModuleDef_HEAD_INIT,
  #endif
    __Pyx_NAMESTR("calign"),
    __Pyx_DOCSTR(__pyx_k_1), /* m_doc */
    -1, /* m_size */
    __pyx_methods /* m_methods */,
    NULL, /* m_reload */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_n_s____import__, __pyx_k____import__, sizeof(__pyx_k____import__), 0, 0, 1, 1},
  {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1},
  {&__pyx_n_s____pyx_capi__, __pyx_k____pyx_capi__, sizeof(__pyx_k____pyx_capi__), 0, 0, 1, 1},
  {&__pyx_n_s____pyx_vtable__, __pyx_k____pyx_vtable__, sizeof(__pyx_k____pyx_vtable__), 0, 0, 1, 1},
  {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1},
  {&__pyx_n_s__hash_nucs, __pyx_k__hash_nucs, sizeof(__pyx_k__hash_nucs), 0, 0, 1, 1},
  {&__pyx_n_s__hash_size, __pyx_k__hash_size, sizeof(__pyx_k__hash_size), 0, 0, 1, 1},
  {&__pyx_n_s__htslibWrapper, __pyx_k__htslibWrapper, sizeof(__pyx_k__htslibWrapper), 0, 0, 1, 1},
  {&__pyx_n_s__logging, __pyx_k__logging, sizeof(__pyx_k__logging), 0, 0, 1, 1},
  {&__pyx_n_s__max_sequence_length, __pyx_k__max_sequence_length, sizeof(__pyx_k__max_sequence_length), 0, 0, 1, 1},
  {&__pyx_n_s__range, __pyx_k__range, sizeof(__pyx_k__range), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s__range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
  return 0;
  __pyx_L1_error:;
  return -1;
}

#if PY_MAJOR_VERSION < 3
PyMODINIT_FUNC initcalign(void); /*proto*/
PyMODINIT_FUNC initcalign(void)
#else
PyMODINIT_FUNC PyInit_calign(void); /*proto*/
PyMODINIT_FUNC PyInit_calign(void)
#endif
{
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannyDeclarations
  #if CYTHON_REFNANNY
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
  if (!__Pyx_RefNanny) {
      PyErr_Clear();
      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
      if (!__Pyx_RefNanny)
          Py_FatalError("failed to import 'refnanny' module");
  }
  #endif
  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_calign(void)", 0);
  if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #ifdef __Pyx_CyFunction_USED
  if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  #ifdef WITH_THREAD /* Python build with threading support? */
  PyEval_InitThreads();
  #endif
  #endif
  /*--- Module creation code ---*/
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4(__Pyx_NAMESTR("calign"), __pyx_methods, __Pyx_DOCSTR(__pyx_k_1), 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  Py_INCREF(__pyx_d);
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
    if (!PyDict_GetItemString(modules, "calign")) {
      if (unlikely(PyDict_SetItemString(modules, "calign", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
    }
  }
  #endif
  __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #if CYTHON_COMPILING_IN_PYPY
  Py_INCREF(__pyx_b);
  #endif
  if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
  /*--- Initialize various global constants etc. ---*/
  if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  #endif
  if (__pyx_module_is_main_calign) {
    if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
  }
  /*--- Builtin init code ---*/
  if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Constants init code ---*/
  if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Global init code ---*/
  /*--- Variable export code ---*/
  if (__Pyx_ExportVoidPtr(__pyx_n_s__hash_nucs, (void *)&__pyx_v_6calign_hash_nucs, "int") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  if (__Pyx_ExportVoidPtr(__pyx_n_s__hash_size, (void *)&__pyx_v_6calign_hash_size, "int") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  if (__Pyx_ExportVoidPtr(__pyx_n_s__max_sequence_length, (void *)&__pyx_v_6calign_max_sequence_length, "int") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Function export code ---*/
  if (__Pyx_ExportFunction("hash_sequence", (void (*)(void))__pyx_f_6calign_hash_sequence, "short *(char *, int)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  if (__Pyx_ExportFunction("hash_sequence_multihit", (void (*)(void))__pyx_f_6calign_hash_sequence_multihit, "void (char *, int, short **, short **)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  if (__Pyx_ExportFunction("mapAndAlignReadToHaplotype", (void (*)(void))__pyx_f_6calign_mapAndAlignReadToHaplotype, "int (char *, char *, int, int, int, int, short *, short *, short *, char *, int, int, char *, int *, int, int, int)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  if (__Pyx_ExportFunction("hashReadForMapping", (void (*)(void))__pyx_f_6calign_hashReadForMapping, "void (__pyx_t_13htslibWrapper_cAlignedRead *)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Type init code ---*/
  /*--- Type import code ---*/
  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
  #if CYTHON_COMPILING_IN_PYPY
  sizeof(PyTypeObject),
  #else
  sizeof(PyHeapTypeObject),
  #endif
  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_ptype_13htslibWrapper_Samfile = __Pyx_ImportType("htslibWrapper", "Samfile", sizeof(struct __pyx_obj_13htslibWrapper_Samfile), 1); if (unlikely(!__pyx_ptype_13htslibWrapper_Samfile)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_vtabptr_13htslibWrapper_Samfile = (struct __pyx_vtabstruct_13htslibWrapper_Samfile*)__Pyx_GetVtable(__pyx_ptype_13htslibWrapper_Samfile->tp_dict); if (unlikely(!__pyx_vtabptr_13htslibWrapper_Samfile)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_ptype_13htslibWrapper_ReadIterator = __Pyx_ImportType("htslibWrapper", "ReadIterator", sizeof(struct __pyx_obj_13htslibWrapper_ReadIterator), 1); if (unlikely(!__pyx_ptype_13htslibWrapper_ReadIterator)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_vtabptr_13htslibWrapper_ReadIterator = (struct __pyx_vtabstruct_13htslibWrapper_ReadIterator*)__Pyx_GetVtable(__pyx_ptype_13htslibWrapper_ReadIterator->tp_dict); if (unlikely(!__pyx_vtabptr_13htslibWrapper_ReadIterator)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Variable import code ---*/
  /*--- Function import code ---*/
  /*--- Execution code ---*/

  /* "calign.pyx":10
 * cimport cython
 * 
 * import logging             # <<<<<<<<<<<<<<
 * import htslibWrapper
 * cimport cerrormodel
 */
  __pyx_t_1 = __Pyx_Import(((PyObject *)__pyx_n_s__logging), 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s__logging, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "calign.pyx":11
 * 
 * import logging
 * import htslibWrapper             # <<<<<<<<<<<<<<
 * cimport cerrormodel
 * cimport htslibWrapper
 */
  __pyx_t_1 = __Pyx_Import(((PyObject *)__pyx_n_s__htslibWrapper), 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s__htslibWrapper, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "calign.pyx":25
 * 
 * # set the size of the hash.  Ensure that hash_size == math.pow(4,hash_nucs)
 * cdef int hash_nucs = 7             # <<<<<<<<<<<<<<
 * cdef int hash_size = 4**hash_nucs
 * cdef int max_sequence_length = hash_size
 */
  __pyx_v_6calign_hash_nucs = 7;

  /* "calign.pyx":26
 * # set the size of the hash.  Ensure that hash_size == math.pow(4,hash_nucs)
 * cdef int hash_nucs = 7
 * cdef int hash_size = 4**hash_nucs             # <<<<<<<<<<<<<<
 * cdef int max_sequence_length = hash_size
 * cdef int mask = (1 << 2*hash_nucs) - 1
 */
  __pyx_v_6calign_hash_size = __Pyx_pow_long(4, ((long)__pyx_v_6calign_hash_nucs));

  /* "calign.pyx":27
 * cdef int hash_nucs = 7
 * cdef int hash_size = 4**hash_nucs
 * cdef int max_sequence_length = hash_size             # <<<<<<<<<<<<<<
 * cdef int mask = (1 << 2*hash_nucs) - 1
 * 
 */
  __pyx_v_6calign_max_sequence_length = __pyx_v_6calign_hash_size;

  /* "calign.pyx":28
 * cdef int hash_size = 4**hash_nucs
 * cdef int max_sequence_length = hash_size
 * cdef int mask = (1 << 2*hash_nucs) - 1             # <<<<<<<<<<<<<<
 * 
 * ctypedef long long size_t
 */
  __pyx_v_6calign_mask = ((1 << (2 * __pyx_v_6calign_hash_nucs)) - 1);

  /* "calign.pyx":31
 * 
 * ctypedef long long size_t
 * cdef double mLTOT = -0.23025850929940459    # Minus log ten over ten             # <<<<<<<<<<<<<<
 * 
 * ###################################################################################################
 */
  __pyx_v_6calign_mLTOT = -0.23025850929940459;

  /* "calign.pyx":1
 * """             # <<<<<<<<<<<<<<
 * Cython module containing glue code for the alignment routines used in
 * Platypus.
 */
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
  if (PyDict_SetItem(__pyx_d, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0;

  /* "htslibWrapper.pxd":295
 *     theRead.bitFlag |= BAM_FCOMPRESSED
 * 
 * cdef inline void Read_SetUnCompressed(cAlignedRead* theRead) nogil:             # <<<<<<<<<<<<<<
 *     theRead.bitFlag &= (~BAM_FCOMPRESSED)
 * 
 */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  if (__pyx_m) {
    __Pyx_AddTraceback("init calign", __pyx_clineno, __pyx_lineno, __pyx_filename);
    Py_DECREF(__pyx_m); __pyx_m = 0;
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init calign");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if PY_MAJOR_VERSION < 3
  return;
  #else
  return __pyx_m;
  #endif
}

/* Runtime support code */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule((char *)modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif /* CYTHON_REFNANNY */

static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

static void* __Pyx_GetVtable(PyObject *dict) {
    void* ptr;
    PyObject *ob = PyObject_GetItem(dict, __pyx_n_s____pyx_vtable__);
    if (!ob)
        goto bad;
#if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
    ptr = PyCapsule_GetPointer(ob, 0);
#else
    ptr = PyCObject_AsVoidPtr(ob);
#endif
    if (!ptr && !PyErr_Occurred())
        PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
    Py_DECREF(ob);
    return ptr;
bad:
    Py_XDECREF(ob);
    return NULL;
}

static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    #if PY_VERSION_HEX < 0x03030000
    PyObject *py_import;
    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s____import__);
    if (!py_import)
        goto bad;
    #endif
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(__pyx_m);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
    #if PY_VERSION_HEX >= 0x02050000
    {
        #if PY_MAJOR_VERSION >= 3
        if (level == -1) {
            if (strchr(__Pyx_MODULE_NAME, '.')) {
                #if PY_VERSION_HEX < 0x03030000
                PyObject *py_level = PyInt_FromLong(1);
                if (!py_level)
                    goto bad;
                module = PyObject_CallFunctionObjArgs(py_import,
                    name, global_dict, empty_dict, list, py_level, NULL);
                Py_DECREF(py_level);
                #else
                module = PyImport_ImportModuleLevelObject(
                    name, global_dict, empty_dict, list, 1);
                #endif
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
            }
            level = 0; /* try absolute import on failure */
        }
        #endif
        if (!module) {
            #if PY_VERSION_HEX < 0x03030000
            PyObject *py_level = PyInt_FromLong(level);
            if (!py_level)
                goto bad;
            module = PyObject_CallFunctionObjArgs(py_import,
                name, global_dict, empty_dict, list, py_level, NULL);
            Py_DECREF(py_level);
            #else
            module = PyImport_ImportModuleLevelObject(
                name, global_dict, empty_dict, list, level);
            #endif
        }
    }
    #else
    if (level>0) {
        PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4.");
        goto bad;
    }
    module = PyObject_CallFunctionObjArgs(py_import,
        name, global_dict, empty_dict, list, NULL);
    #endif
bad:
    #if PY_VERSION_HEX < 0x03030000
    Py_XDECREF(py_import);
    #endif
    Py_XDECREF(empty_list);
    Py_XDECREF(empty_dict);
    return module;
}

static CYTHON_INLINE long __Pyx_pow_long(long b, long e) {
    long t = b;
    switch (e) {
        case 3:
            t *= b;
        case 2:
            t *= b;
        case 1:
            return t;
        case 0:
            return 1;
    }
    #if 1
    if (unlikely(e<0)) return 0;
    #endif
    t = 1;
    while (likely(e)) {
        t *= (b * (e&1)) | ((~e)&1);    /* 1 or b */
        b *= b;
        e >>= 1;
    }
    return t;
}

static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject* x) {
    const unsigned char neg_one = (unsigned char)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(unsigned char) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(unsigned char)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to unsigned char" :
                    "value too large to convert to unsigned char");
            }
            return (unsigned char)-1;
        }
        return (unsigned char)val;
    }
    return (unsigned char)__Pyx_PyInt_AsUnsignedLong(x);
}

static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject* x) {
    const unsigned short neg_one = (unsigned short)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(unsigned short) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(unsigned short)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to unsigned short" :
                    "value too large to convert to unsigned short");
            }
            return (unsigned short)-1;
        }
        return (unsigned short)val;
    }
    return (unsigned short)__Pyx_PyInt_AsUnsignedLong(x);
}

static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject* x) {
    const unsigned int neg_one = (unsigned int)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(unsigned int) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(unsigned int)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to unsigned int" :
                    "value too large to convert to unsigned int");
            }
            return (unsigned int)-1;
        }
        return (unsigned int)val;
    }
    return (unsigned int)__Pyx_PyInt_AsUnsignedLong(x);
}

static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject* x) {
    const char neg_one = (char)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(char) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(char)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to char" :
                    "value too large to convert to char");
            }
            return (char)-1;
        }
        return (char)val;
    }
    return (char)__Pyx_PyInt_AsLong(x);
}

static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject* x) {
    const short neg_one = (short)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(short) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(short)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to short" :
                    "value too large to convert to short");
            }
            return (short)-1;
        }
        return (short)val;
    }
    return (short)__Pyx_PyInt_AsLong(x);
}

static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject* x) {
    const int neg_one = (int)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(int) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(int)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to int" :
                    "value too large to convert to int");
            }
            return (int)-1;
        }
        return (int)val;
    }
    return (int)__Pyx_PyInt_AsLong(x);
}

static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject* x) {
    const signed char neg_one = (signed char)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(signed char) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(signed char)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to signed char" :
                    "value too large to convert to signed char");
            }
            return (signed char)-1;
        }
        return (signed char)val;
    }
    return (signed char)__Pyx_PyInt_AsSignedLong(x);
}

static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject* x) {
    const signed short neg_one = (signed short)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(signed short) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(signed short)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to signed short" :
                    "value too large to convert to signed short");
            }
            return (signed short)-1;
        }
        return (signed short)val;
    }
    return (signed short)__Pyx_PyInt_AsSignedLong(x);
}

static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject* x) {
    const signed int neg_one = (signed int)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(signed int) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(signed int)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to signed int" :
                    "value too large to convert to signed int");
            }
            return (signed int)-1;
        }
        return (signed int)val;
    }
    return (signed int)__Pyx_PyInt_AsSignedLong(x);
}

static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject* x) {
    const int neg_one = (int)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
    if (sizeof(int) < sizeof(long)) {
        long val = __Pyx_PyInt_AsLong(x);
        if (unlikely(val != (long)(int)val)) {
            if (!unlikely(val == -1 && PyErr_Occurred())) {
                PyErr_SetString(PyExc_OverflowError,
                    (is_unsigned && unlikely(val < 0)) ?
                    "can't convert negative value to int" :
                    "value too large to convert to int");
            }
            return (int)-1;
        }
        return (int)val;
    }
    return (int)__Pyx_PyInt_AsLong(x);
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject* x) {
    const unsigned long neg_one = (unsigned long)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to unsigned long");
            return (unsigned long)-1;
        }
        return (unsigned long)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(unsigned long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (unsigned long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to unsigned long");
                return (unsigned long)-1;
            }
            return (unsigned long)PyLong_AsUnsignedLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(unsigned long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(unsigned long) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(unsigned long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (unsigned long)PyLong_AsLong(x);
        }
    } else {
        unsigned long val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (unsigned long)-1;
        val = __Pyx_PyInt_AsUnsignedLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject* x) {
    const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to unsigned PY_LONG_LONG");
            return (unsigned PY_LONG_LONG)-1;
        }
        return (unsigned PY_LONG_LONG)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to unsigned PY_LONG_LONG");
                return (unsigned PY_LONG_LONG)-1;
            }
            return (unsigned PY_LONG_LONG)PyLong_AsUnsignedLongLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (unsigned PY_LONG_LONG)PyLong_AsLongLong(x);
        }
    } else {
        unsigned PY_LONG_LONG val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (unsigned PY_LONG_LONG)-1;
        val = __Pyx_PyInt_AsUnsignedLongLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject* x) {
    const long neg_one = (long)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to long");
            return (long)-1;
        }
        return (long)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to long");
                return (long)-1;
            }
            return (long)PyLong_AsUnsignedLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(long) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (long)PyLong_AsLong(x);
        }
    } else {
        long val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (long)-1;
        val = __Pyx_PyInt_AsLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject* x) {
    const PY_LONG_LONG neg_one = (PY_LONG_LONG)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to PY_LONG_LONG");
            return (PY_LONG_LONG)-1;
        }
        return (PY_LONG_LONG)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to PY_LONG_LONG");
                return (PY_LONG_LONG)-1;
            }
            return (PY_LONG_LONG)PyLong_AsUnsignedLongLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (PY_LONG_LONG)PyLong_AsLongLong(x);
        }
    } else {
        PY_LONG_LONG val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (PY_LONG_LONG)-1;
        val = __Pyx_PyInt_AsLongLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject* x) {
    const signed long neg_one = (signed long)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to signed long");
            return (signed long)-1;
        }
        return (signed long)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(signed long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (signed long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to signed long");
                return (signed long)-1;
            }
            return (signed long)PyLong_AsUnsignedLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(signed long)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(signed long) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(signed long) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (signed long)PyLong_AsLong(x);
        }
    } else {
        signed long val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (signed long)-1;
        val = __Pyx_PyInt_AsSignedLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject* x) {
    const signed PY_LONG_LONG neg_one = (signed PY_LONG_LONG)-1, const_zero = 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        long val = PyInt_AS_LONG(x);
        if (is_unsigned && unlikely(val < 0)) {
            PyErr_SetString(PyExc_OverflowError,
                            "can't convert negative value to signed PY_LONG_LONG");
            return (signed PY_LONG_LONG)-1;
        }
        return (signed PY_LONG_LONG)val;
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return (signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            if (unlikely(Py_SIZE(x) < 0)) {
                PyErr_SetString(PyExc_OverflowError,
                                "can't convert negative value to signed PY_LONG_LONG");
                return (signed PY_LONG_LONG)-1;
            }
            return (signed PY_LONG_LONG)PyLong_AsUnsignedLongLong(x);
        } else {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
            if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) {
                switch (Py_SIZE(x)) {
                    case  0: return 0;
                    case  1: return +(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                    case -1: return -(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0];
                }
            }
#endif
#endif
            return (signed PY_LONG_LONG)PyLong_AsLongLong(x);
        }
    } else {
        signed PY_LONG_LONG val;
        PyObject *tmp = __Pyx_PyNumber_Int(x);
        if (!tmp) return (signed PY_LONG_LONG)-1;
        val = __Pyx_PyInt_AsSignedLongLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

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());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        #if PY_VERSION_HEX < 0x02050000
        return PyErr_Warn(NULL, message);
        #else
        return PyErr_WarnEx(NULL, message, 1);
        #endif
    }
    return 0;
}

static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig) {
    PyObject *d;
    PyObject *cobj = 0;
    d = PyDict_GetItem(__pyx_d, __pyx_n_s____pyx_capi__);
    Py_XINCREF(d);
    if (!d) {
        d = PyDict_New();
        if (!d)
            goto bad;
        if (__Pyx_PyObject_SetAttrStr(__pyx_m, __pyx_n_s____pyx_capi__, d) < 0)
            goto bad;
    }
#if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3 && PY_MINOR_VERSION==0)
    cobj = PyCapsule_New(p, sig, 0);
#else
    cobj = PyCObject_FromVoidPtrAndDesc(p, (void *)sig, 0);
#endif
    if (!cobj)
        goto bad;
    if (PyDict_SetItem(d, name, cobj) < 0)
        goto bad;
    Py_DECREF(cobj);
    Py_DECREF(d);
    return 0;
bad:
    Py_XDECREF(cobj);
    Py_XDECREF(d);
    return -1;
}

static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
    PyObject *d = 0;
    PyObject *cobj = 0;
    union {
        void (*fp)(void);
        void *p;
    } tmp;
    d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__");
    if (!d) {
        PyErr_Clear();
        d = PyDict_New();
        if (!d)
            goto bad;
        Py_INCREF(d);
        if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0)
            goto bad;
    }
    tmp.fp = f;
#if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
    cobj = PyCapsule_New(tmp.p, sig, 0);
#else
    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
#endif
    if (!cobj)
        goto bad;
    if (PyDict_SetItemString(d, name, cobj) < 0)
        goto bad;
    Py_DECREF(cobj);
    Py_DECREF(d);
    return 0;
bad:
    Py_XDECREF(cobj);
    Py_XDECREF(d);
    return -1;
}

#ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
    PyObject *py_name = 0;
    PyObject *py_module = 0;
    py_name = __Pyx_PyIdentifier_FromString(name);
    if (!py_name)
        goto bad;
    py_module = PyImport_Import(py_name);
    Py_DECREF(py_name);
    return py_module;
bad:
    Py_XDECREF(py_name);
    return 0;
}
#endif

#ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
    size_t size, int strict)
{
    PyObject *py_module = 0;
    PyObject *result = 0;
    PyObject *py_name = 0;
    char warning[200];
    Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
#endif
    py_module = __Pyx_ImportModule(module_name);
    if (!py_module)
        goto bad;
    py_name = __Pyx_PyIdentifier_FromString(class_name);
    if (!py_name)
        goto bad;
    result = PyObject_GetAttr(py_module, py_name);
    Py_DECREF(py_name);
    py_name = 0;
    Py_DECREF(py_module);
    py_module = 0;
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%s.%s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if (!strict && (size_t)basicsize > size) {
        PyOS_snprintf(warning, sizeof(warning),
            "%s.%s size changed, may indicate binary incompatibility",
            module_name, class_name);
        #if PY_VERSION_HEX < 0x02050000
        if (PyErr_Warn(NULL, warning) < 0) goto bad;
        #else
        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
        #endif
    }
    else if ((size_t)basicsize != size) {
        PyErr_Format(PyExc_ValueError,
            "%s.%s has the wrong size, try recompiling",
            module_name, class_name);
        goto bad;
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(py_module);
    Py_XDECREF(result);
    return NULL;
}
#endif

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;
    }
    while (start < end) {
        mid = (start + end) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            __pyx_code_cache.entries = entries;
            __pyx_code_cache.max_count = 64;
            __pyx_code_cache.count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
        PyCodeObject* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_DECREF(tmp);
        return;
    }
    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, new_max*sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        __pyx_code_cache.entries = entries;
        __pyx_code_cache.max_count = new_max;
    }
    for (i=__pyx_code_cache.count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    __pyx_code_cache.count++;
    Py_INCREF(code_object);
}

#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(filename);
    #else
    py_srcfile = PyUnicode_FromString(filename);
    #endif
    if (!py_srcfile) goto bad;
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_code = __Pyx_PyCode_New(
        0,            /*int argcount,*/
        0,            /*int kwonlyargcount,*/
        0,            /*int nlocals,*/
        0,            /*int stacksize,*/
        0,            /*int flags,*/
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,      /*int firstlineno,*/
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    Py_DECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_globals = 0;
    PyFrameObject *py_frame = 0;
    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
    }
    py_globals = PyModule_GetDict(__pyx_m);
    if (!py_globals) goto bad;
    py_frame = PyFrame_New(
        PyThreadState_GET(), /*PyThreadState *tstate,*/
        py_code,             /*PyCodeObject *code,*/
        py_globals,          /*PyObject *globals,*/
        0                    /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    py_frame->f_lineno = py_line;
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else  /* Python 3+ has unicode identifiers */
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        ++t;
    }
    return 0;
}

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(char* c_str) {
    return __Pyx_PyUnicode_FromStringAndSize(c_str, strlen(c_str));
}
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
    if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
            __Pyx_sys_getdefaultencoding_not_ascii &&
#endif
            PyUnicode_Check(o)) {
#if PY_VERSION_HEX < 0x03030000
        char* defenc_c;
        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
        if (!defenc) return NULL;
        defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        {
            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
            char* c;
            for (c = defenc_c; c < end; c++) {
                if ((unsigned char) (*c) >= 128) {
                    PyUnicode_AsASCIIString(o);
                    return NULL;
                }
            }
        }
#endif /*__PYX_DEFAULT_STRING_ENCODING_IS_ASCII*/
        *length = PyBytes_GET_SIZE(defenc);
        return defenc_c;
#else /* PY_VERSION_HEX < 0x03030000 */
        if (PyUnicode_READY(o) == -1) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        if (PyUnicode_IS_ASCII(o)) {
            *length = PyUnicode_GET_DATA_SIZE(o);
            return PyUnicode_AsUTF8(o);
        } else {
            PyUnicode_AsASCIIString(o);
            return NULL;
        }
#else /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */
        return PyUnicode_AsUTF8AndSize(o, length);
#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */
#endif /* PY_VERSION_HEX < 0x03030000 */
    } else
#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII  || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT */
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (r < 0) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
  PyNumberMethods *m;
  const char *name = NULL;
  PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
  if (PyInt_Check(x) || PyLong_Check(x))
#else
  if (PyLong_Check(x))
#endif
    return Py_INCREF(x), x;
  m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Int(x);
  }
  else if (m && m->nb_long) {
    name = "long";
    res = PyNumber_Long(x);
  }
#else
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Long(x);
  }
#endif
  if (res) {
#if PY_MAJOR_VERSION < 3
    if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
    if (!PyLong_Check(res)) {
#endif
      PyErr_Format(PyExc_TypeError,
                   "__%s__ returned non-%s (type %.200s)",
                   name, name, Py_TYPE(res)->tp_name);
      Py_DECREF(res);
      return NULL;
    }
  }
  else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_TypeError,
                    "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject* x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
#if PY_VERSION_HEX < 0x02050000
   if (ival <= LONG_MAX)
       return PyInt_FromLong((long)ival);
   else {
       unsigned char *bytes = (unsigned char *) &ival;
       int one = 1; int little = (int)*(unsigned char*)&one;
       return _PyLong_FromByteArray(bytes, sizeof(size_t), little, 0);
   }
#else
   return PyInt_FromSize_t(ival);
#endif
}
static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject* x) {
   unsigned PY_LONG_LONG val = __Pyx_PyInt_AsUnsignedLongLong(x);
   if (unlikely(val != (unsigned PY_LONG_LONG)(size_t)val)) {
       if ((val != (unsigned PY_LONG_LONG)-1) || !PyErr_Occurred())
           PyErr_SetString(PyExc_OverflowError,
                           "value too large to convert to size_t");
       return (size_t)-1;
   }
   return (size_t)val;
}


#endif /* Py_PYTHON_H */
