+001: # cython: language_level=3, boundscheck=True, wraparound=False

  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+002: import numpy as np

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+003: import psutil      # For Memory Profiling

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_psutil, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_psutil, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+004: import os

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 005: cimport cython

 006: 

 007: #from scipy.special import logsumexp

 008: from libc.math cimport exp, log   # For doing Exponentials and Logs

 009: 

+010: DTYPE = np.float # The float data type

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 011: 

+012: cdef inline double logsumexp(double[:] vec):

static CYTHON_INLINE double __pyx_f_5cfunc_logsumexp(__Pyx_memviewslice __pyx_v_vec) {
  Py_ssize_t __pyx_v_i;
  double __pyx_v_result;
  double __pyx_v_largest;
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("logsumexp", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("cfunc.logsumexp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 013:   """Do the Log of the Sum of Exponentials."""

 014:   cdef Py_ssize_t i  # The iterator Variable

+015:   cdef double result = 0.0

  __pyx_v_result = 0.0;

+016:   cdef double largest = vec[0]

  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 16, __pyx_L1_error)
  }
  __pyx_v_largest = (*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_1 * __pyx_v_vec.strides[0]) )));

 017: 

+018:   for i in range(1, vec.shape[0]):   # Find Maximum in vec

  __pyx_t_3 = (__pyx_v_vec.shape[0]);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

+019:       if (vec[i] > largest):

    __pyx_t_6 = __pyx_v_i;
    __pyx_t_2 = -1;
    if (__pyx_t_6 < 0) {
      __pyx_t_2 = 0;
    } else if (unlikely(__pyx_t_6 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
    if (unlikely(__pyx_t_2 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_2);
      __PYX_ERR(0, 19, __pyx_L1_error)
    }
    __pyx_t_7 = (((*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_6 * __pyx_v_vec.strides[0]) ))) > __pyx_v_largest) != 0);
    if (__pyx_t_7) {
/* … */
    }
  }

+020:           largest = vec[i]

      __pyx_t_8 = __pyx_v_i;
      __pyx_t_2 = -1;
      if (__pyx_t_8 < 0) {
        __pyx_t_2 = 0;
      } else if (unlikely(__pyx_t_8 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
      if (unlikely(__pyx_t_2 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_2);
        __PYX_ERR(0, 20, __pyx_L1_error)
      }
      __pyx_v_largest = (*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_8 * __pyx_v_vec.strides[0]) )));

+021:   for i in range(vec.shape[0]):

  __pyx_t_3 = (__pyx_v_vec.shape[0]);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

+022:       result += exp(vec[i] - largest)

    __pyx_t_9 = __pyx_v_i;
    __pyx_t_2 = -1;
    if (__pyx_t_9 < 0) {
      __pyx_t_2 = 0;
    } else if (unlikely(__pyx_t_9 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
    if (unlikely(__pyx_t_2 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_2);
      __PYX_ERR(0, 22, __pyx_L1_error)
    }
    __pyx_v_result = (__pyx_v_result + exp(((*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_9 * __pyx_v_vec.strides[0]) ))) - __pyx_v_largest)));
  }

+023:   return largest + log(result)

  __pyx_r = (__pyx_v_largest + log(__pyx_v_result));
  goto __pyx_L0;

 024: 

+025: cdef inline long argmax(double[:] vec):

static CYTHON_INLINE long __pyx_f_5cfunc_argmax(__Pyx_memviewslice __pyx_v_vec) {
  int __pyx_v_m;
  double __pyx_v_v;
  Py_ssize_t __pyx_v_k;
  long __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("argmax", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("cfunc.argmax", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 026:   """Return Max and ArgMax"""

 027:   cdef Py_ssize_t i  # The iterator Variable.

+028:   cdef int m = 0     # Position of the Maximum.

  __pyx_v_m = 0;

+029:   cdef double v = vec[0]

  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 29, __pyx_L1_error)
  }
  __pyx_v_v = (*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_1 * __pyx_v_vec.strides[0]) )));

 030: 

+031:   for k in range(1, vec.shape[0]):   # Find Maximum

  __pyx_t_3 = (__pyx_v_vec.shape[0]);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_k = __pyx_t_5;

+032:     if (vec[k] > v):

    __pyx_t_6 = __pyx_v_k;
    __pyx_t_2 = -1;
    if (__pyx_t_6 < 0) {
      __pyx_t_2 = 0;
    } else if (unlikely(__pyx_t_6 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
    if (unlikely(__pyx_t_2 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_2);
      __PYX_ERR(0, 32, __pyx_L1_error)
    }
    __pyx_t_7 = (((*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_6 * __pyx_v_vec.strides[0]) ))) > __pyx_v_v) != 0);
    if (__pyx_t_7) {
/* … */
    }
  }

+033:       m, v = k, vec[k]

      __pyx_t_8 = __pyx_v_k;
      __pyx_t_9 = __pyx_v_k;
      __pyx_t_2 = -1;
      if (__pyx_t_9 < 0) {
        __pyx_t_2 = 0;
      } else if (unlikely(__pyx_t_9 >= __pyx_v_vec.shape[0])) __pyx_t_2 = 0;
      if (unlikely(__pyx_t_2 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_2);
        __PYX_ERR(0, 33, __pyx_L1_error)
      }
      __pyx_t_10 = (*((double *) ( /* dim=0 */ (__pyx_v_vec.data + __pyx_t_9 * __pyx_v_vec.strides[0]) )));
      __pyx_v_m = __pyx_t_8;
      __pyx_v_v = __pyx_t_10;

+034:   return m  # Return Argmax

  __pyx_r = __pyx_v_m;
  goto __pyx_L0;

 035: 

 036: 

+037: def print_memory_usage():

/* Python wrapper */
static PyObject *__pyx_pw_5cfunc_1print_memory_usage(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_5cfunc_print_memory_usage[] = "Print the current Memory Usage in mB";
static PyMethodDef __pyx_mdef_5cfunc_1print_memory_usage = {"print_memory_usage", (PyCFunction)__pyx_pw_5cfunc_1print_memory_usage, METH_NOARGS, __pyx_doc_5cfunc_print_memory_usage};
static PyObject *__pyx_pw_5cfunc_1print_memory_usage(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_memory_usage (wrapper)", 0);
  __pyx_r = __pyx_pf_5cfunc_print_memory_usage(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5cfunc_print_memory_usage(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_v_process = NULL;
  PyObject *__pyx_v_mb_usage = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_memory_usage", 0);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cfunc.print_memory_usage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_process);
  __Pyx_XDECREF(__pyx_v_mb_usage);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_process, __pyx_n_s_mb_usage); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__43);
  __Pyx_GIVEREF(__pyx_tuple__43);
/* … */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5cfunc_1print_memory_usage, NULL, __pyx_n_s_cfunc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_print_memory_usage, __pyx_t_2) < 0) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cfunc_pyx, __pyx_n_s_print_memory_usage, 37, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 37, __pyx_L1_error)

 038:     """Print the current Memory Usage in mB"""

+039:     process = psutil.Process(os.getpid())

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_psutil); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Process); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_getpid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_5, function);
    }
  }
  if (__pyx_t_4) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
  }
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  if (!__pyx_t_5) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
      __Pyx_GIVEREF(__pyx_t_2);
      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_process = __pyx_t_1;
  __pyx_t_1 = 0;

+040:     mb_usage = process.memory_info().rss / 1e6

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_process, __pyx_n_s_memory_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  if (__pyx_t_4) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error)
  }
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_rss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_3, __pyx_float_1e6, 1e6, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_mb_usage = __pyx_t_1;
  __pyx_t_1 = 0;

+041:     print(f"Memory Usage: {mb_usage} mB")

  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = 0;
  __pyx_t_7 = 127;
  __Pyx_INCREF(__pyx_kp_u_Memory_Usage);
  __pyx_t_6 += 14;
  __Pyx_GIVEREF(__pyx_kp_u_Memory_Usage);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Memory_Usage);
  __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_mb_usage, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_7;
  __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
  __pyx_t_3 = 0;
  __Pyx_INCREF(__pyx_kp_u_mB);
  __pyx_t_6 += 3;
  __Pyx_GIVEREF(__pyx_kp_u_mB);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_mB);
  __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 042: 

 043: 

+044: def fwd_bkwd(double[:, :] e_prob0, double[:, :] t_mat,

/* Python wrapper */
static PyObject *__pyx_pw_5cfunc_3fwd_bkwd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_5cfunc_2fwd_bkwd[] = "Takes emission and transition probabilities, and calculates posteriors.\n    Input: kxl matrices of emission, transition\n    and initialized fwd and bwd probabilities. Given in log Space\n    full: Boolean whether to return everything";
static PyMethodDef __pyx_mdef_5cfunc_3fwd_bkwd = {"fwd_bkwd", (PyCFunction)__pyx_pw_5cfunc_3fwd_bkwd, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5cfunc_2fwd_bkwd};
static PyObject *__pyx_pw_5cfunc_3fwd_bkwd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  __Pyx_memviewslice __pyx_v_e_prob0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t_mat = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_fwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_bwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_full = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_e_prob0,&__pyx_n_s_t_mat,&__pyx_n_s_fwd,&__pyx_n_s_bwd,&__pyx_n_s_t,&__pyx_n_s_full,0};
    PyObject* values[6] = {0,0,0,0,0,0};
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5cfunc_2fwd_bkwd(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_e_prob0, __Pyx_memviewslice __pyx_v_t_mat, __Pyx_memviewslice __pyx_v_fwd, __Pyx_memviewslice __pyx_v_bwd, CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t, PyObject *__pyx_v_full) {
  int __pyx_v_n_states;
  int __pyx_v_n_loci;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_j;
  Py_ssize_t __pyx_v_k;
  PyObject *__pyx_v_post = NULL;
  PyObject *__pyx_v_trans_ll = NULL;
  __Pyx_memviewslice __pyx_v_trans_ll_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t_mat0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  double __pyx_v_tot_ll;
  PyObject *__pyx_v_fwd1 = NULL;
  PyObject *__pyx_v_bwd1 = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd", 0);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __Pyx_AddTraceback("cfunc.fwd_bkwd", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_post);
  __Pyx_XDECREF(__pyx_v_trans_ll);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t_mat0, 1);
  __Pyx_XDECREF(__pyx_v_fwd1);
  __Pyx_XDECREF(__pyx_v_bwd1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_e_prob0, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t_mat, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_fwd, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_bwd, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__45 = PyTuple_Pack(18, __pyx_n_s_e_prob0, __pyx_n_s_t_mat, __pyx_n_s_fwd, __pyx_n_s_bwd, __pyx_n_s_t, __pyx_n_s_full, __pyx_n_s_n_states, __pyx_n_s_n_loci, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_post, __pyx_n_s_trans_ll, __pyx_n_s_trans_ll_view, __pyx_n_s_t_mat0, __pyx_n_s_tot_ll, __pyx_n_s_fwd1, __pyx_n_s_bwd1); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 44, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__45);
  __Pyx_GIVEREF(__pyx_tuple__45);
/* … */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5cfunc_3fwd_bkwd, NULL, __pyx_n_s_cfunc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fwd_bkwd, __pyx_t_2) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(6, 0, 18, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cfunc_pyx, __pyx_n_s_fwd_bkwd, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 44, __pyx_L1_error)

+045:     double[:, :] fwd, double[:, :] bwd, double[:,:,:] t, full=False):

    values[5] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_e_prob0)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_mat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd", 0, 5, 6, 1); __PYX_ERR(0, 44, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fwd)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd", 0, 5, 6, 2); __PYX_ERR(0, 44, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bwd)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd", 0, 5, 6, 3); __PYX_ERR(0, 44, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd", 0, 5, 6, 4); __PYX_ERR(0, 44, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_full);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fwd_bkwd") < 0)) __PYX_ERR(0, 44, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_e_prob0 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_e_prob0.memview)) __PYX_ERR(0, 44, __pyx_L3_error)
    __pyx_v_t_mat = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_mat.memview)) __PYX_ERR(0, 44, __pyx_L3_error)
    __pyx_v_fwd = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_fwd.memview)) __PYX_ERR(0, 45, __pyx_L3_error)
    __pyx_v_bwd = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_bwd.memview)) __PYX_ERR(0, 45, __pyx_L3_error)
    __pyx_v_t = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t.memview)) __PYX_ERR(0, 45, __pyx_L3_error)
    __pyx_v_full = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fwd_bkwd", 0, 5, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 44, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("cfunc.fwd_bkwd", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_5cfunc_2fwd_bkwd(__pyx_self, __pyx_v_e_prob0, __pyx_v_t_mat, __pyx_v_fwd, __pyx_v_bwd, __pyx_v_t, __pyx_v_full);

 046:     """Takes emission and transition probabilities, and calculates posteriors.

 047:     Input: kxl matrices of emission, transition

 048:     and initialized fwd and bwd probabilities. Given in log Space

 049:     full: Boolean whether to return everything"""

+050:     cdef int n_states = e_prob0.shape[0]

  __pyx_v_n_states = (__pyx_v_e_prob0.shape[0]);

+051:     cdef int n_loci = e_prob0.shape[1]

  __pyx_v_n_loci = (__pyx_v_e_prob0.shape[1]);

 052:     cdef Py_ssize_t i, j, k # The Array Indices

 053: 

 054:     # Initialize Posterior and Transition Probabilities

+055:     post = np.empty([n_states, n_loci], dtype=DTYPE)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_post = __pyx_t_1;
  __pyx_t_1 = 0;

 056: 

+057:     trans_ll = np.empty(n_states, dtype=DTYPE)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_trans_ll = __pyx_t_2;
  __pyx_t_2 = 0;

+058:     cdef double[:] trans_ll_view = trans_ll

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 58, __pyx_L1_error)
  __pyx_v_trans_ll_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 059: 

 060:     ### Transform to Log space

+061:     cdef double[:, :] t_mat0 = np.log(np.eye(n_states) + t_mat[:,:])  # Do log of (relevant) transition Matrix

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_eye); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (!__pyx_t_7) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else
    #endif
    {
      __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
      __Pyx_GIVEREF(__pyx_t_4);
      PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_t_mat, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_6)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  if (!__pyx_t_6) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    } else
    #endif
    {
      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL;
      __Pyx_GIVEREF(__pyx_t_8);
      PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_8);
      __pyx_t_8 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_t_mat0 = __pyx_t_9;
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;

 062: 

+063:     for i in range(1, n_loci):  # Do the forward recursion

  __pyx_t_10 = __pyx_v_n_loci;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 1; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_i = __pyx_t_12;

+064:         for j in range(n_states):

    __pyx_t_13 = __pyx_v_n_states;
    __pyx_t_14 = __pyx_t_13;
    for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
      __pyx_v_j = __pyx_t_15;

+065:           for k in range(n_states):

      __pyx_t_16 = __pyx_v_n_states;
      __pyx_t_17 = __pyx_t_16;
      for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
        __pyx_v_k = __pyx_t_18;

+066:             trans_ll_view[k] = fwd[k, i - 1] + t_mat0[k, j]

        __pyx_t_19 = __pyx_v_k;
        __pyx_t_20 = (__pyx_v_i - 1);
        __pyx_t_21 = -1;
        if (__pyx_t_19 < 0) {
          __pyx_t_21 = 0;
        } else if (unlikely(__pyx_t_19 >= __pyx_v_fwd.shape[0])) __pyx_t_21 = 0;
        if (__pyx_t_20 < 0) {
          __pyx_t_21 = 1;
        } else if (unlikely(__pyx_t_20 >= __pyx_v_fwd.shape[1])) __pyx_t_21 = 1;
        if (unlikely(__pyx_t_21 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_21);
          __PYX_ERR(0, 66, __pyx_L1_error)
        }
        __pyx_t_22 = __pyx_v_k;
        __pyx_t_23 = __pyx_v_j;
        __pyx_t_21 = -1;
        if (__pyx_t_22 < 0) {
          __pyx_t_21 = 0;
        } else if (unlikely(__pyx_t_22 >= __pyx_v_t_mat0.shape[0])) __pyx_t_21 = 0;
        if (__pyx_t_23 < 0) {
          __pyx_t_21 = 1;
        } else if (unlikely(__pyx_t_23 >= __pyx_v_t_mat0.shape[1])) __pyx_t_21 = 1;
        if (unlikely(__pyx_t_21 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_21);
          __PYX_ERR(0, 66, __pyx_L1_error)
        }
        __pyx_t_24 = __pyx_v_k;
        __pyx_t_21 = -1;
        if (__pyx_t_24 < 0) {
          __pyx_t_21 = 0;
        } else if (unlikely(__pyx_t_24 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_21 = 0;
        if (unlikely(__pyx_t_21 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_21);
          __PYX_ERR(0, 66, __pyx_L1_error)
        }
        *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_24 * __pyx_v_trans_ll_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_19 * __pyx_v_fwd.strides[0]) ) + __pyx_t_20 * __pyx_v_fwd.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_22 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_23 * __pyx_v_t_mat0.strides[1]) ))));
      }

 067: 

+068:           fwd[j, i] = e_prob0[j, i] + logsumexp(trans_ll_view)

      __pyx_t_25 = __pyx_v_j;
      __pyx_t_26 = __pyx_v_i;
      __pyx_t_16 = -1;
      if (__pyx_t_25 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_25 >= __pyx_v_e_prob0.shape[0])) __pyx_t_16 = 0;
      if (__pyx_t_26 < 0) {
        __pyx_t_16 = 1;
      } else if (unlikely(__pyx_t_26 >= __pyx_v_e_prob0.shape[1])) __pyx_t_16 = 1;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 68, __pyx_L1_error)
      }
      __pyx_t_27 = __pyx_v_j;
      __pyx_t_28 = __pyx_v_i;
      __pyx_t_16 = -1;
      if (__pyx_t_27 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_27 >= __pyx_v_fwd.shape[0])) __pyx_t_16 = 0;
      if (__pyx_t_28 < 0) {
        __pyx_t_16 = 1;
      } else if (unlikely(__pyx_t_28 >= __pyx_v_fwd.shape[1])) __pyx_t_16 = 1;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 68, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_27 * __pyx_v_fwd.strides[0]) ) + __pyx_t_28 * __pyx_v_fwd.strides[1]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_25 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_26 * __pyx_v_e_prob0.strides[1]) ))) + __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view));
    }
  }

 069: 

+070:     for i in range(n_loci-1, 0, -1):  # Do the backward recursion

  for (__pyx_t_12 = (__pyx_v_n_loci - 1); __pyx_t_12 > 0; __pyx_t_12-=1) {
    __pyx_v_i = __pyx_t_12;

+071:       for j in range(n_states):

    __pyx_t_10 = __pyx_v_n_states;
    __pyx_t_11 = __pyx_t_10;
    for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_11; __pyx_t_15+=1) {
      __pyx_v_j = __pyx_t_15;

+072:         for k in range(n_states):

      __pyx_t_13 = __pyx_v_n_states;
      __pyx_t_14 = __pyx_t_13;
      for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_14; __pyx_t_18+=1) {
        __pyx_v_k = __pyx_t_18;

+073:           trans_ll_view[k] = t_mat0[j, k] + e_prob0[k, i] + bwd[k, i]

        __pyx_t_29 = __pyx_v_j;
        __pyx_t_30 = __pyx_v_k;
        __pyx_t_16 = -1;
        if (__pyx_t_29 < 0) {
          __pyx_t_16 = 0;
        } else if (unlikely(__pyx_t_29 >= __pyx_v_t_mat0.shape[0])) __pyx_t_16 = 0;
        if (__pyx_t_30 < 0) {
          __pyx_t_16 = 1;
        } else if (unlikely(__pyx_t_30 >= __pyx_v_t_mat0.shape[1])) __pyx_t_16 = 1;
        if (unlikely(__pyx_t_16 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_16);
          __PYX_ERR(0, 73, __pyx_L1_error)
        }
        __pyx_t_31 = __pyx_v_k;
        __pyx_t_32 = __pyx_v_i;
        __pyx_t_16 = -1;
        if (__pyx_t_31 < 0) {
          __pyx_t_16 = 0;
        } else if (unlikely(__pyx_t_31 >= __pyx_v_e_prob0.shape[0])) __pyx_t_16 = 0;
        if (__pyx_t_32 < 0) {
          __pyx_t_16 = 1;
        } else if (unlikely(__pyx_t_32 >= __pyx_v_e_prob0.shape[1])) __pyx_t_16 = 1;
        if (unlikely(__pyx_t_16 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_16);
          __PYX_ERR(0, 73, __pyx_L1_error)
        }
        __pyx_t_33 = __pyx_v_k;
        __pyx_t_34 = __pyx_v_i;
        __pyx_t_16 = -1;
        if (__pyx_t_33 < 0) {
          __pyx_t_16 = 0;
        } else if (unlikely(__pyx_t_33 >= __pyx_v_bwd.shape[0])) __pyx_t_16 = 0;
        if (__pyx_t_34 < 0) {
          __pyx_t_16 = 1;
        } else if (unlikely(__pyx_t_34 >= __pyx_v_bwd.shape[1])) __pyx_t_16 = 1;
        if (unlikely(__pyx_t_16 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_16);
          __PYX_ERR(0, 73, __pyx_L1_error)
        }
        __pyx_t_35 = __pyx_v_k;
        __pyx_t_16 = -1;
        if (__pyx_t_35 < 0) {
          __pyx_t_16 = 0;
        } else if (unlikely(__pyx_t_35 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_16 = 0;
        if (unlikely(__pyx_t_16 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_16);
          __PYX_ERR(0, 73, __pyx_L1_error)
        }
        *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_35 * __pyx_v_trans_ll_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_29 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_30 * __pyx_v_t_mat0.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_31 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_32 * __pyx_v_e_prob0.strides[1]) )))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_33 * __pyx_v_bwd.strides[0]) ) + __pyx_t_34 * __pyx_v_bwd.strides[1]) ))));
      }

+074:         bwd[j, i - 1] = logsumexp(trans_ll_view)

      __pyx_t_36 = __pyx_v_j;
      __pyx_t_37 = (__pyx_v_i - 1);
      __pyx_t_13 = -1;
      if (__pyx_t_36 < 0) {
        __pyx_t_13 = 0;
      } else if (unlikely(__pyx_t_36 >= __pyx_v_bwd.shape[0])) __pyx_t_13 = 0;
      if (__pyx_t_37 < 0) {
        __pyx_t_13 = 1;
      } else if (unlikely(__pyx_t_37 >= __pyx_v_bwd.shape[1])) __pyx_t_13 = 1;
      if (unlikely(__pyx_t_13 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_13);
        __PYX_ERR(0, 74, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_36 * __pyx_v_bwd.strides[0]) ) + __pyx_t_37 * __pyx_v_bwd.strides[1]) )) = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);
    }
  }

 075: 

 076:     # Get total log likelihood

+077:     for k in range(n_states):  # Simply sum the two 1D arrays

  __pyx_t_10 = __pyx_v_n_states;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_k = __pyx_t_12;

+078:       trans_ll_view[k] = fwd[k, n_loci-1] + bwd[k, n_loci-1]

    __pyx_t_38 = __pyx_v_k;
    __pyx_t_39 = (__pyx_v_n_loci - 1);
    __pyx_t_13 = -1;
    if (__pyx_t_38 < 0) {
      __pyx_t_13 = 0;
    } else if (unlikely(__pyx_t_38 >= __pyx_v_fwd.shape[0])) __pyx_t_13 = 0;
    if (__pyx_t_39 < 0) {
      __pyx_t_13 = 1;
    } else if (unlikely(__pyx_t_39 >= __pyx_v_fwd.shape[1])) __pyx_t_13 = 1;
    if (unlikely(__pyx_t_13 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_13);
      __PYX_ERR(0, 78, __pyx_L1_error)
    }
    __pyx_t_40 = __pyx_v_k;
    __pyx_t_41 = (__pyx_v_n_loci - 1);
    __pyx_t_13 = -1;
    if (__pyx_t_40 < 0) {
      __pyx_t_13 = 0;
    } else if (unlikely(__pyx_t_40 >= __pyx_v_bwd.shape[0])) __pyx_t_13 = 0;
    if (__pyx_t_41 < 0) {
      __pyx_t_13 = 1;
    } else if (unlikely(__pyx_t_41 >= __pyx_v_bwd.shape[1])) __pyx_t_13 = 1;
    if (unlikely(__pyx_t_13 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_13);
      __PYX_ERR(0, 78, __pyx_L1_error)
    }
    __pyx_t_42 = __pyx_v_k;
    __pyx_t_13 = -1;
    if (__pyx_t_42 < 0) {
      __pyx_t_13 = 0;
    } else if (unlikely(__pyx_t_42 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_13 = 0;
    if (unlikely(__pyx_t_13 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_13);
      __PYX_ERR(0, 78, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_42 * __pyx_v_trans_ll_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_38 * __pyx_v_fwd.strides[0]) ) + __pyx_t_39 * __pyx_v_fwd.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_40 * __pyx_v_bwd.strides[0]) ) + __pyx_t_41 * __pyx_v_bwd.strides[1]) ))));
  }

+079:     tot_ll = logsumexp(trans_ll_view)

  __pyx_v_tot_ll = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);

 080: 

+081:     print(f"Total Log likelihood: {tot_ll: .3f}")

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_kp_u_3f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Total_Log_likelihood, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 082: 

 083:     # Combine the forward and backward calculations

+084:     fwd1 = np.asarray(fwd)  # Transform

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_fwd, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_8)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (!__pyx_t_8) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    {
      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 84, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); __pyx_t_8 = NULL;
      __Pyx_GIVEREF(__pyx_t_2);
      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_fwd1 = __pyx_t_3;
  __pyx_t_3 = 0;

+085:     bwd1 = np.asarray(bwd)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_bwd, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (!__pyx_t_2) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_1};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_1};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    {
      __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 85, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); __pyx_t_2 = NULL;
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_1);
      __pyx_t_1 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_bwd1 = __pyx_t_3;
  __pyx_t_3 = 0;

+086:     post = fwd1 + bwd1 - tot_ll

  __pyx_t_3 = PyNumber_Add(__pyx_v_fwd1, __pyx_v_bwd1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = PyNumber_Subtract(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF_SET(__pyx_v_post, __pyx_t_8);
  __pyx_t_8 = 0;

 087: 

+088:     if full==False:

  __pyx_t_8 = PyObject_RichCompare(__pyx_v_full, Py_False, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 88, __pyx_L1_error)
  __pyx_t_43 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_43 < 0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_43) {
/* … */
  }

+089:       return post

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_post);
    __pyx_r = __pyx_v_post;
    goto __pyx_L0;

 090: 

+091:     elif full==True:   # Return everything

  __pyx_t_8 = PyObject_RichCompare(__pyx_v_full, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error)
  __pyx_t_43 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_43 < 0)) __PYX_ERR(0, 91, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_43) {
/* … */
  }

+092:       return post, fwd1, bwd1, tot_ll

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_8 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 92, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_post);
    __Pyx_GIVEREF(__pyx_v_post);
    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_post);
    __Pyx_INCREF(__pyx_v_fwd1);
    __Pyx_GIVEREF(__pyx_v_fwd1);
    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_fwd1);
    __Pyx_INCREF(__pyx_v_bwd1);
    __Pyx_GIVEREF(__pyx_v_bwd1);
    PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_bwd1);
    __Pyx_GIVEREF(__pyx_t_8);
    PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_8);
    __pyx_t_8 = 0;
    __pyx_r = __pyx_t_6;
    __pyx_t_6 = 0;
    goto __pyx_L0;

 093: 

 094: 

+095: def fwd_bkwd_fast(double[:, :] e_prob0, double[:, :] t_mat,

/* Python wrapper */
static PyObject *__pyx_pw_5cfunc_5fwd_bkwd_fast(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_5cfunc_4fwd_bkwd_fast[] = "Takes emission and transition probabilities, and calculates posteriors.\n    Uses speed-up specific for Genotype data (pooling same transition rates)\n    Input:\n    Emission probabilities [k x l] (log space)       (log space)\n    Transition probabilities (infinitesimal) [k x k] (normal space)\n    Initialized fwd and bwd probabilities [k x l]    (log space)\n    t: Transition Matrix: [l x 3 x 3]                     (normal space)\n    full: Boolean whether to return everything";
static PyMethodDef __pyx_mdef_5cfunc_5fwd_bkwd_fast = {"fwd_bkwd_fast", (PyCFunction)__pyx_pw_5cfunc_5fwd_bkwd_fast, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5cfunc_4fwd_bkwd_fast};
static PyObject *__pyx_pw_5cfunc_5fwd_bkwd_fast(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  __Pyx_memviewslice __pyx_v_e_prob0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t_mat = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t = { 0, 0, { 0 }, { 0 }, { 0 } };
  double __pyx_v_in_val;
  PyObject *__pyx_v_full = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd_fast (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_e_prob0,&__pyx_n_s_t_mat,&__pyx_n_s_t,&__pyx_n_s_in_val,&__pyx_n_s_full,0};
    PyObject* values[5] = {0,0,0,0,0};
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5cfunc_4fwd_bkwd_fast(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_e_prob0, CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t_mat, __Pyx_memviewslice __pyx_v_t, double __pyx_v_in_val, PyObject *__pyx_v_full) {
  int __pyx_v_n_states;
  int __pyx_v_n_loci;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_j;
  Py_ssize_t __pyx_v_k;
  double __pyx_v_stay;
  PyObject *__pyx_v_post = NULL;
  PyObject *__pyx_v_trans_ll = NULL;
  __Pyx_memviewslice __pyx_v_trans_ll_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_trans_ll1 = NULL;
  __Pyx_memviewslice __pyx_v_trans_ll_view1 = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_three_v = NULL;
  __Pyx_memviewslice __pyx_v_three_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_two_v = NULL;
  __Pyx_memviewslice __pyx_v_two_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_fwd0 = NULL;
  __Pyx_memviewslice __pyx_v_fwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_bwd0 = NULL;
  __Pyx_memviewslice __pyx_v_bwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  double __pyx_v_f_l;
  double __pyx_v_tot_ll;
  PyObject *__pyx_v_fwd1 = NULL;
  PyObject *__pyx_v_bwd1 = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd_fast", 0);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __Pyx_XDECREF(__pyx_t_6);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __Pyx_XDECREF(__pyx_t_105);
  __Pyx_AddTraceback("cfunc.fwd_bkwd_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_post);
  __Pyx_XDECREF(__pyx_v_trans_ll);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view, 1);
  __Pyx_XDECREF(__pyx_v_trans_ll1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view1, 1);
  __Pyx_XDECREF(__pyx_v_three_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_three_v_view, 1);
  __Pyx_XDECREF(__pyx_v_two_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_two_v_view, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t0, 1);
  __Pyx_XDECREF(__pyx_v_fwd0);
  __PYX_XDEC_MEMVIEW(&__pyx_v_fwd, 1);
  __Pyx_XDECREF(__pyx_v_bwd0);
  __PYX_XDEC_MEMVIEW(&__pyx_v_bwd, 1);
  __Pyx_XDECREF(__pyx_v_fwd1);
  __Pyx_XDECREF(__pyx_v_bwd1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_e_prob0, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t_mat, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__47 = PyTuple_Pack(29, __pyx_n_s_e_prob0, __pyx_n_s_t_mat, __pyx_n_s_t, __pyx_n_s_in_val, __pyx_n_s_full, __pyx_n_s_n_states, __pyx_n_s_n_loci, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_stay, __pyx_n_s_post, __pyx_n_s_trans_ll, __pyx_n_s_trans_ll_view, __pyx_n_s_trans_ll1, __pyx_n_s_trans_ll_view1, __pyx_n_s_three_v, __pyx_n_s_three_v_view, __pyx_n_s_two_v, __pyx_n_s_two_v_view, __pyx_n_s_t0, __pyx_n_s_fwd0, __pyx_n_s_fwd, __pyx_n_s_bwd0, __pyx_n_s_bwd, __pyx_n_s_f_l, __pyx_n_s_tot_ll, __pyx_n_s_fwd1, __pyx_n_s_bwd1); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__47);
  __Pyx_GIVEREF(__pyx_tuple__47);
/* … */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5cfunc_5fwd_bkwd_fast, NULL, __pyx_n_s_cfunc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fwd_bkwd_fast, __pyx_t_2) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(5, 0, 29, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cfunc_pyx, __pyx_n_s_fwd_bkwd_fast, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 95, __pyx_L1_error)

+096:     double[:, :, :] t, double in_val = 1e-4, full=False):

    values[4] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_e_prob0)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_mat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd_fast", 0, 3, 5, 1); __PYX_ERR(0, 95, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd_fast", 0, 3, 5, 2); __PYX_ERR(0, 95, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_val);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_full);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fwd_bkwd_fast") < 0)) __PYX_ERR(0, 95, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_e_prob0 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_e_prob0.memview)) __PYX_ERR(0, 95, __pyx_L3_error)
    __pyx_v_t_mat = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_mat.memview)) __PYX_ERR(0, 95, __pyx_L3_error)
    __pyx_v_t = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t.memview)) __PYX_ERR(0, 96, __pyx_L3_error)
    if (values[3]) {
      __pyx_v_in_val = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_in_val == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error)
    } else {
      __pyx_v_in_val = ((double)1e-4);
    }
    __pyx_v_full = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fwd_bkwd_fast", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 95, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("cfunc.fwd_bkwd_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_5cfunc_4fwd_bkwd_fast(__pyx_self, __pyx_v_e_prob0, __pyx_v_t_mat, __pyx_v_t, __pyx_v_in_val, __pyx_v_full);

 097:     """Takes emission and transition probabilities, and calculates posteriors.

 098:     Uses speed-up specific for Genotype data (pooling same transition rates)

 099:     Input:

 100:     Emission probabilities [k x l] (log space)       (log space)

 101:     Transition probabilities (infinitesimal) [k x k] (normal space)

 102:     Initialized fwd and bwd probabilities [k x l]    (log space)

 103:     t: Transition Matrix: [l x 3 x 3]                     (normal space)

 104:     full: Boolean whether to return everything"""

+105:     cdef int n_states = e_prob0.shape[0]

  __pyx_v_n_states = (__pyx_v_e_prob0.shape[0]);

+106:     cdef int n_loci = e_prob0.shape[1]

  __pyx_v_n_loci = (__pyx_v_e_prob0.shape[1]);

 107:     cdef Py_ssize_t i, j, k    # The Array Indices

 108:     cdef double stay           # The Probablility of Staying

 109: 

 110:     # Initialize Posterior and Transition Probabilities

+111:     post = np.empty([n_states, n_loci], dtype=DTYPE)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_post = __pyx_t_1;
  __pyx_t_1 = 0;

 112: 

+113:     trans_ll = np.empty(n_states-1, dtype=DTYPE) # Array for pre-calculations

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_long((__pyx_v_n_states - 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_trans_ll = __pyx_t_2;
  __pyx_t_2 = 0;

+114:     cdef double[:] trans_ll_view = trans_ll

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 114, __pyx_L1_error)
  __pyx_v_trans_ll_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 115: 

+116:     trans_ll1 = np.empty(n_states, dtype=DTYPE) # Array for calculations

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_trans_ll1 = __pyx_t_4;
  __pyx_t_4 = 0;

+117:     cdef double[:] trans_ll_view1 = trans_ll1

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 117, __pyx_L1_error)
  __pyx_v_trans_ll_view1 = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 118: 

+119:     three_v = np.empty(3, dtype=DTYPE)     # Array of size three

  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple_, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_three_v = __pyx_t_3;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

+120:     cdef double[:] three_v_view = three_v

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_three_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 120, __pyx_L1_error)
  __pyx_v_three_v_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 121: 

+122:     two_v = np.empty(2, dtype=DTYPE)       # Array of size two

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_two_v = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_int_2); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

+123:     cdef double[:] two_v_view = two_v

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_two_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 123, __pyx_L1_error)
  __pyx_v_two_v_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 124: 

 125:     # Do transform to Log Space:

+126:     cdef double[:,:,:] t0 = np.log(t)         # Do log of recombination Map

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_t, 3, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  if (!__pyx_t_1) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    {
      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __pyx_t_1 = NULL;
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_t0 = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 127: 

 128:     ### Initialize FWD BWD matrices

+129:     fwd0 = np.zeros((n_states, n_loci), dtype="float")

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6);
  __pyx_t_2 = 0;
  __pyx_t_6 = 0;
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_n_u_float) < 0) __PYX_ERR(0, 129, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_fwd0 = __pyx_t_2;
  __pyx_t_2 = 0;

+130:     fwd0[:, 0] = np.log(in_val)  # Initial Probabilities

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_in_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (!__pyx_t_4) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    {
      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL;
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* … */
  __pyx_slice__3 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__3);
  __Pyx_GIVEREF(__pyx_slice__3);
  if (unlikely(PyObject_SetItem(__pyx_v_fwd0, __pyx_tuple__4, __pyx_t_2) < 0)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice__3, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);

+131:     fwd0[0, 0] = np.log(1 - (n_states - 1) * in_val)

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble((1.0 - ((__pyx_v_n_states - 1) * __pyx_v_in_val))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (!__pyx_t_3) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(PyObject_SetItem(__pyx_v_fwd0, __pyx_tuple__5, __pyx_t_2) < 0)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_tuple__5 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

+132:     cdef double[:,:] fwd = fwd0

  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_fwd0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 132, __pyx_L1_error)
  __pyx_v_fwd = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

 133: 

+134:     bwd0 = np.zeros((n_states, n_loci), dtype="float")

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_n_u_float) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_bwd0 = __pyx_t_2;
  __pyx_t_2 = 0;

+135:     bwd0[:, -1] = np.log(in_val)

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_in_val); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  if (!__pyx_t_1) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    {
      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __pyx_t_1 = NULL;
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_slice__6 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__6)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__6);
  __Pyx_GIVEREF(__pyx_slice__6);
  if (unlikely(PyObject_SetItem(__pyx_v_bwd0, __pyx_tuple__7, __pyx_t_2) < 0)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_slice__6, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

+136:     bwd0[0, -1] = np.log(1 - (n_states - 1) * in_val)

  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble((1.0 - ((__pyx_v_n_states - 1) * __pyx_v_in_val))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_6)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  if (!__pyx_t_6) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else
    #endif
    {
      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL;
      __Pyx_GIVEREF(__pyx_t_4);
      PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(PyObject_SetItem(__pyx_v_bwd0, __pyx_tuple__8, __pyx_t_2) < 0)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

+137:     cdef double[:,:] bwd = bwd0

  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_bwd0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 137, __pyx_L1_error)
  __pyx_v_bwd = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

 138: 

 139:     #############################

 140:     ### Do the Forward Algorithm

+141:     for i in range(1, n_loci):  # Run forward recursion

  __pyx_t_9 = __pyx_v_n_loci;
  __pyx_t_10 = __pyx_t_9;
  for (__pyx_t_11 = 1; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
    __pyx_v_i = __pyx_t_11;

+142:         stay = log(t[i, 1, 1] - t[i, 1, 2])  # Do the log of the Stay term

    __pyx_t_12 = __pyx_v_i;
    __pyx_t_13 = 1;
    __pyx_t_14 = 1;
    __pyx_t_15 = -1;
    if (__pyx_t_12 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_12 >= __pyx_v_t.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_13 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_13 >= __pyx_v_t.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_14 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_14 >= __pyx_v_t.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 142, __pyx_L1_error)
    }
    __pyx_t_16 = __pyx_v_i;
    __pyx_t_17 = 1;
    __pyx_t_18 = 2;
    __pyx_t_15 = -1;
    if (__pyx_t_16 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_16 >= __pyx_v_t.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_17 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_17 >= __pyx_v_t.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_18 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_18 >= __pyx_v_t.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 142, __pyx_L1_error)
    }
    __pyx_v_stay = log(((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_12 * __pyx_v_t.strides[0]) ) + __pyx_t_13 * __pyx_v_t.strides[1]) ) + __pyx_t_14 * __pyx_v_t.strides[2]) ))) - (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_16 * __pyx_v_t.strides[0]) ) + __pyx_t_17 * __pyx_v_t.strides[1]) ) + __pyx_t_18 * __pyx_v_t.strides[2]) )))));

 143: 

+144:         for k in range(1, n_states): # Calculate logsum of ROH states:

    __pyx_t_15 = __pyx_v_n_states;
    __pyx_t_19 = __pyx_t_15;
    for (__pyx_t_20 = 1; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
      __pyx_v_k = __pyx_t_20;

+145:             trans_ll_view[k-1] = fwd[k, i - 1]

      __pyx_t_21 = __pyx_v_k;
      __pyx_t_22 = (__pyx_v_i - 1);
      __pyx_t_23 = -1;
      if (__pyx_t_21 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (__pyx_t_22 < 0) {
        __pyx_t_23 = 1;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_fwd.shape[1])) __pyx_t_23 = 1;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 145, __pyx_L1_error)
      }
      __pyx_t_24 = (__pyx_v_k - 1);
      __pyx_t_23 = -1;
      if (__pyx_t_24 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_24 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 145, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_24 * __pyx_v_trans_ll_view.strides[0]) )) = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_21 * __pyx_v_fwd.strides[0]) ) + __pyx_t_22 * __pyx_v_fwd.strides[1]) )));
    }

+146:         f_l = logsumexp(trans_ll_view) # Logsum of ROH States

    __pyx_v_f_l = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);

 147: 

 148:         # Do the 0 State:

+149:         two_v_view[0] = fwd[0, i - 1] + t0[i, 0, 0]   # Staying in 0 State

    __pyx_t_25 = 0;
    __pyx_t_26 = (__pyx_v_i - 1);
    __pyx_t_15 = -1;
    if (__pyx_t_25 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_25 >= __pyx_v_fwd.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_26 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_26 >= __pyx_v_fwd.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 149, __pyx_L1_error)
    }
    __pyx_t_27 = __pyx_v_i;
    __pyx_t_28 = 0;
    __pyx_t_29 = 0;
    __pyx_t_15 = -1;
    if (__pyx_t_27 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_27 >= __pyx_v_t0.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_28 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_28 >= __pyx_v_t0.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_29 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_29 >= __pyx_v_t0.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 149, __pyx_L1_error)
    }
    __pyx_t_30 = 0;
    __pyx_t_15 = -1;
    if (__pyx_t_30 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_30 >= __pyx_v_two_v_view.shape[0])) __pyx_t_15 = 0;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 149, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_30 * __pyx_v_two_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_25 * __pyx_v_fwd.strides[0]) ) + __pyx_t_26 * __pyx_v_fwd.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_27 * __pyx_v_t0.strides[0]) ) + __pyx_t_28 * __pyx_v_t0.strides[1]) ) + __pyx_t_29 * __pyx_v_t0.strides[2]) ))));

+150:         two_v_view[1] = f_l + t0[i, 1, 0]             # Going into 0 State

    __pyx_t_31 = __pyx_v_i;
    __pyx_t_32 = 1;
    __pyx_t_33 = 0;
    __pyx_t_15 = -1;
    if (__pyx_t_31 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_31 >= __pyx_v_t0.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_32 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_32 >= __pyx_v_t0.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_33 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_33 >= __pyx_v_t0.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 150, __pyx_L1_error)
    }
    __pyx_t_34 = 1;
    __pyx_t_15 = -1;
    if (__pyx_t_34 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_34 >= __pyx_v_two_v_view.shape[0])) __pyx_t_15 = 0;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 150, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_34 * __pyx_v_two_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_31 * __pyx_v_t0.strides[0]) ) + __pyx_t_32 * __pyx_v_t0.strides[1]) ) + __pyx_t_33 * __pyx_v_t0.strides[2]) ))));

+151:         fwd[0, i] = e_prob0[0, i] + logsumexp(two_v_view)

    __pyx_t_35 = 0;
    __pyx_t_36 = __pyx_v_i;
    __pyx_t_15 = -1;
    if (__pyx_t_35 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_35 >= __pyx_v_e_prob0.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_36 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_36 >= __pyx_v_e_prob0.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 151, __pyx_L1_error)
    }
    __pyx_t_37 = 0;
    __pyx_t_38 = __pyx_v_i;
    __pyx_t_15 = -1;
    if (__pyx_t_37 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_37 >= __pyx_v_fwd.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_38 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_38 >= __pyx_v_fwd.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 151, __pyx_L1_error)
    }
    *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_37 * __pyx_v_fwd.strides[0]) ) + __pyx_t_38 * __pyx_v_fwd.strides[1]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_35 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_36 * __pyx_v_e_prob0.strides[1]) ))) + __pyx_f_5cfunc_logsumexp(__pyx_v_two_v_view));

 152: 

 153:         ### Do the other states

 154:         # Preprocessing:

+155:         three_v_view[0] = fwd[0, i - 1] + t0[i, 0, 1]   # Coming from 0 State

    __pyx_t_39 = 0;
    __pyx_t_40 = (__pyx_v_i - 1);
    __pyx_t_15 = -1;
    if (__pyx_t_39 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_39 >= __pyx_v_fwd.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_40 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_40 >= __pyx_v_fwd.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 155, __pyx_L1_error)
    }
    __pyx_t_41 = __pyx_v_i;
    __pyx_t_42 = 0;
    __pyx_t_43 = 1;
    __pyx_t_15 = -1;
    if (__pyx_t_41 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_41 >= __pyx_v_t0.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_42 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_42 >= __pyx_v_t0.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_43 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_43 >= __pyx_v_t0.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 155, __pyx_L1_error)
    }
    __pyx_t_44 = 0;
    __pyx_t_15 = -1;
    if (__pyx_t_44 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_44 >= __pyx_v_three_v_view.shape[0])) __pyx_t_15 = 0;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 155, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_44 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_39 * __pyx_v_fwd.strides[0]) ) + __pyx_t_40 * __pyx_v_fwd.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_41 * __pyx_v_t0.strides[0]) ) + __pyx_t_42 * __pyx_v_t0.strides[1]) ) + __pyx_t_43 * __pyx_v_t0.strides[2]) ))));

+156:         three_v_view[1] = f_l + t0[i, 1, 2]             # Coming from other ROH State

    __pyx_t_45 = __pyx_v_i;
    __pyx_t_46 = 1;
    __pyx_t_47 = 2;
    __pyx_t_15 = -1;
    if (__pyx_t_45 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_45 >= __pyx_v_t0.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_46 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_46 >= __pyx_v_t0.shape[1])) __pyx_t_15 = 1;
    if (__pyx_t_47 < 0) {
      __pyx_t_15 = 2;
    } else if (unlikely(__pyx_t_47 >= __pyx_v_t0.shape[2])) __pyx_t_15 = 2;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 156, __pyx_L1_error)
    }
    __pyx_t_48 = 1;
    __pyx_t_15 = -1;
    if (__pyx_t_48 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_48 >= __pyx_v_three_v_view.shape[0])) __pyx_t_15 = 0;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 156, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_48 * __pyx_v_three_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_45 * __pyx_v_t0.strides[0]) ) + __pyx_t_46 * __pyx_v_t0.strides[1]) ) + __pyx_t_47 * __pyx_v_t0.strides[2]) ))));

 157: 

+158:         for j in range(1, n_states):  # Do the final run over all states

    __pyx_t_15 = __pyx_v_n_states;
    __pyx_t_19 = __pyx_t_15;
    for (__pyx_t_20 = 1; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
      __pyx_v_j = __pyx_t_20;

+159:           three_v_view[2] = fwd[j, i-1] +  stay

      __pyx_t_49 = __pyx_v_j;
      __pyx_t_50 = (__pyx_v_i - 1);
      __pyx_t_23 = -1;
      if (__pyx_t_49 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_49 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (__pyx_t_50 < 0) {
        __pyx_t_23 = 1;
      } else if (unlikely(__pyx_t_50 >= __pyx_v_fwd.shape[1])) __pyx_t_23 = 1;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 159, __pyx_L1_error)
      }
      __pyx_t_51 = 2;
      __pyx_t_23 = -1;
      if (__pyx_t_51 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_51 >= __pyx_v_three_v_view.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 159, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_51 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_49 * __pyx_v_fwd.strides[0]) ) + __pyx_t_50 * __pyx_v_fwd.strides[1]) ))) + __pyx_v_stay);

+160:           fwd[j, i] = e_prob0[j, i] + logsumexp(three_v_view)

      __pyx_t_52 = __pyx_v_j;
      __pyx_t_53 = __pyx_v_i;
      __pyx_t_23 = -1;
      if (__pyx_t_52 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_52 >= __pyx_v_e_prob0.shape[0])) __pyx_t_23 = 0;
      if (__pyx_t_53 < 0) {
        __pyx_t_23 = 1;
      } else if (unlikely(__pyx_t_53 >= __pyx_v_e_prob0.shape[1])) __pyx_t_23 = 1;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 160, __pyx_L1_error)
      }
      __pyx_t_54 = __pyx_v_j;
      __pyx_t_55 = __pyx_v_i;
      __pyx_t_23 = -1;
      if (__pyx_t_54 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_54 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (__pyx_t_55 < 0) {
        __pyx_t_23 = 1;
      } else if (unlikely(__pyx_t_55 >= __pyx_v_fwd.shape[1])) __pyx_t_23 = 1;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 160, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_54 * __pyx_v_fwd.strides[0]) ) + __pyx_t_55 * __pyx_v_fwd.strides[1]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_52 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_53 * __pyx_v_e_prob0.strides[1]) ))) + __pyx_f_5cfunc_logsumexp(__pyx_v_three_v_view));
    }
  }

 161: 

 162:     #############################

 163:     ### Do the Backward Algorithm

+164:     for i in range(n_loci-1, 0, -1):  # Run backward recursion

  for (__pyx_t_11 = (__pyx_v_n_loci - 1); __pyx_t_11 > 0; __pyx_t_11-=1) {
    __pyx_v_i = __pyx_t_11;

+165:       stay = log(t[i, 1, 1] - t[i, 1, 2])

    __pyx_t_56 = __pyx_v_i;
    __pyx_t_57 = 1;
    __pyx_t_58 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_56 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_56 >= __pyx_v_t.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_57 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_57 >= __pyx_v_t.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_58 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_58 >= __pyx_v_t.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 165, __pyx_L1_error)
    }
    __pyx_t_59 = __pyx_v_i;
    __pyx_t_60 = 1;
    __pyx_t_61 = 2;
    __pyx_t_9 = -1;
    if (__pyx_t_59 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_59 >= __pyx_v_t.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_60 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_60 >= __pyx_v_t.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_61 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_61 >= __pyx_v_t.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 165, __pyx_L1_error)
    }
    __pyx_v_stay = log(((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_56 * __pyx_v_t.strides[0]) ) + __pyx_t_57 * __pyx_v_t.strides[1]) ) + __pyx_t_58 * __pyx_v_t.strides[2]) ))) - (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_59 * __pyx_v_t.strides[0]) ) + __pyx_t_60 * __pyx_v_t.strides[1]) ) + __pyx_t_61 * __pyx_v_t.strides[2]) )))));

 166: 

+167:       for k in range(1, n_states): # Calculate logsum of ROH states:

    __pyx_t_9 = __pyx_v_n_states;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_20 = 1; __pyx_t_20 < __pyx_t_10; __pyx_t_20+=1) {
      __pyx_v_k = __pyx_t_20;

+168:           trans_ll_view[k-1] = bwd[k, i] + e_prob0[k, i]

      __pyx_t_62 = __pyx_v_k;
      __pyx_t_63 = __pyx_v_i;
      __pyx_t_15 = -1;
      if (__pyx_t_62 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_62 >= __pyx_v_bwd.shape[0])) __pyx_t_15 = 0;
      if (__pyx_t_63 < 0) {
        __pyx_t_15 = 1;
      } else if (unlikely(__pyx_t_63 >= __pyx_v_bwd.shape[1])) __pyx_t_15 = 1;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 168, __pyx_L1_error)
      }
      __pyx_t_64 = __pyx_v_k;
      __pyx_t_65 = __pyx_v_i;
      __pyx_t_15 = -1;
      if (__pyx_t_64 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_64 >= __pyx_v_e_prob0.shape[0])) __pyx_t_15 = 0;
      if (__pyx_t_65 < 0) {
        __pyx_t_15 = 1;
      } else if (unlikely(__pyx_t_65 >= __pyx_v_e_prob0.shape[1])) __pyx_t_15 = 1;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 168, __pyx_L1_error)
      }
      __pyx_t_66 = (__pyx_v_k - 1);
      __pyx_t_15 = -1;
      if (__pyx_t_66 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_66 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_15 = 0;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 168, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_66 * __pyx_v_trans_ll_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_62 * __pyx_v_bwd.strides[0]) ) + __pyx_t_63 * __pyx_v_bwd.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_64 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_65 * __pyx_v_e_prob0.strides[1]) ))));
    }

+169:       f_l = logsumexp(trans_ll_view) # Logsum of ROH States

    __pyx_v_f_l = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);

 170: 

 171:       # Do the 0 State:

+172:       two_v_view[0] = bwd[0, i] + t0[i, 0, 0] + e_prob0[0, i]   # Staying in 0 State

    __pyx_t_67 = 0;
    __pyx_t_68 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_67 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_67 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_68 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_68 >= __pyx_v_bwd.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 172, __pyx_L1_error)
    }
    __pyx_t_69 = __pyx_v_i;
    __pyx_t_70 = 0;
    __pyx_t_71 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_69 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_69 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_70 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_70 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_71 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_71 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 172, __pyx_L1_error)
    }
    __pyx_t_72 = 0;
    __pyx_t_73 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_72 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_72 >= __pyx_v_e_prob0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_73 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_73 >= __pyx_v_e_prob0.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 172, __pyx_L1_error)
    }
    __pyx_t_74 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_74 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_74 >= __pyx_v_two_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 172, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_74 * __pyx_v_two_v_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_67 * __pyx_v_bwd.strides[0]) ) + __pyx_t_68 * __pyx_v_bwd.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_69 * __pyx_v_t0.strides[0]) ) + __pyx_t_70 * __pyx_v_t0.strides[1]) ) + __pyx_t_71 * __pyx_v_t0.strides[2]) )))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_72 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_73 * __pyx_v_e_prob0.strides[1]) ))));

+173:       two_v_view[1] = f_l + t0[i, 0, 1]                         # Going into 0 State

    __pyx_t_75 = __pyx_v_i;
    __pyx_t_76 = 0;
    __pyx_t_77 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_75 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_75 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_76 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_76 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_77 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_77 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 173, __pyx_L1_error)
    }
    __pyx_t_78 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_78 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_78 >= __pyx_v_two_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 173, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_78 * __pyx_v_two_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_75 * __pyx_v_t0.strides[0]) ) + __pyx_t_76 * __pyx_v_t0.strides[1]) ) + __pyx_t_77 * __pyx_v_t0.strides[2]) ))));

+174:       bwd[0, i - 1] = logsumexp(two_v_view)

    __pyx_t_79 = 0;
    __pyx_t_80 = (__pyx_v_i - 1);
    __pyx_t_9 = -1;
    if (__pyx_t_79 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_79 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_80 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_80 >= __pyx_v_bwd.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 174, __pyx_L1_error)
    }
    *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_79 * __pyx_v_bwd.strides[0]) ) + __pyx_t_80 * __pyx_v_bwd.strides[1]) )) = __pyx_f_5cfunc_logsumexp(__pyx_v_two_v_view);

 175: 

 176:       ### Do the other states

 177:       # Preprocessing:

+178:       three_v_view[0] = e_prob0[0, i] + bwd[0, i] + t0[i, 1, 0]

    __pyx_t_81 = 0;
    __pyx_t_82 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_81 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_81 >= __pyx_v_e_prob0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_82 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_82 >= __pyx_v_e_prob0.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 178, __pyx_L1_error)
    }
    __pyx_t_83 = 0;
    __pyx_t_84 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_83 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_83 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_84 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_84 >= __pyx_v_bwd.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 178, __pyx_L1_error)
    }
    __pyx_t_85 = __pyx_v_i;
    __pyx_t_86 = 1;
    __pyx_t_87 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_85 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_85 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_86 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_86 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_87 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_87 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 178, __pyx_L1_error)
    }
    __pyx_t_88 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_88 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_88 >= __pyx_v_three_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 178, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_88 * __pyx_v_three_v_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_81 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_82 * __pyx_v_e_prob0.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_83 * __pyx_v_bwd.strides[0]) ) + __pyx_t_84 * __pyx_v_bwd.strides[1]) )))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_85 * __pyx_v_t0.strides[0]) ) + __pyx_t_86 * __pyx_v_t0.strides[1]) ) + __pyx_t_87 * __pyx_v_t0.strides[2]) ))));

+179:       three_v_view[1] = f_l + t0[i, 1, 2]    # Coming from other ROH State

    __pyx_t_89 = __pyx_v_i;
    __pyx_t_90 = 1;
    __pyx_t_91 = 2;
    __pyx_t_9 = -1;
    if (__pyx_t_89 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_89 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_90 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_90 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_91 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_91 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 179, __pyx_L1_error)
    }
    __pyx_t_92 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_92 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_92 >= __pyx_v_three_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 179, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_92 * __pyx_v_three_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_89 * __pyx_v_t0.strides[0]) ) + __pyx_t_90 * __pyx_v_t0.strides[1]) ) + __pyx_t_91 * __pyx_v_t0.strides[2]) ))));

 180: 

+181:       for j in range(1, n_states):  # Do the final run over all states

    __pyx_t_9 = __pyx_v_n_states;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_20 = 1; __pyx_t_20 < __pyx_t_10; __pyx_t_20+=1) {
      __pyx_v_j = __pyx_t_20;

+182:         three_v_view[2] = e_prob0[j, i] + bwd[j, i] +  stay

      __pyx_t_93 = __pyx_v_j;
      __pyx_t_94 = __pyx_v_i;
      __pyx_t_15 = -1;
      if (__pyx_t_93 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_93 >= __pyx_v_e_prob0.shape[0])) __pyx_t_15 = 0;
      if (__pyx_t_94 < 0) {
        __pyx_t_15 = 1;
      } else if (unlikely(__pyx_t_94 >= __pyx_v_e_prob0.shape[1])) __pyx_t_15 = 1;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 182, __pyx_L1_error)
      }
      __pyx_t_95 = __pyx_v_j;
      __pyx_t_96 = __pyx_v_i;
      __pyx_t_15 = -1;
      if (__pyx_t_95 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_95 >= __pyx_v_bwd.shape[0])) __pyx_t_15 = 0;
      if (__pyx_t_96 < 0) {
        __pyx_t_15 = 1;
      } else if (unlikely(__pyx_t_96 >= __pyx_v_bwd.shape[1])) __pyx_t_15 = 1;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 182, __pyx_L1_error)
      }
      __pyx_t_97 = 2;
      __pyx_t_15 = -1;
      if (__pyx_t_97 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_97 >= __pyx_v_three_v_view.shape[0])) __pyx_t_15 = 0;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 182, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_97 * __pyx_v_three_v_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_93 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_94 * __pyx_v_e_prob0.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_95 * __pyx_v_bwd.strides[0]) ) + __pyx_t_96 * __pyx_v_bwd.strides[1]) )))) + __pyx_v_stay);

+183:         bwd[j, i - 1] = logsumexp(three_v_view)  # Fill in the backward Probability

      __pyx_t_98 = __pyx_v_j;
      __pyx_t_99 = (__pyx_v_i - 1);
      __pyx_t_15 = -1;
      if (__pyx_t_98 < 0) {
        __pyx_t_15 = 0;
      } else if (unlikely(__pyx_t_98 >= __pyx_v_bwd.shape[0])) __pyx_t_15 = 0;
      if (__pyx_t_99 < 0) {
        __pyx_t_15 = 1;
      } else if (unlikely(__pyx_t_99 >= __pyx_v_bwd.shape[1])) __pyx_t_15 = 1;
      if (unlikely(__pyx_t_15 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_15);
        __PYX_ERR(0, 183, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_98 * __pyx_v_bwd.strides[0]) ) + __pyx_t_99 * __pyx_v_bwd.strides[1]) )) = __pyx_f_5cfunc_logsumexp(__pyx_v_three_v_view);
    }
  }

 184: 

 185:     # Get total log likelihood

+186:     for k in range(n_states):  # Simply sum the two 1D arrays

  __pyx_t_9 = __pyx_v_n_states;
  __pyx_t_10 = __pyx_t_9;
  for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
    __pyx_v_k = __pyx_t_11;

+187:       trans_ll_view1[k] = fwd[k, n_loci - 1] + bwd[k, n_loci - 1]

    __pyx_t_100 = __pyx_v_k;
    __pyx_t_101 = (__pyx_v_n_loci - 1);
    __pyx_t_15 = -1;
    if (__pyx_t_100 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_100 >= __pyx_v_fwd.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_101 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_101 >= __pyx_v_fwd.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 187, __pyx_L1_error)
    }
    __pyx_t_102 = __pyx_v_k;
    __pyx_t_103 = (__pyx_v_n_loci - 1);
    __pyx_t_15 = -1;
    if (__pyx_t_102 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_102 >= __pyx_v_bwd.shape[0])) __pyx_t_15 = 0;
    if (__pyx_t_103 < 0) {
      __pyx_t_15 = 1;
    } else if (unlikely(__pyx_t_103 >= __pyx_v_bwd.shape[1])) __pyx_t_15 = 1;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 187, __pyx_L1_error)
    }
    __pyx_t_104 = __pyx_v_k;
    __pyx_t_15 = -1;
    if (__pyx_t_104 < 0) {
      __pyx_t_15 = 0;
    } else if (unlikely(__pyx_t_104 >= __pyx_v_trans_ll_view1.shape[0])) __pyx_t_15 = 0;
    if (unlikely(__pyx_t_15 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_15);
      __PYX_ERR(0, 187, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view1.data + __pyx_t_104 * __pyx_v_trans_ll_view1.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_100 * __pyx_v_fwd.strides[0]) ) + __pyx_t_101 * __pyx_v_fwd.strides[1]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_102 * __pyx_v_bwd.strides[0]) ) + __pyx_t_103 * __pyx_v_bwd.strides[1]) ))));
  }

+188:     tot_ll = logsumexp(trans_ll_view1)

  __pyx_v_tot_ll = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view1);

 189: 

 190:     # Combine the forward and backward calculations

+191:     fwd1 = np.asarray(fwd, dtype=np.float)  # Transform

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_fwd, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_fwd1 = __pyx_t_6;
  __pyx_t_6 = 0;

+192:     bwd1 = np.asarray(bwd, dtype=np.float)

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_asarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_bwd, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_bwd1 = __pyx_t_4;
  __pyx_t_4 = 0;

+193:     post = fwd1 + bwd1 - np.float(tot_ll)

  __pyx_t_4 = PyNumber_Add(__pyx_v_fwd1, __pyx_v_bwd1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  if (!__pyx_t_3) {
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GOTREF(__pyx_t_6);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    {
      __pyx_t_105 = PyTuple_New(1+1); if (unlikely(!__pyx_t_105)) __PYX_ERR(0, 193, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_105);
      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_105, 0, __pyx_t_3); __pyx_t_3 = NULL;
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_105, 0+1, __pyx_t_1);
      __pyx_t_1 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_105, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_105); __pyx_t_105 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF_SET(__pyx_v_post, __pyx_t_2);
  __pyx_t_2 = 0;

 194: 

+195:     print("Memory Usage Full:")

  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Memory_Usage_Full); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

+196:     print_memory_usage()   ## For MEMORY_BENCH

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_print_memory_usage); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (__pyx_t_4) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error)
  }
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+197:     print(f"Total Log likelihood: {tot_ll: .3f}")

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_kp_u_3f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Total_Log_likelihood, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 198: 

+199:     if full==False:

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_full, Py_False, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
  __pyx_t_106 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_106 < 0)) __PYX_ERR(0, 199, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_106) {
/* … */
  }

+200:       return post

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_post);
    __pyx_r = __pyx_v_post;
    goto __pyx_L0;

 201: 

+202:     elif full==True:   # Return everything

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_full, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 202, __pyx_L1_error)
  __pyx_t_106 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_106 < 0)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_106) {
/* … */
  }

+203:       return post, fwd1, bwd1, tot_ll

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_post);
    __Pyx_GIVEREF(__pyx_v_post);
    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_post);
    __Pyx_INCREF(__pyx_v_fwd1);
    __Pyx_GIVEREF(__pyx_v_fwd1);
    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_fwd1);
    __Pyx_INCREF(__pyx_v_bwd1);
    __Pyx_GIVEREF(__pyx_v_bwd1);
    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_bwd1);
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6);
    __pyx_t_6 = 0;
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 204: 

 205: 

+206: def fwd_bkwd_lowmem(double[:, :] e_prob0, double[:, :] t_mat,

/* Python wrapper */
static PyObject *__pyx_pw_5cfunc_7fwd_bkwd_lowmem(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_5cfunc_6fwd_bkwd_lowmem[] = "Takes emission and transition probabilities, and calculates posteriors.\n    Uses speed-up specific for Genotype data (pooling same transition rates)\n    Low-Mem: Do no save the full FWD BWD and Posterior. Use temporary\n    Arrays for saving.\n    Input:\n    Emission probabilities [k x l] (log space)       (log space)\n    Transition probabilities (infinitesimal) [k x k] (normal space)\n    Initialized fwd and bwd probabilities [k x l]    (log space)\n    t: Transition Matrix: [l x 3 x 3]                     (normal space)\n    full: Boolean whether to return everything";
static PyMethodDef __pyx_mdef_5cfunc_7fwd_bkwd_lowmem = {"fwd_bkwd_lowmem", (PyCFunction)__pyx_pw_5cfunc_7fwd_bkwd_lowmem, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5cfunc_6fwd_bkwd_lowmem};
static PyObject *__pyx_pw_5cfunc_7fwd_bkwd_lowmem(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  __Pyx_memviewslice __pyx_v_e_prob0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t_mat = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t = { 0, 0, { 0 }, { 0 }, { 0 } };
  double __pyx_v_in_val;
  PyObject *__pyx_v_full = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd_lowmem (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_e_prob0,&__pyx_n_s_t_mat,&__pyx_n_s_t,&__pyx_n_s_in_val,&__pyx_n_s_full,0};
    PyObject* values[5] = {0,0,0,0,0};
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5cfunc_6fwd_bkwd_lowmem(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_e_prob0, CYTHON_UNUSED __Pyx_memviewslice __pyx_v_t_mat, __Pyx_memviewslice __pyx_v_t, double __pyx_v_in_val, PyObject *__pyx_v_full) {
  int __pyx_v_n_states;
  int __pyx_v_n_loci;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_j;
  Py_ssize_t __pyx_v_k;
  double __pyx_v_stay;
  double __pyx_v_tot_ll;
  PyObject *__pyx_v_post = NULL;
  __Pyx_memviewslice __pyx_v_post_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_trans_ll = NULL;
  __Pyx_memviewslice __pyx_v_trans_ll_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_trans_ll1 = NULL;
  __Pyx_memviewslice __pyx_v_trans_ll_view1 = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_three_v = NULL;
  __Pyx_memviewslice __pyx_v_three_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_two_v = NULL;
  __Pyx_memviewslice __pyx_v_two_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_fwd0 = NULL;
  __Pyx_memviewslice __pyx_v_fwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_bwd0 = NULL;
  __Pyx_memviewslice __pyx_v_bwd = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_tmp0 = NULL;
  __Pyx_memviewslice __pyx_v_tmp = { 0, 0, { 0 }, { 0 }, { 0 } };
  double __pyx_v_f_l;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fwd_bkwd_lowmem", 0);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __Pyx_XDECREF(__pyx_t_6);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __Pyx_AddTraceback("cfunc.fwd_bkwd_lowmem", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_post);
  __PYX_XDEC_MEMVIEW(&__pyx_v_post_view, 1);
  __Pyx_XDECREF(__pyx_v_trans_ll);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view, 1);
  __Pyx_XDECREF(__pyx_v_trans_ll1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view1, 1);
  __Pyx_XDECREF(__pyx_v_three_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_three_v_view, 1);
  __Pyx_XDECREF(__pyx_v_two_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_two_v_view, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t0, 1);
  __Pyx_XDECREF(__pyx_v_fwd0);
  __PYX_XDEC_MEMVIEW(&__pyx_v_fwd, 1);
  __Pyx_XDECREF(__pyx_v_bwd0);
  __PYX_XDEC_MEMVIEW(&__pyx_v_bwd, 1);
  __Pyx_XDECREF(__pyx_v_tmp0);
  __PYX_XDEC_MEMVIEW(&__pyx_v_tmp, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_e_prob0, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t_mat, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__49 = PyTuple_Pack(30, __pyx_n_s_e_prob0, __pyx_n_s_t_mat, __pyx_n_s_t, __pyx_n_s_in_val, __pyx_n_s_full, __pyx_n_s_n_states, __pyx_n_s_n_loci, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_stay, __pyx_n_s_tot_ll, __pyx_n_s_post, __pyx_n_s_post_view, __pyx_n_s_trans_ll, __pyx_n_s_trans_ll_view, __pyx_n_s_trans_ll1, __pyx_n_s_trans_ll_view1, __pyx_n_s_three_v, __pyx_n_s_three_v_view, __pyx_n_s_two_v, __pyx_n_s_two_v_view, __pyx_n_s_t0, __pyx_n_s_fwd0, __pyx_n_s_fwd, __pyx_n_s_bwd0, __pyx_n_s_bwd, __pyx_n_s_tmp0, __pyx_n_s_tmp, __pyx_n_s_f_l); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__49);
  __Pyx_GIVEREF(__pyx_tuple__49);
/* … */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5cfunc_7fwd_bkwd_lowmem, NULL, __pyx_n_s_cfunc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fwd_bkwd_lowmem, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(5, 0, 30, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cfunc_pyx, __pyx_n_s_fwd_bkwd_lowmem, 206, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 206, __pyx_L1_error)

+207:     double[:, :, :] t, double in_val = 1e-4, full=False):

    values[4] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_e_prob0)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_mat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd_lowmem", 0, 3, 5, 1); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("fwd_bkwd_lowmem", 0, 3, 5, 2); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_val);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_full);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fwd_bkwd_lowmem") < 0)) __PYX_ERR(0, 206, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_e_prob0 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_e_prob0.memview)) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_t_mat = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_mat.memview)) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_t = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t.memview)) __PYX_ERR(0, 207, __pyx_L3_error)
    if (values[3]) {
      __pyx_v_in_val = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_in_val == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 207, __pyx_L3_error)
    } else {
      __pyx_v_in_val = ((double)1e-4);
    }
    __pyx_v_full = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fwd_bkwd_lowmem", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 206, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("cfunc.fwd_bkwd_lowmem", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_5cfunc_6fwd_bkwd_lowmem(__pyx_self, __pyx_v_e_prob0, __pyx_v_t_mat, __pyx_v_t, __pyx_v_in_val, __pyx_v_full);

 208:     """Takes emission and transition probabilities, and calculates posteriors.

 209:     Uses speed-up specific for Genotype data (pooling same transition rates)

 210:     Low-Mem: Do no save the full FWD BWD and Posterior. Use temporary

 211:     Arrays for saving.

 212:     Input:

 213:     Emission probabilities [k x l] (log space)       (log space)

 214:     Transition probabilities (infinitesimal) [k x k] (normal space)

 215:     Initialized fwd and bwd probabilities [k x l]    (log space)

 216:     t: Transition Matrix: [l x 3 x 3]                     (normal space)

 217:     full: Boolean whether to return everything"""

+218:     cdef int n_states = e_prob0.shape[0]

  __pyx_v_n_states = (__pyx_v_e_prob0.shape[0]);

+219:     cdef int n_loci = e_prob0.shape[1]

  __pyx_v_n_loci = (__pyx_v_e_prob0.shape[1]);

 220:     cdef Py_ssize_t i, j, k    # The Array Indices

 221:     cdef double stay           # The Probablility of Staying

 222:     cdef double tot_ll  # The total Likelihood (need for Posterior)

 223: 

 224:     # Initialize Posterior and Transition Probabilities

+225:     post = np.empty(n_loci, dtype=DTYPE) # Array of 0 State Posterior

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_post = __pyx_t_4;
  __pyx_t_4 = 0;

+226:     cdef double[:] post_view = post

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_post, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 226, __pyx_L1_error)
  __pyx_v_post_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 227: 

+228:     trans_ll = np.empty(n_states-1, dtype=DTYPE) # Array for pre-calculations

  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyInt_From_long((__pyx_v_n_states - 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_trans_ll = __pyx_t_2;
  __pyx_t_2 = 0;

+229:     cdef double[:] trans_ll_view = trans_ll

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 229, __pyx_L1_error)
  __pyx_v_trans_ll_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 230: 

+231:     trans_ll1 = np.empty(n_states, dtype=DTYPE) # Array for calculations

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_trans_ll1 = __pyx_t_1;
  __pyx_t_1 = 0;

+232:     cdef double[:] trans_ll_view1 = trans_ll1

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 232, __pyx_L1_error)
  __pyx_v_trans_ll_view1 = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 233: 

+234:     three_v = np.empty(3, dtype=DTYPE)     # Array of size three

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__10, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_three_v = __pyx_t_3;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

+235:     cdef double[:] three_v_view = three_v

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_three_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 235, __pyx_L1_error)
  __pyx_v_three_v_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 236: 

+237:     two_v = np.empty(2, dtype=DTYPE)       # Array of size two

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__11, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_two_v = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_int_2); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

+238:     cdef double[:] two_v_view = two_v

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_two_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 238, __pyx_L1_error)
  __pyx_v_two_v_view = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 239: 

 240:     # Do transform to Log Space:

+241:     cdef double[:,:,:] t0 = np.log(t)         # Do log of recombination Map

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_t, 3, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (!__pyx_t_4) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    {
      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 241, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 241, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_t0 = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 242: 

 243:     ### Initialize FWD BWD Arrays

+244:     fwd0 = np.zeros(n_states, dtype=DTYPE)

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_fwd0 = __pyx_t_3;
  __pyx_t_3 = 0;

+245:     fwd0[:] = np.log(in_val)  # Initial Probabilities

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_in_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (!__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
      PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 245, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
      __Pyx_GIVEREF(__pyx_t_2);
      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__Pyx_PyObject_SetSlice(__pyx_v_fwd0, __pyx_t_3, 0, 0, NULL, NULL, &__pyx_slice__12, 0, 0, 0) < 0) __PYX_ERR(0, 245, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_slice__12 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__12)) __PYX_ERR(0, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__12);
  __Pyx_GIVEREF(__pyx_slice__12);

+246:     fwd0[0] = np.log(1 - (n_states - 1) * in_val)

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble((1.0 - ((__pyx_v_n_states - 1) * __pyx_v_in_val))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  if (!__pyx_t_2) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_6};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_6};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else
    #endif
    {
      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(__Pyx_SetItemInt(__pyx_v_fwd0, 0, __pyx_t_3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(0, 246, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+247:     cdef double[:] fwd = fwd0

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_fwd0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 247, __pyx_L1_error)
  __pyx_v_fwd = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 248: 

+249:     bwd0 = np.zeros(n_states, dtype=DTYPE)

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_bwd0 = __pyx_t_6;
  __pyx_t_6 = 0;

+250:     bwd0[:] = np.log(in_val)

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_in_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (!__pyx_t_4) {
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 250, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GOTREF(__pyx_t_6);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 250, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 250, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    } else
    #endif
    {
      __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 250, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__Pyx_PyObject_SetSlice(__pyx_v_bwd0, __pyx_t_6, 0, 0, NULL, NULL, &__pyx_slice__13, 0, 0, 0) < 0) __PYX_ERR(0, 250, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* … */
  __pyx_slice__13 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__13)) __PYX_ERR(0, 250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__13);
  __Pyx_GIVEREF(__pyx_slice__13);

+251:     bwd0[0] = np.log(1 - (n_states - 1) * in_val)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble((1.0 - ((__pyx_v_n_states - 1) * __pyx_v_in_val))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  if (!__pyx_t_3) {
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 251, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GOTREF(__pyx_t_6);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 251, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 251, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_1);
      __pyx_t_1 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__Pyx_SetItemInt(__pyx_v_bwd0, 0, __pyx_t_6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(0, 251, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+252:     cdef double[:] bwd = bwd0

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_bwd0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 252, __pyx_L1_error)
  __pyx_v_bwd = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 253: 

+254:     tmp0 = np.zeros(n_states, dtype=DTYPE)

  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_tmp0 = __pyx_t_1;
  __pyx_t_1 = 0;

+255:     cdef double[:] tmp = tmp0

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_tmp0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 255, __pyx_L1_error)
  __pyx_v_tmp = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

 256: 

 257:     #############################

 258:     ### Do the Forward Algorithm

 259: 

+260:     post_view[0] = fwd[0] # Add to first locus 0 Posterior

  __pyx_t_8 = 0;
  __pyx_t_9 = -1;
  if (__pyx_t_8 < 0) {
    __pyx_t_9 = 0;
  } else if (unlikely(__pyx_t_8 >= __pyx_v_fwd.shape[0])) __pyx_t_9 = 0;
  if (unlikely(__pyx_t_9 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_9);
    __PYX_ERR(0, 260, __pyx_L1_error)
  }
  __pyx_t_10 = 0;
  __pyx_t_9 = -1;
  if (__pyx_t_10 < 0) {
    __pyx_t_9 = 0;
  } else if (unlikely(__pyx_t_10 >= __pyx_v_post_view.shape[0])) __pyx_t_9 = 0;
  if (unlikely(__pyx_t_9 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_9);
    __PYX_ERR(0, 260, __pyx_L1_error)
  }
  *((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_10 * __pyx_v_post_view.strides[0]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_8 * __pyx_v_fwd.strides[0]) )));

+261:     for i in range(1, n_loci):  # Run forward recursion

  __pyx_t_9 = __pyx_v_n_loci;
  __pyx_t_11 = __pyx_t_9;
  for (__pyx_t_12 = 1; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_i = __pyx_t_12;

+262:         stay = log(t[i, 1, 1] - t[i, 1, 2])  # Do the log of the Stay term

    __pyx_t_13 = __pyx_v_i;
    __pyx_t_14 = 1;
    __pyx_t_15 = 1;
    __pyx_t_16 = -1;
    if (__pyx_t_13 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_13 >= __pyx_v_t.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_14 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_14 >= __pyx_v_t.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_15 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_15 >= __pyx_v_t.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 262, __pyx_L1_error)
    }
    __pyx_t_17 = __pyx_v_i;
    __pyx_t_18 = 1;
    __pyx_t_19 = 2;
    __pyx_t_16 = -1;
    if (__pyx_t_17 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_17 >= __pyx_v_t.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_18 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_18 >= __pyx_v_t.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_19 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_19 >= __pyx_v_t.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 262, __pyx_L1_error)
    }
    __pyx_v_stay = log(((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_13 * __pyx_v_t.strides[0]) ) + __pyx_t_14 * __pyx_v_t.strides[1]) ) + __pyx_t_15 * __pyx_v_t.strides[2]) ))) - (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_17 * __pyx_v_t.strides[0]) ) + __pyx_t_18 * __pyx_v_t.strides[1]) ) + __pyx_t_19 * __pyx_v_t.strides[2]) )))));

 263: 

+264:         for k in range(1, n_states): # Calculate logsum of ROH states:

    __pyx_t_16 = __pyx_v_n_states;
    __pyx_t_20 = __pyx_t_16;
    for (__pyx_t_21 = 1; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
      __pyx_v_k = __pyx_t_21;

+265:             trans_ll_view[k-1] = fwd[k]

      __pyx_t_22 = __pyx_v_k;
      __pyx_t_23 = -1;
      if (__pyx_t_22 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 265, __pyx_L1_error)
      }
      __pyx_t_24 = (__pyx_v_k - 1);
      __pyx_t_23 = -1;
      if (__pyx_t_24 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_24 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 265, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_24 * __pyx_v_trans_ll_view.strides[0]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_22 * __pyx_v_fwd.strides[0]) )));
    }

+266:         f_l = logsumexp(trans_ll_view) # Logsum of ROH States

    __pyx_v_f_l = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);

 267: 

 268:         # Do the 0 State:

+269:         two_v_view[0] = fwd[0] + t0[i, 0, 0]   # Staying in 0 State

    __pyx_t_25 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_25 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_25 >= __pyx_v_fwd.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 269, __pyx_L1_error)
    }
    __pyx_t_26 = __pyx_v_i;
    __pyx_t_27 = 0;
    __pyx_t_28 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_26 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_26 >= __pyx_v_t0.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_27 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_27 >= __pyx_v_t0.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_28 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_28 >= __pyx_v_t0.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 269, __pyx_L1_error)
    }
    __pyx_t_29 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_29 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_29 >= __pyx_v_two_v_view.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 269, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_29 * __pyx_v_two_v_view.strides[0]) )) = ((*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_25 * __pyx_v_fwd.strides[0]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_26 * __pyx_v_t0.strides[0]) ) + __pyx_t_27 * __pyx_v_t0.strides[1]) ) + __pyx_t_28 * __pyx_v_t0.strides[2]) ))));

+270:         two_v_view[1] = f_l + t0[i, 1, 0]             # Going into 0 State

    __pyx_t_30 = __pyx_v_i;
    __pyx_t_31 = 1;
    __pyx_t_32 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_30 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_30 >= __pyx_v_t0.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_31 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_31 >= __pyx_v_t0.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_32 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_32 >= __pyx_v_t0.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 270, __pyx_L1_error)
    }
    __pyx_t_33 = 1;
    __pyx_t_16 = -1;
    if (__pyx_t_33 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_33 >= __pyx_v_two_v_view.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 270, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_33 * __pyx_v_two_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_30 * __pyx_v_t0.strides[0]) ) + __pyx_t_31 * __pyx_v_t0.strides[1]) ) + __pyx_t_32 * __pyx_v_t0.strides[2]) ))));

+271:         tmp[0] = e_prob0[0, i] + logsumexp(two_v_view)

    __pyx_t_34 = 0;
    __pyx_t_35 = __pyx_v_i;
    __pyx_t_16 = -1;
    if (__pyx_t_34 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_34 >= __pyx_v_e_prob0.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_35 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_35 >= __pyx_v_e_prob0.shape[1])) __pyx_t_16 = 1;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 271, __pyx_L1_error)
    }
    __pyx_t_36 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_36 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_36 >= __pyx_v_tmp.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 271, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_36 * __pyx_v_tmp.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_34 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_35 * __pyx_v_e_prob0.strides[1]) ))) + __pyx_f_5cfunc_logsumexp(__pyx_v_two_v_view));

 272: 

 273:         ### Do the other states

 274:         # Preprocessing:

+275:         three_v_view[0] = fwd[0] + t0[i, 0, 1]   # Coming from 0 State

    __pyx_t_37 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_37 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_37 >= __pyx_v_fwd.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 275, __pyx_L1_error)
    }
    __pyx_t_38 = __pyx_v_i;
    __pyx_t_39 = 0;
    __pyx_t_40 = 1;
    __pyx_t_16 = -1;
    if (__pyx_t_38 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_38 >= __pyx_v_t0.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_39 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_39 >= __pyx_v_t0.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_40 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_40 >= __pyx_v_t0.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 275, __pyx_L1_error)
    }
    __pyx_t_41 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_41 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_41 >= __pyx_v_three_v_view.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 275, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_41 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_37 * __pyx_v_fwd.strides[0]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_38 * __pyx_v_t0.strides[0]) ) + __pyx_t_39 * __pyx_v_t0.strides[1]) ) + __pyx_t_40 * __pyx_v_t0.strides[2]) ))));

+276:         three_v_view[1] = f_l + t0[i, 1, 2]             # Coming from other ROH State

    __pyx_t_42 = __pyx_v_i;
    __pyx_t_43 = 1;
    __pyx_t_44 = 2;
    __pyx_t_16 = -1;
    if (__pyx_t_42 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_42 >= __pyx_v_t0.shape[0])) __pyx_t_16 = 0;
    if (__pyx_t_43 < 0) {
      __pyx_t_16 = 1;
    } else if (unlikely(__pyx_t_43 >= __pyx_v_t0.shape[1])) __pyx_t_16 = 1;
    if (__pyx_t_44 < 0) {
      __pyx_t_16 = 2;
    } else if (unlikely(__pyx_t_44 >= __pyx_v_t0.shape[2])) __pyx_t_16 = 2;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 276, __pyx_L1_error)
    }
    __pyx_t_45 = 1;
    __pyx_t_16 = -1;
    if (__pyx_t_45 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_45 >= __pyx_v_three_v_view.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 276, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_45 * __pyx_v_three_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_42 * __pyx_v_t0.strides[0]) ) + __pyx_t_43 * __pyx_v_t0.strides[1]) ) + __pyx_t_44 * __pyx_v_t0.strides[2]) ))));

 277: 

+278:         for j in range(1, n_states):  # Do the final run over all states

    __pyx_t_16 = __pyx_v_n_states;
    __pyx_t_20 = __pyx_t_16;
    for (__pyx_t_21 = 1; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
      __pyx_v_j = __pyx_t_21;

+279:           three_v_view[2] = fwd[j] +  stay

      __pyx_t_46 = __pyx_v_j;
      __pyx_t_23 = -1;
      if (__pyx_t_46 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_46 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 279, __pyx_L1_error)
      }
      __pyx_t_47 = 2;
      __pyx_t_23 = -1;
      if (__pyx_t_47 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_47 >= __pyx_v_three_v_view.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 279, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_47 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_46 * __pyx_v_fwd.strides[0]) ))) + __pyx_v_stay);

+280:           tmp[j] = e_prob0[j, i] + logsumexp(three_v_view)

      __pyx_t_48 = __pyx_v_j;
      __pyx_t_49 = __pyx_v_i;
      __pyx_t_23 = -1;
      if (__pyx_t_48 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_48 >= __pyx_v_e_prob0.shape[0])) __pyx_t_23 = 0;
      if (__pyx_t_49 < 0) {
        __pyx_t_23 = 1;
      } else if (unlikely(__pyx_t_49 >= __pyx_v_e_prob0.shape[1])) __pyx_t_23 = 1;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 280, __pyx_L1_error)
      }
      __pyx_t_50 = __pyx_v_j;
      __pyx_t_23 = -1;
      if (__pyx_t_50 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_50 >= __pyx_v_tmp.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 280, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_50 * __pyx_v_tmp.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_48 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_49 * __pyx_v_e_prob0.strides[1]) ))) + __pyx_f_5cfunc_logsumexp(__pyx_v_three_v_view));
    }

 281: 

 282:         ### Make tmp new fwd vec:

+283:         for j in range(0, n_states):

    __pyx_t_16 = __pyx_v_n_states;
    __pyx_t_20 = __pyx_t_16;
    for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
      __pyx_v_j = __pyx_t_21;

+284:           fwd[j] = tmp[j]

      __pyx_t_51 = __pyx_v_j;
      __pyx_t_23 = -1;
      if (__pyx_t_51 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_51 >= __pyx_v_tmp.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 284, __pyx_L1_error)
      }
      __pyx_t_52 = __pyx_v_j;
      __pyx_t_23 = -1;
      if (__pyx_t_52 < 0) {
        __pyx_t_23 = 0;
      } else if (unlikely(__pyx_t_52 >= __pyx_v_fwd.shape[0])) __pyx_t_23 = 0;
      if (unlikely(__pyx_t_23 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_23);
        __PYX_ERR(0, 284, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_52 * __pyx_v_fwd.strides[0]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_51 * __pyx_v_tmp.strides[0]) )));
    }

+285:         post_view[i] = fwd[0]  # Add to 0-State Posterior

    __pyx_t_53 = 0;
    __pyx_t_16 = -1;
    if (__pyx_t_53 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_53 >= __pyx_v_fwd.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 285, __pyx_L1_error)
    }
    __pyx_t_54 = __pyx_v_i;
    __pyx_t_16 = -1;
    if (__pyx_t_54 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_54 >= __pyx_v_post_view.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 285, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_54 * __pyx_v_post_view.strides[0]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_53 * __pyx_v_fwd.strides[0]) )));
  }

 286: 

 287:     ### Get total log likelihood

+288:     for k in range(n_states):  # Simply sum the two 1D arrays

  __pyx_t_9 = __pyx_v_n_states;
  __pyx_t_11 = __pyx_t_9;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_k = __pyx_t_12;

+289:       trans_ll_view1[k] = fwd[k] + bwd[k]

    __pyx_t_55 = __pyx_v_k;
    __pyx_t_16 = -1;
    if (__pyx_t_55 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_55 >= __pyx_v_fwd.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 289, __pyx_L1_error)
    }
    __pyx_t_56 = __pyx_v_k;
    __pyx_t_16 = -1;
    if (__pyx_t_56 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_56 >= __pyx_v_bwd.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 289, __pyx_L1_error)
    }
    __pyx_t_57 = __pyx_v_k;
    __pyx_t_16 = -1;
    if (__pyx_t_57 < 0) {
      __pyx_t_16 = 0;
    } else if (unlikely(__pyx_t_57 >= __pyx_v_trans_ll_view1.shape[0])) __pyx_t_16 = 0;
    if (unlikely(__pyx_t_16 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_16);
      __PYX_ERR(0, 289, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view1.data + __pyx_t_57 * __pyx_v_trans_ll_view1.strides[0]) )) = ((*((double *) ( /* dim=0 */ (__pyx_v_fwd.data + __pyx_t_55 * __pyx_v_fwd.strides[0]) ))) + (*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_56 * __pyx_v_bwd.strides[0]) ))));
  }

+290:     tot_ll = logsumexp(trans_ll_view1)

  __pyx_v_tot_ll = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view1);

 291: 

 292:     #############################

 293:     ### Do the Backward Algorithm

 294:     ## last0-State Posterior

+295:     post_view[n_loci-1] = post_view[n_loci-1] + bwd[0] - tot_ll

  __pyx_t_58 = (__pyx_v_n_loci - 1);
  __pyx_t_9 = -1;
  if (__pyx_t_58 < 0) {
    __pyx_t_9 = 0;
  } else if (unlikely(__pyx_t_58 >= __pyx_v_post_view.shape[0])) __pyx_t_9 = 0;
  if (unlikely(__pyx_t_9 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_9);
    __PYX_ERR(0, 295, __pyx_L1_error)
  }
  __pyx_t_59 = 0;
  __pyx_t_9 = -1;
  if (__pyx_t_59 < 0) {
    __pyx_t_9 = 0;
  } else if (unlikely(__pyx_t_59 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
  if (unlikely(__pyx_t_9 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_9);
    __PYX_ERR(0, 295, __pyx_L1_error)
  }
  __pyx_t_60 = (__pyx_v_n_loci - 1);
  __pyx_t_9 = -1;
  if (__pyx_t_60 < 0) {
    __pyx_t_9 = 0;
  } else if (unlikely(__pyx_t_60 >= __pyx_v_post_view.shape[0])) __pyx_t_9 = 0;
  if (unlikely(__pyx_t_9 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_9);
    __PYX_ERR(0, 295, __pyx_L1_error)
  }
  *((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_60 * __pyx_v_post_view.strides[0]) )) = (((*((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_58 * __pyx_v_post_view.strides[0]) ))) + (*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_59 * __pyx_v_bwd.strides[0]) )))) - __pyx_v_tot_ll);

 296: 

+297:     for i in range(n_loci-1, 0, -1):  # Run backward recursion

  for (__pyx_t_12 = (__pyx_v_n_loci - 1); __pyx_t_12 > 0; __pyx_t_12-=1) {
    __pyx_v_i = __pyx_t_12;

+298:       stay = log(t[i, 1, 1] - t[i, 1, 2])

    __pyx_t_61 = __pyx_v_i;
    __pyx_t_62 = 1;
    __pyx_t_63 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_61 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_61 >= __pyx_v_t.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_62 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_62 >= __pyx_v_t.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_63 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_63 >= __pyx_v_t.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 298, __pyx_L1_error)
    }
    __pyx_t_64 = __pyx_v_i;
    __pyx_t_65 = 1;
    __pyx_t_66 = 2;
    __pyx_t_9 = -1;
    if (__pyx_t_64 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_64 >= __pyx_v_t.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_65 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_65 >= __pyx_v_t.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_66 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_66 >= __pyx_v_t.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 298, __pyx_L1_error)
    }
    __pyx_v_stay = log(((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_61 * __pyx_v_t.strides[0]) ) + __pyx_t_62 * __pyx_v_t.strides[1]) ) + __pyx_t_63 * __pyx_v_t.strides[2]) ))) - (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t.data + __pyx_t_64 * __pyx_v_t.strides[0]) ) + __pyx_t_65 * __pyx_v_t.strides[1]) ) + __pyx_t_66 * __pyx_v_t.strides[2]) )))));

 299: 

+300:       for k in range(1, n_states): # Calculate logsum of ROH states:

    __pyx_t_9 = __pyx_v_n_states;
    __pyx_t_11 = __pyx_t_9;
    for (__pyx_t_21 = 1; __pyx_t_21 < __pyx_t_11; __pyx_t_21+=1) {
      __pyx_v_k = __pyx_t_21;

+301:           trans_ll_view[k-1] = bwd[k] + e_prob0[k, i]

      __pyx_t_67 = __pyx_v_k;
      __pyx_t_16 = -1;
      if (__pyx_t_67 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_67 >= __pyx_v_bwd.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 301, __pyx_L1_error)
      }
      __pyx_t_68 = __pyx_v_k;
      __pyx_t_69 = __pyx_v_i;
      __pyx_t_16 = -1;
      if (__pyx_t_68 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_68 >= __pyx_v_e_prob0.shape[0])) __pyx_t_16 = 0;
      if (__pyx_t_69 < 0) {
        __pyx_t_16 = 1;
      } else if (unlikely(__pyx_t_69 >= __pyx_v_e_prob0.shape[1])) __pyx_t_16 = 1;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 301, __pyx_L1_error)
      }
      __pyx_t_70 = (__pyx_v_k - 1);
      __pyx_t_16 = -1;
      if (__pyx_t_70 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_70 >= __pyx_v_trans_ll_view.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 301, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_trans_ll_view.data + __pyx_t_70 * __pyx_v_trans_ll_view.strides[0]) )) = ((*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_67 * __pyx_v_bwd.strides[0]) ))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_68 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_69 * __pyx_v_e_prob0.strides[1]) ))));
    }

+302:       f_l = logsumexp(trans_ll_view) # Logsum of ROH States

    __pyx_v_f_l = __pyx_f_5cfunc_logsumexp(__pyx_v_trans_ll_view);

 303: 

 304:       # Do the 0 State:

+305:       two_v_view[0] = bwd[0] + t0[i, 0, 0] + e_prob0[0, i]   # Staying in 0 State

    __pyx_t_71 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_71 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_71 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 305, __pyx_L1_error)
    }
    __pyx_t_72 = __pyx_v_i;
    __pyx_t_73 = 0;
    __pyx_t_74 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_72 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_72 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_73 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_73 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_74 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_74 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 305, __pyx_L1_error)
    }
    __pyx_t_75 = 0;
    __pyx_t_76 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_75 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_75 >= __pyx_v_e_prob0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_76 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_76 >= __pyx_v_e_prob0.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 305, __pyx_L1_error)
    }
    __pyx_t_77 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_77 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_77 >= __pyx_v_two_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 305, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_77 * __pyx_v_two_v_view.strides[0]) )) = (((*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_71 * __pyx_v_bwd.strides[0]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_72 * __pyx_v_t0.strides[0]) ) + __pyx_t_73 * __pyx_v_t0.strides[1]) ) + __pyx_t_74 * __pyx_v_t0.strides[2]) )))) + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_75 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_76 * __pyx_v_e_prob0.strides[1]) ))));

+306:       two_v_view[1] = f_l + t0[i, 0, 1]                         # Going into 0 State

    __pyx_t_78 = __pyx_v_i;
    __pyx_t_79 = 0;
    __pyx_t_80 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_78 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_78 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_79 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_79 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_80 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_80 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 306, __pyx_L1_error)
    }
    __pyx_t_81 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_81 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_81 >= __pyx_v_two_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 306, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_81 * __pyx_v_two_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_78 * __pyx_v_t0.strides[0]) ) + __pyx_t_79 * __pyx_v_t0.strides[1]) ) + __pyx_t_80 * __pyx_v_t0.strides[2]) ))));

+307:       tmp[0] = logsumexp(two_v_view)

    __pyx_t_82 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_82 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_82 >= __pyx_v_tmp.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 307, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_82 * __pyx_v_tmp.strides[0]) )) = __pyx_f_5cfunc_logsumexp(__pyx_v_two_v_view);

 308: 

 309:       ### Do the other states

 310:       # Preprocessing:

+311:       three_v_view[0] = e_prob0[0, i] + bwd[0] + t0[i, 1, 0]

    __pyx_t_83 = 0;
    __pyx_t_84 = __pyx_v_i;
    __pyx_t_9 = -1;
    if (__pyx_t_83 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_83 >= __pyx_v_e_prob0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_84 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_84 >= __pyx_v_e_prob0.shape[1])) __pyx_t_9 = 1;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 311, __pyx_L1_error)
    }
    __pyx_t_85 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_85 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_85 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 311, __pyx_L1_error)
    }
    __pyx_t_86 = __pyx_v_i;
    __pyx_t_87 = 1;
    __pyx_t_88 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_86 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_86 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_87 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_87 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_88 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_88 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 311, __pyx_L1_error)
    }
    __pyx_t_89 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_89 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_89 >= __pyx_v_three_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 311, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_89 * __pyx_v_three_v_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_83 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_84 * __pyx_v_e_prob0.strides[1]) ))) + (*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_85 * __pyx_v_bwd.strides[0]) )))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_86 * __pyx_v_t0.strides[0]) ) + __pyx_t_87 * __pyx_v_t0.strides[1]) ) + __pyx_t_88 * __pyx_v_t0.strides[2]) ))));

+312:       three_v_view[1] = f_l + t0[i, 1, 2]    # Coming from other ROH State

    __pyx_t_90 = __pyx_v_i;
    __pyx_t_91 = 1;
    __pyx_t_92 = 2;
    __pyx_t_9 = -1;
    if (__pyx_t_90 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_90 >= __pyx_v_t0.shape[0])) __pyx_t_9 = 0;
    if (__pyx_t_91 < 0) {
      __pyx_t_9 = 1;
    } else if (unlikely(__pyx_t_91 >= __pyx_v_t0.shape[1])) __pyx_t_9 = 1;
    if (__pyx_t_92 < 0) {
      __pyx_t_9 = 2;
    } else if (unlikely(__pyx_t_92 >= __pyx_v_t0.shape[2])) __pyx_t_9 = 2;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 312, __pyx_L1_error)
    }
    __pyx_t_93 = 1;
    __pyx_t_9 = -1;
    if (__pyx_t_93 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_93 >= __pyx_v_three_v_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 312, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_93 * __pyx_v_three_v_view.strides[0]) )) = (__pyx_v_f_l + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t0.data + __pyx_t_90 * __pyx_v_t0.strides[0]) ) + __pyx_t_91 * __pyx_v_t0.strides[1]) ) + __pyx_t_92 * __pyx_v_t0.strides[2]) ))));

 313: 

+314:       for j in range(1, n_states):  # Do the final run over all states

    __pyx_t_9 = __pyx_v_n_states;
    __pyx_t_11 = __pyx_t_9;
    for (__pyx_t_21 = 1; __pyx_t_21 < __pyx_t_11; __pyx_t_21+=1) {
      __pyx_v_j = __pyx_t_21;

+315:         three_v_view[2] = e_prob0[j, i] + bwd[j] +  stay

      __pyx_t_94 = __pyx_v_j;
      __pyx_t_95 = __pyx_v_i;
      __pyx_t_16 = -1;
      if (__pyx_t_94 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_94 >= __pyx_v_e_prob0.shape[0])) __pyx_t_16 = 0;
      if (__pyx_t_95 < 0) {
        __pyx_t_16 = 1;
      } else if (unlikely(__pyx_t_95 >= __pyx_v_e_prob0.shape[1])) __pyx_t_16 = 1;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 315, __pyx_L1_error)
      }
      __pyx_t_96 = __pyx_v_j;
      __pyx_t_16 = -1;
      if (__pyx_t_96 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_96 >= __pyx_v_bwd.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 315, __pyx_L1_error)
      }
      __pyx_t_97 = 2;
      __pyx_t_16 = -1;
      if (__pyx_t_97 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_97 >= __pyx_v_three_v_view.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 315, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_97 * __pyx_v_three_v_view.strides[0]) )) = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_94 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_95 * __pyx_v_e_prob0.strides[1]) ))) + (*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_96 * __pyx_v_bwd.strides[0]) )))) + __pyx_v_stay);

+316:         tmp[j] = logsumexp(three_v_view)  # Fill in the backward Probability

      __pyx_t_98 = __pyx_v_j;
      __pyx_t_16 = -1;
      if (__pyx_t_98 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_98 >= __pyx_v_tmp.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 316, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_98 * __pyx_v_tmp.strides[0]) )) = __pyx_f_5cfunc_logsumexp(__pyx_v_three_v_view);
    }

 317: 

 318:       ### Make tmp new bwd vec:

+319:       for j in range(0, n_states):

    __pyx_t_9 = __pyx_v_n_states;
    __pyx_t_11 = __pyx_t_9;
    for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_11; __pyx_t_21+=1) {
      __pyx_v_j = __pyx_t_21;

+320:         bwd[j] = tmp[j]

      __pyx_t_99 = __pyx_v_j;
      __pyx_t_16 = -1;
      if (__pyx_t_99 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_99 >= __pyx_v_tmp.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 320, __pyx_L1_error)
      }
      __pyx_t_100 = __pyx_v_j;
      __pyx_t_16 = -1;
      if (__pyx_t_100 < 0) {
        __pyx_t_16 = 0;
      } else if (unlikely(__pyx_t_100 >= __pyx_v_bwd.shape[0])) __pyx_t_16 = 0;
      if (unlikely(__pyx_t_16 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_16);
        __PYX_ERR(0, 320, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_100 * __pyx_v_bwd.strides[0]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_tmp.data + __pyx_t_99 * __pyx_v_tmp.strides[0]) )));
    }

 321: 

 322:       ### Finalize the 0 Posterior

+323:       post_view[i-1] = post_view[i-1] + bwd[0] - tot_ll

    __pyx_t_101 = (__pyx_v_i - 1);
    __pyx_t_9 = -1;
    if (__pyx_t_101 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_101 >= __pyx_v_post_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 323, __pyx_L1_error)
    }
    __pyx_t_102 = 0;
    __pyx_t_9 = -1;
    if (__pyx_t_102 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_102 >= __pyx_v_bwd.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 323, __pyx_L1_error)
    }
    __pyx_t_103 = (__pyx_v_i - 1);
    __pyx_t_9 = -1;
    if (__pyx_t_103 < 0) {
      __pyx_t_9 = 0;
    } else if (unlikely(__pyx_t_103 >= __pyx_v_post_view.shape[0])) __pyx_t_9 = 0;
    if (unlikely(__pyx_t_9 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_9);
      __PYX_ERR(0, 323, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_103 * __pyx_v_post_view.strides[0]) )) = (((*((double *) ( /* dim=0 */ (__pyx_v_post_view.data + __pyx_t_101 * __pyx_v_post_view.strides[0]) ))) + (*((double *) ( /* dim=0 */ (__pyx_v_bwd.data + __pyx_t_102 * __pyx_v_bwd.strides[0]) )))) - __pyx_v_tot_ll);
  }

 324: 

+325:     print(f"Total Log likelihood: {tot_ll: .3f}")

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_kp_u_3f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Total_Log_likelihood, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+326:     print_memory_usage()   ## For MEMORY_BENCH

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_print_memory_usage); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (__pyx_t_4) {
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 326, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 326, __pyx_L1_error)
  }
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 327: 

+328:     if full==False:

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_full, Py_False, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 328, __pyx_L1_error)
  __pyx_t_104 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_104 < 0)) __PYX_ERR(0, 328, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_104) {
/* … */
  }

+329:       return post[None,:]  # For "fake" axis

    __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_slice__14 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__14)) __PYX_ERR(0, 329, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__14);
  __Pyx_GIVEREF(__pyx_slice__14);
    __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_post, __pyx_tuple__15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_r = __pyx_t_6;
    __pyx_t_6 = 0;
    goto __pyx_L0;
  __pyx_tuple__15 = PyTuple_Pack(2, Py_None, __pyx_slice__14); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 329, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__15);
  __Pyx_GIVEREF(__pyx_tuple__15);

 330: 

+331:     elif full==True:   # Return everything

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_full, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L1_error)
  __pyx_t_104 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_104 < 0)) __PYX_ERR(0, 331, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_104) {
/* … */
  }

+332:       return post[None,:], fwd0, bwd0, tot_ll

    __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_slice__16 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__16)) __PYX_ERR(0, 332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__16);
  __Pyx_GIVEREF(__pyx_slice__16);
    __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_post, __pyx_tuple__17); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 332, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_tot_ll); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 332, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
    __Pyx_INCREF(__pyx_v_fwd0);
    __Pyx_GIVEREF(__pyx_v_fwd0);
    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_fwd0);
    __Pyx_INCREF(__pyx_v_bwd0);
    __Pyx_GIVEREF(__pyx_v_bwd0);
    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_bwd0);
    __Pyx_GIVEREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_1);
    __pyx_t_6 = 0;
    __pyx_t_1 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;
  __pyx_tuple__17 = PyTuple_Pack(2, Py_None, __pyx_slice__16); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__17);
  __Pyx_GIVEREF(__pyx_tuple__17);

 333: 

 334: 

+335: def viterbi_path(double[:, :] e_prob0, double[:, :, :] t_mat0, double[:] end_p0):

/* Python wrapper */
static PyObject *__pyx_pw_5cfunc_9viterbi_path(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_5cfunc_8viterbi_path[] = "Implementation of a Viterbi Path.\n    e_prob0  Matrices with Emission Probabilities, [k,l] (log space)\n    t_mat: Transition Matrix: [l x 3 x 3]  (normal space)\n    end_p: probability to begin/end in states [k]";
static PyMethodDef __pyx_mdef_5cfunc_9viterbi_path = {"viterbi_path", (PyCFunction)__pyx_pw_5cfunc_9viterbi_path, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5cfunc_8viterbi_path};
static PyObject *__pyx_pw_5cfunc_9viterbi_path(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  __Pyx_memviewslice __pyx_v_e_prob0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_t_mat0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_end_p0 = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("viterbi_path (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_e_prob0,&__pyx_n_s_t_mat0,&__pyx_n_s_end_p0,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_e_prob0)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_mat0)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("viterbi_path", 1, 3, 3, 1); __PYX_ERR(0, 335, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end_p0)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("viterbi_path", 1, 3, 3, 2); __PYX_ERR(0, 335, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "viterbi_path") < 0)) __PYX_ERR(0, 335, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_e_prob0 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_e_prob0.memview)) __PYX_ERR(0, 335, __pyx_L3_error)
    __pyx_v_t_mat0 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_mat0.memview)) __PYX_ERR(0, 335, __pyx_L3_error)
    __pyx_v_end_p0 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_end_p0.memview)) __PYX_ERR(0, 335, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("viterbi_path", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 335, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("cfunc.viterbi_path", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_5cfunc_8viterbi_path(__pyx_self, __pyx_v_e_prob0, __pyx_v_t_mat0, __pyx_v_end_p0);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5cfunc_8viterbi_path(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_e_prob0, __Pyx_memviewslice __pyx_v_t_mat0, __Pyx_memviewslice __pyx_v_end_p0) {
  int __pyx_v_n_states;
  int __pyx_v_n_loci;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_k;
  int __pyx_v_m;
  double __pyx_v_v;
  __Pyx_memviewslice __pyx_v_mp = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED __Pyx_memviewslice __pyx_v_new_p = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_pt = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_trans_ll = NULL;
  CYTHON_UNUSED __Pyx_memviewslice __pyx_v_trans_ll_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_three_v = NULL;
  __Pyx_memviewslice __pyx_v_three_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_three_vi = NULL;
  __Pyx_memviewslice __pyx_v_three_vi_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_two_v = NULL;
  __Pyx_memviewslice __pyx_v_two_v_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_two_vi = NULL;
  __Pyx_memviewslice __pyx_v_two_vi_view = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_path = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_x = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("viterbi_path", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __Pyx_AddTraceback("cfunc.viterbi_path", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_mp, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_new_p, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_pt, 1);
  __Pyx_XDECREF(__pyx_v_trans_ll);
  __PYX_XDEC_MEMVIEW(&__pyx_v_trans_ll_view, 1);
  __Pyx_XDECREF(__pyx_v_three_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_three_v_view, 1);
  __Pyx_XDECREF(__pyx_v_three_vi);
  __PYX_XDEC_MEMVIEW(&__pyx_v_three_vi_view, 1);
  __Pyx_XDECREF(__pyx_v_two_v);
  __PYX_XDEC_MEMVIEW(&__pyx_v_two_v_view, 1);
  __Pyx_XDECREF(__pyx_v_two_vi);
  __PYX_XDEC_MEMVIEW(&__pyx_v_two_vi_view, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_path, 1);
  __Pyx_XDECREF(__pyx_v_x);
  __PYX_XDEC_MEMVIEW(&__pyx_v_e_prob0, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_t_mat0, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_end_p0, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__51 = PyTuple_Pack(25, __pyx_n_s_e_prob0, __pyx_n_s_t_mat0, __pyx_n_s_end_p0, __pyx_n_s_n_states, __pyx_n_s_n_loci, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_m, __pyx_n_s_v, __pyx_n_s_mp, __pyx_n_s_new_p, __pyx_n_s_pt, __pyx_n_s_trans_ll, __pyx_n_s_trans_ll_view, __pyx_n_s_three_v, __pyx_n_s_three_v_view, __pyx_n_s_three_vi, __pyx_n_s_three_vi_view, __pyx_n_s_two_v, __pyx_n_s_two_v_view, __pyx_n_s_two_vi, __pyx_n_s_two_vi_view, __pyx_n_s_path, __pyx_n_s_x); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 335, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__51);
  __Pyx_GIVEREF(__pyx_tuple__51);
/* … */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5cfunc_9viterbi_path, NULL, __pyx_n_s_cfunc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 335, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_viterbi_path, __pyx_t_2) < 0) __PYX_ERR(0, 335, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(3, 0, 25, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__51, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cfunc_pyx, __pyx_n_s_viterbi_path, 335, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(0, 335, __pyx_L1_error)

 336:     """Implementation of a Viterbi Path.

 337:     e_prob0  Matrices with Emission Probabilities, [k,l] (log space)

 338:     t_mat: Transition Matrix: [l x 3 x 3]  (normal space)

 339:     end_p: probability to begin/end in states [k]"""

+340:     cdef int n_states = e_prob0.shape[0]

  __pyx_v_n_states = (__pyx_v_e_prob0.shape[0]);

+341:     cdef int n_loci = e_prob0.shape[1]

  __pyx_v_n_loci = (__pyx_v_e_prob0.shape[1]);

 342:     cdef Py_ssize_t i, j, k # The Array Indices

 343:     cdef int m  # Placeholder for Maximum

 344:     cdef double v # Value to set

 345: 

 346:     # Do the actual optimization (with back-tracking)

 347:     # Initialize Views:

+348:     cdef double[:, :] mp = np.empty((n_states, n_loci), dtype=np.float)

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_mp = __pyx_t_6;
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;

+349:     cdef double[:] new_p = np.empty(n_states, dtype = np.float) # Temporary Array

  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_new_p = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

+350:     cdef long[:,:] pt = np.empty((n_states, n_loci), dtype = np.int)  # Previous State Pointer

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_int); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_long(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 350, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_pt = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

 351: 

+352:     trans_ll = np.empty(n_states-1, dtype=DTYPE) # Array for pre-calculations

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_long((__pyx_v_n_states - 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_trans_ll = __pyx_t_5;
  __pyx_t_5 = 0;

+353:     cdef double[:] trans_ll_view = trans_ll

  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_trans_ll, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 353, __pyx_L1_error)
  __pyx_v_trans_ll_view = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 354: 

+355:     three_v = np.empty(3, dtype=DTYPE)     # Array of size three

  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__18, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_three_v = __pyx_t_3;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__18);
  __Pyx_GIVEREF(__pyx_tuple__18);

+356:     cdef double[:] three_v_view = three_v

  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_three_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 356, __pyx_L1_error)
  __pyx_v_three_v_view = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 357: 

+358:     three_vi = np.empty(3, dtype=int)       # Int Array of size three

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 358, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__19, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_three_vi = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__19);
  __Pyx_GIVEREF(__pyx_tuple__19);

+359:     cdef long[:] three_vi_view = three_vi

  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_three_vi, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 359, __pyx_L1_error)
  __pyx_v_three_vi_view = __pyx_t_9;
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;

 360: 

+361:     two_v = np.empty(2, dtype=DTYPE)       # Array of size two

  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__20, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_two_v = __pyx_t_5;
  __pyx_t_5 = 0;
/* … */
  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_int_2); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__20);
  __Pyx_GIVEREF(__pyx_tuple__20);

+362:     cdef double[:] two_v_view = two_v

  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_two_v, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 362, __pyx_L1_error)
  __pyx_v_two_v_view = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 363: 

+364:     two_vi = np.empty(2, dtype=int)       # Int Array of size two

  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__21, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_two_vi = __pyx_t_3;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_int_2); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__21);
  __Pyx_GIVEREF(__pyx_tuple__21);

+365:     cdef long[:] two_vi_view = two_vi

  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_two_vi, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 365, __pyx_L1_error)
  __pyx_v_two_vi_view = __pyx_t_9;
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;

 366: 

+367:     for k in range(n_states):

  __pyx_t_10 = __pyx_v_n_states;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_k = __pyx_t_12;

+368:       mp[k, 0] = end_p0[k]  # Initialize with Ending Probabilities

    __pyx_t_13 = __pyx_v_k;
    __pyx_t_14 = -1;
    if (__pyx_t_13 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_13 >= __pyx_v_end_p0.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 368, __pyx_L1_error)
    }
    __pyx_t_15 = __pyx_v_k;
    __pyx_t_16 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_15 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_15 >= __pyx_v_mp.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_16 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_16 >= __pyx_v_mp.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 368, __pyx_L1_error)
    }
    *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_15 * __pyx_v_mp.strides[0]) ) + __pyx_t_16 * __pyx_v_mp.strides[1]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_end_p0.data + __pyx_t_13 * __pyx_v_end_p0.strides[0]) )));

 369: 

+370:       two_vi_view[0] = 0

    __pyx_t_17 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_17 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_17 >= __pyx_v_two_vi_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 370, __pyx_L1_error)
    }
    *((long *) ( /* dim=0 */ (__pyx_v_two_vi_view.data + __pyx_t_17 * __pyx_v_two_vi_view.strides[0]) )) = 0;

+371:       three_vi_view[0] = 0

    __pyx_t_18 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_18 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_18 >= __pyx_v_three_vi_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 371, __pyx_L1_error)
    }
    *((long *) ( /* dim=0 */ (__pyx_v_three_vi_view.data + __pyx_t_18 * __pyx_v_three_vi_view.strides[0]) )) = 0;
  }

 372: 

+373:     for i in range(1, n_loci):  # Do the Viterbi-Iteration

  __pyx_t_10 = __pyx_v_n_loci;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 1; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_i = __pyx_t_12;

 374:         ### Precomputation:

 375:         # Do the maximal log probability of 1, ...k State:

+376:         m = argmax(mp[1:, i - 1])

    __pyx_t_7.data = __pyx_v_mp.data;
    __pyx_t_7.memview = __pyx_v_mp.memview;
    __PYX_INC_MEMVIEW(&__pyx_t_7, 0);
    __pyx_t_14 = -1;
    if (unlikely(__pyx_memoryview_slice_memviewslice(
    &__pyx_t_7,
    __pyx_v_mp.shape[0], __pyx_v_mp.strides[0], __pyx_v_mp.suboffsets[0],
    0,
    0,
    &__pyx_t_14,
    1,
    0,
    0,
    1,
    0,
    0,
    1) < 0))
{
    __PYX_ERR(0, 376, __pyx_L1_error)
}

{
    Py_ssize_t __pyx_tmp_idx = (__pyx_v_i - 1);
    Py_ssize_t __pyx_tmp_shape = __pyx_v_mp.shape[1];
    Py_ssize_t __pyx_tmp_stride = __pyx_v_mp.strides[1];
    if (0 && (__pyx_tmp_idx < 0))
        __pyx_tmp_idx += __pyx_tmp_shape;
    if (1 && (__pyx_tmp_idx < 0 || __pyx_tmp_idx >= __pyx_tmp_shape)) {
        PyErr_SetString(PyExc_IndexError, "Index out of bounds (axis 1)");
        __PYX_ERR(0, 376, __pyx_L1_error)
    }
        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_m = __pyx_f_5cfunc_argmax(__pyx_t_7);
    __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
    __pyx_t_7.memview = NULL;
    __pyx_t_7.data = NULL;

+377:         v = mp[m+1, i - 1]

    __pyx_t_19 = (__pyx_v_m + 1);
    __pyx_t_20 = (__pyx_v_i - 1);
    __pyx_t_14 = -1;
    if (__pyx_t_19 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_19 >= __pyx_v_mp.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_20 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_20 >= __pyx_v_mp.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 377, __pyx_L1_error)
    }
    __pyx_v_v = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_19 * __pyx_v_mp.strides[0]) ) + __pyx_t_20 * __pyx_v_mp.strides[1]) )));

 378: 

 379:         # Do the States from collapsed states

+380:         two_vi_view[1] = m+1   # Set the Pointers

    __pyx_t_21 = 1;
    __pyx_t_14 = -1;
    if (__pyx_t_21 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_21 >= __pyx_v_two_vi_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 380, __pyx_L1_error)
    }
    *((long *) ( /* dim=0 */ (__pyx_v_two_vi_view.data + __pyx_t_21 * __pyx_v_two_vi_view.strides[0]) )) = (__pyx_v_m + 1);

+381:         three_vi_view[1] = m+1

    __pyx_t_22 = 1;
    __pyx_t_14 = -1;
    if (__pyx_t_22 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_22 >= __pyx_v_three_vi_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 381, __pyx_L1_error)
    }
    *((long *) ( /* dim=0 */ (__pyx_v_three_vi_view.data + __pyx_t_22 * __pyx_v_three_vi_view.strides[0]) )) = (__pyx_v_m + 1);

 382: 

+383:         two_v_view[1] = v + t_mat0[i, 1, 0]

    __pyx_t_23 = __pyx_v_i;
    __pyx_t_24 = 1;
    __pyx_t_25 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_23 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_23 >= __pyx_v_t_mat0.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_24 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_24 >= __pyx_v_t_mat0.shape[1])) __pyx_t_14 = 1;
    if (__pyx_t_25 < 0) {
      __pyx_t_14 = 2;
    } else if (unlikely(__pyx_t_25 >= __pyx_v_t_mat0.shape[2])) __pyx_t_14 = 2;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 383, __pyx_L1_error)
    }
    __pyx_t_26 = 1;
    __pyx_t_14 = -1;
    if (__pyx_t_26 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_26 >= __pyx_v_two_v_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 383, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_26 * __pyx_v_two_v_view.strides[0]) )) = (__pyx_v_v + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_23 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_24 * __pyx_v_t_mat0.strides[1]) ) + __pyx_t_25 * __pyx_v_t_mat0.strides[2]) ))));

+384:         three_v_view[1] = v + t_mat0[i, 1, 2] # Move in from other ROH

    __pyx_t_27 = __pyx_v_i;
    __pyx_t_28 = 1;
    __pyx_t_29 = 2;
    __pyx_t_14 = -1;
    if (__pyx_t_27 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_27 >= __pyx_v_t_mat0.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_28 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_28 >= __pyx_v_t_mat0.shape[1])) __pyx_t_14 = 1;
    if (__pyx_t_29 < 0) {
      __pyx_t_14 = 2;
    } else if (unlikely(__pyx_t_29 >= __pyx_v_t_mat0.shape[2])) __pyx_t_14 = 2;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 384, __pyx_L1_error)
    }
    __pyx_t_30 = 1;
    __pyx_t_14 = -1;
    if (__pyx_t_30 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_30 >= __pyx_v_three_v_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 384, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_30 * __pyx_v_three_v_view.strides[0]) )) = (__pyx_v_v + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_27 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_28 * __pyx_v_t_mat0.strides[1]) ) + __pyx_t_29 * __pyx_v_t_mat0.strides[2]) ))));

 385: 

 386:         ### Do the zero State

+387:         two_v_view[0] = mp[0, i - 1] + t_mat0[i, 0, 0]

    __pyx_t_31 = 0;
    __pyx_t_32 = (__pyx_v_i - 1);
    __pyx_t_14 = -1;
    if (__pyx_t_31 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_31 >= __pyx_v_mp.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_32 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_32 >= __pyx_v_mp.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 387, __pyx_L1_error)
    }
    __pyx_t_33 = __pyx_v_i;
    __pyx_t_34 = 0;
    __pyx_t_35 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_33 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_33 >= __pyx_v_t_mat0.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_34 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_34 >= __pyx_v_t_mat0.shape[1])) __pyx_t_14 = 1;
    if (__pyx_t_35 < 0) {
      __pyx_t_14 = 2;
    } else if (unlikely(__pyx_t_35 >= __pyx_v_t_mat0.shape[2])) __pyx_t_14 = 2;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 387, __pyx_L1_error)
    }
    __pyx_t_36 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_36 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_36 >= __pyx_v_two_v_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 387, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_36 * __pyx_v_two_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_31 * __pyx_v_mp.strides[0]) ) + __pyx_t_32 * __pyx_v_mp.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_33 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_34 * __pyx_v_t_mat0.strides[1]) ) + __pyx_t_35 * __pyx_v_t_mat0.strides[2]) ))));

 388: 

+389:         m = argmax(two_v_view)      ### Do a Maximum

    __pyx_v_m = __pyx_f_5cfunc_argmax(__pyx_v_two_v_view);

+390:         v = two_v_view[m]

    __pyx_t_37 = __pyx_v_m;
    __pyx_t_14 = -1;
    if (__pyx_t_37 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_37 >= __pyx_v_two_v_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 390, __pyx_L1_error)
    }
    __pyx_v_v = (*((double *) ( /* dim=0 */ (__pyx_v_two_v_view.data + __pyx_t_37 * __pyx_v_two_v_view.strides[0]) )));

+391:         mp[0, i] = v + e_prob0[0, i]   ### Set Max. Probability

    __pyx_t_38 = 0;
    __pyx_t_39 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_38 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_38 >= __pyx_v_e_prob0.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_39 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_39 >= __pyx_v_e_prob0.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 391, __pyx_L1_error)
    }
    __pyx_t_40 = 0;
    __pyx_t_41 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_40 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_40 >= __pyx_v_mp.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_41 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_41 >= __pyx_v_mp.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 391, __pyx_L1_error)
    }
    *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_40 * __pyx_v_mp.strides[0]) ) + __pyx_t_41 * __pyx_v_mp.strides[1]) )) = (__pyx_v_v + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_38 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_39 * __pyx_v_e_prob0.strides[1]) ))));

+392:         pt[0, i] = two_vi_view[m]      ### Set Pointer for Backtrace

    __pyx_t_42 = __pyx_v_m;
    __pyx_t_14 = -1;
    if (__pyx_t_42 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_42 >= __pyx_v_two_vi_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 392, __pyx_L1_error)
    }
    __pyx_t_43 = 0;
    __pyx_t_44 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_43 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_43 >= __pyx_v_pt.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_44 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_44 >= __pyx_v_pt.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 392, __pyx_L1_error)
    }
    *((long *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_pt.data + __pyx_t_43 * __pyx_v_pt.strides[0]) ) + __pyx_t_44 * __pyx_v_pt.strides[1]) )) = (*((long *) ( /* dim=0 */ (__pyx_v_two_vi_view.data + __pyx_t_42 * __pyx_v_two_vi_view.strides[0]) )));

 393: 

 394:         ### Do the other States

+395:         three_v_view[0] = mp[0, i - 1] + t_mat0[i, 0, 1] # Move from 0 State

    __pyx_t_45 = 0;
    __pyx_t_46 = (__pyx_v_i - 1);
    __pyx_t_14 = -1;
    if (__pyx_t_45 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_45 >= __pyx_v_mp.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_46 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_46 >= __pyx_v_mp.shape[1])) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 395, __pyx_L1_error)
    }
    __pyx_t_47 = __pyx_v_i;
    __pyx_t_48 = 0;
    __pyx_t_49 = 1;
    __pyx_t_14 = -1;
    if (__pyx_t_47 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_47 >= __pyx_v_t_mat0.shape[0])) __pyx_t_14 = 0;
    if (__pyx_t_48 < 0) {
      __pyx_t_14 = 1;
    } else if (unlikely(__pyx_t_48 >= __pyx_v_t_mat0.shape[1])) __pyx_t_14 = 1;
    if (__pyx_t_49 < 0) {
      __pyx_t_14 = 2;
    } else if (unlikely(__pyx_t_49 >= __pyx_v_t_mat0.shape[2])) __pyx_t_14 = 2;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 395, __pyx_L1_error)
    }
    __pyx_t_50 = 0;
    __pyx_t_14 = -1;
    if (__pyx_t_50 < 0) {
      __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_50 >= __pyx_v_three_v_view.shape[0])) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 395, __pyx_L1_error)
    }
    *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_50 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_45 * __pyx_v_mp.strides[0]) ) + __pyx_t_46 * __pyx_v_mp.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_47 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_48 * __pyx_v_t_mat0.strides[1]) ) + __pyx_t_49 * __pyx_v_t_mat0.strides[2]) ))));

 396: 

+397:         for k in range(1, n_states):   # Find Maximum

    __pyx_t_14 = __pyx_v_n_states;
    __pyx_t_51 = __pyx_t_14;
    for (__pyx_t_52 = 1; __pyx_t_52 < __pyx_t_51; __pyx_t_52+=1) {
      __pyx_v_k = __pyx_t_52;

+398:           three_v_view[2] = mp[k, i - 1] + t_mat0[i, 1, 1] # The Stay State

      __pyx_t_53 = __pyx_v_k;
      __pyx_t_54 = (__pyx_v_i - 1);
      __pyx_t_55 = -1;
      if (__pyx_t_53 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_53 >= __pyx_v_mp.shape[0])) __pyx_t_55 = 0;
      if (__pyx_t_54 < 0) {
        __pyx_t_55 = 1;
      } else if (unlikely(__pyx_t_54 >= __pyx_v_mp.shape[1])) __pyx_t_55 = 1;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 398, __pyx_L1_error)
      }
      __pyx_t_56 = __pyx_v_i;
      __pyx_t_57 = 1;
      __pyx_t_58 = 1;
      __pyx_t_55 = -1;
      if (__pyx_t_56 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_56 >= __pyx_v_t_mat0.shape[0])) __pyx_t_55 = 0;
      if (__pyx_t_57 < 0) {
        __pyx_t_55 = 1;
      } else if (unlikely(__pyx_t_57 >= __pyx_v_t_mat0.shape[1])) __pyx_t_55 = 1;
      if (__pyx_t_58 < 0) {
        __pyx_t_55 = 2;
      } else if (unlikely(__pyx_t_58 >= __pyx_v_t_mat0.shape[2])) __pyx_t_55 = 2;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 398, __pyx_L1_error)
      }
      __pyx_t_59 = 2;
      __pyx_t_55 = -1;
      if (__pyx_t_59 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_59 >= __pyx_v_three_v_view.shape[0])) __pyx_t_55 = 0;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 398, __pyx_L1_error)
      }
      *((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_59 * __pyx_v_three_v_view.strides[0]) )) = ((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_53 * __pyx_v_mp.strides[0]) ) + __pyx_t_54 * __pyx_v_mp.strides[1]) ))) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_mat0.data + __pyx_t_56 * __pyx_v_t_mat0.strides[0]) ) + __pyx_t_57 * __pyx_v_t_mat0.strides[1]) ) + __pyx_t_58 * __pyx_v_t_mat0.strides[2]) ))));

+399:           three_vi_view[2] = k

      __pyx_t_60 = 2;
      __pyx_t_55 = -1;
      if (__pyx_t_60 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_60 >= __pyx_v_three_vi_view.shape[0])) __pyx_t_55 = 0;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 399, __pyx_L1_error)
      }
      *((long *) ( /* dim=0 */ (__pyx_v_three_vi_view.data + __pyx_t_60 * __pyx_v_three_vi_view.strides[0]) )) = __pyx_v_k;

 400: 

+401:           m = argmax(three_v_view)      ### Do a Maximum

      __pyx_v_m = __pyx_f_5cfunc_argmax(__pyx_v_three_v_view);

+402:           v = three_v_view[m]

      __pyx_t_61 = __pyx_v_m;
      __pyx_t_55 = -1;
      if (__pyx_t_61 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_61 >= __pyx_v_three_v_view.shape[0])) __pyx_t_55 = 0;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 402, __pyx_L1_error)
      }
      __pyx_v_v = (*((double *) ( /* dim=0 */ (__pyx_v_three_v_view.data + __pyx_t_61 * __pyx_v_three_v_view.strides[0]) )));

 403: 

+404:           mp[k, i] = v + e_prob0[k, i]   ### Set Max. Probability

      __pyx_t_62 = __pyx_v_k;
      __pyx_t_63 = __pyx_v_i;
      __pyx_t_55 = -1;
      if (__pyx_t_62 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_62 >= __pyx_v_e_prob0.shape[0])) __pyx_t_55 = 0;
      if (__pyx_t_63 < 0) {
        __pyx_t_55 = 1;
      } else if (unlikely(__pyx_t_63 >= __pyx_v_e_prob0.shape[1])) __pyx_t_55 = 1;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 404, __pyx_L1_error)
      }
      __pyx_t_64 = __pyx_v_k;
      __pyx_t_65 = __pyx_v_i;
      __pyx_t_55 = -1;
      if (__pyx_t_64 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_64 >= __pyx_v_mp.shape[0])) __pyx_t_55 = 0;
      if (__pyx_t_65 < 0) {
        __pyx_t_55 = 1;
      } else if (unlikely(__pyx_t_65 >= __pyx_v_mp.shape[1])) __pyx_t_55 = 1;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 404, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_64 * __pyx_v_mp.strides[0]) ) + __pyx_t_65 * __pyx_v_mp.strides[1]) )) = (__pyx_v_v + (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_e_prob0.data + __pyx_t_62 * __pyx_v_e_prob0.strides[0]) ) + __pyx_t_63 * __pyx_v_e_prob0.strides[1]) ))));

+405:           pt[k, i] = three_vi_view[m]      ### Set Pointer for Backtrace

      __pyx_t_66 = __pyx_v_m;
      __pyx_t_55 = -1;
      if (__pyx_t_66 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_66 >= __pyx_v_three_vi_view.shape[0])) __pyx_t_55 = 0;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 405, __pyx_L1_error)
      }
      __pyx_t_67 = __pyx_v_k;
      __pyx_t_68 = __pyx_v_i;
      __pyx_t_55 = -1;
      if (__pyx_t_67 < 0) {
        __pyx_t_55 = 0;
      } else if (unlikely(__pyx_t_67 >= __pyx_v_pt.shape[0])) __pyx_t_55 = 0;
      if (__pyx_t_68 < 0) {
        __pyx_t_55 = 1;
      } else if (unlikely(__pyx_t_68 >= __pyx_v_pt.shape[1])) __pyx_t_55 = 1;
      if (unlikely(__pyx_t_55 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_55);
        __PYX_ERR(0, 405, __pyx_L1_error)
      }
      *((long *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_pt.data + __pyx_t_67 * __pyx_v_pt.strides[0]) ) + __pyx_t_68 * __pyx_v_pt.strides[1]) )) = (*((long *) ( /* dim=0 */ (__pyx_v_three_vi_view.data + __pyx_t_66 * __pyx_v_three_vi_view.strides[0]) )));
    }
  }

 406: 

 407:     ### Do the trace back

+408:     cdef long[:] path = -np.ones(n_loci, dtype=np.int)  # Initialize

  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ones); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_loci); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_path = __pyx_t_9;
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;

 409: 

+410:     x = np.argmax(mp[:, n_loci-1])  # The highest probability

  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_argmax); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7.data = __pyx_v_mp.data;
  __pyx_t_7.memview = __pyx_v_mp.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_7, 0);
  __pyx_t_7.shape[0] = __pyx_v_mp.shape[0];
__pyx_t_7.strides[0] = __pyx_v_mp.strides[0];
    __pyx_t_7.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = (__pyx_v_n_loci - 1);
    Py_ssize_t __pyx_tmp_shape = __pyx_v_mp.shape[1];
    Py_ssize_t __pyx_tmp_stride = __pyx_v_mp.strides[1];
    if (0 && (__pyx_tmp_idx < 0))
        __pyx_tmp_idx += __pyx_tmp_shape;
    if (1 && (__pyx_tmp_idx < 0 || __pyx_tmp_idx >= __pyx_tmp_shape)) {
        PyErr_SetString(PyExc_IndexError, "Index out of bounds (axis 1)");
        __PYX_ERR(0, 410, __pyx_L1_error)
    }
        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_t_1 = __pyx_memoryview_fromslice(__pyx_t_7, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  if (!__pyx_t_5) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_1};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_1};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 410, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_1);
      __pyx_t_1 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_x = __pyx_t_3;
  __pyx_t_3 = 0;

+411:     path[n_loci-1] = x

  __pyx_t_69 = __Pyx_PyInt_As_long(__pyx_v_x); if (unlikely((__pyx_t_69 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 411, __pyx_L1_error)
  __pyx_t_70 = (__pyx_v_n_loci - 1);
  __pyx_t_10 = -1;
  if (__pyx_t_70 < 0) {
    __pyx_t_10 = 0;
  } else if (unlikely(__pyx_t_70 >= __pyx_v_path.shape[0])) __pyx_t_10 = 0;
  if (unlikely(__pyx_t_10 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_10);
    __PYX_ERR(0, 411, __pyx_L1_error)
  }
  *((long *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_70 * __pyx_v_path.strides[0]) )) = __pyx_t_69;

 412: 

+413:     for i in range(n_loci - 1, 0, -1):

  for (__pyx_t_12 = (__pyx_v_n_loci - 1); __pyx_t_12 > 0; __pyx_t_12-=1) {
    __pyx_v_i = __pyx_t_12;

 414:         # Always th pointer to the previous path

+415:         path[i - 1] = pt[path[i], i]

    __pyx_t_71 = __pyx_v_i;
    __pyx_t_10 = -1;
    if (__pyx_t_71 < 0) {
      __pyx_t_10 = 0;
    } else if (unlikely(__pyx_t_71 >= __pyx_v_path.shape[0])) __pyx_t_10 = 0;
    if (unlikely(__pyx_t_10 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_10);
      __PYX_ERR(0, 415, __pyx_L1_error)
    }
    __pyx_t_72 = (*((long *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_71 * __pyx_v_path.strides[0]) )));
    __pyx_t_73 = __pyx_v_i;
    __pyx_t_10 = -1;
    if (__pyx_t_72 < 0) {
      __pyx_t_10 = 0;
    } else if (unlikely(__pyx_t_72 >= __pyx_v_pt.shape[0])) __pyx_t_10 = 0;
    if (__pyx_t_73 < 0) {
      __pyx_t_10 = 1;
    } else if (unlikely(__pyx_t_73 >= __pyx_v_pt.shape[1])) __pyx_t_10 = 1;
    if (unlikely(__pyx_t_10 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_10);
      __PYX_ERR(0, 415, __pyx_L1_error)
    }
    __pyx_t_74 = (__pyx_v_i - 1);
    __pyx_t_10 = -1;
    if (__pyx_t_74 < 0) {
      __pyx_t_10 = 0;
    } else if (unlikely(__pyx_t_74 >= __pyx_v_path.shape[0])) __pyx_t_10 = 0;
    if (unlikely(__pyx_t_10 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_10);
      __PYX_ERR(0, 415, __pyx_L1_error)
    }
    *((long *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_74 * __pyx_v_path.strides[0]) )) = (*((long *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_pt.data + __pyx_t_72 * __pyx_v_pt.strides[0]) ) + __pyx_t_73 * __pyx_v_pt.strides[1]) )));
  }

 416: 

+417:     m = path[n_loci-1]

  __pyx_t_75 = (__pyx_v_n_loci - 1);
  __pyx_t_10 = -1;
  if (__pyx_t_75 < 0) {
    __pyx_t_10 = 0;
  } else if (unlikely(__pyx_t_75 >= __pyx_v_path.shape[0])) __pyx_t_10 = 0;
  if (unlikely(__pyx_t_10 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_10);
    __PYX_ERR(0, 417, __pyx_L1_error)
  }
  __pyx_v_m = (*((long *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_75 * __pyx_v_path.strides[0]) )));

+418:     print(f"Log likelihood Path: {mp[m,n_loci-1]:.3f}")

  __pyx_t_76 = __pyx_v_m;
  __pyx_t_77 = (__pyx_v_n_loci - 1);
  __pyx_t_10 = -1;
  if (__pyx_t_76 < 0) {
    __pyx_t_10 = 0;
  } else if (unlikely(__pyx_t_76 >= __pyx_v_mp.shape[0])) __pyx_t_10 = 0;
  if (__pyx_t_77 < 0) {
    __pyx_t_10 = 1;
  } else if (unlikely(__pyx_t_77 >= __pyx_v_mp.shape[1])) __pyx_t_10 = 1;
  if (unlikely(__pyx_t_10 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_10);
    __PYX_ERR(0, 418, __pyx_L1_error)
  }
  __pyx_t_3 = PyFloat_FromDouble((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_mp.data + __pyx_t_76 * __pyx_v_mp.strides[0]) ) + __pyx_t_77 * __pyx_v_mp.strides[1]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_3, __pyx_kp_u_3f_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Log_likelihood_Path, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+419:     assert(np.min(path)>=0) #Sanity check if everything was filled up

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 419, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_path, 1, (PyObject *(*)(char *)) __pyx_memview_get_long, (int (*)(char *, PyObject *)) __pyx_memview_set_long, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 419, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_1)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    if (!__pyx_t_1) {
      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_2);
    } else {
      #if CYTHON_FAST_PYCALL
      if (PyFunction_Check(__pyx_t_4)) {
        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_3};
        __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error)
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      } else
      #endif
      #if CYTHON_FAST_PYCCALL
      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_3};
        __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error)
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      } else
      #endif
      {
        __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 419, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __pyx_t_1 = NULL;
        __Pyx_GIVEREF(__pyx_t_3);
        PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
        __pyx_t_3 = 0;
        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_78 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_78 < 0)) __PYX_ERR(0, 419, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_78)) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(0, 419, __pyx_L1_error)
    }
  }
  #endif

+420:     return np.asarray(path)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_path, 1, (PyObject *(*)(char *)) __pyx_memview_get_long, (int (*)(char *, PyObject *)) __pyx_memview_set_long, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_5, function);
    }
  }
  if (!__pyx_t_3) {
    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_t_4);
  } else {
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_5)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2};
      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2};
      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    {
      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); __pyx_t_3 = NULL;
      __Pyx_GIVEREF(__pyx_t_2);
      PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;