+001: # cython: linetrace=True

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

 002: # cython: binding=True

 003: # distutils: language = c++

 004: # distutils: define_macros=CYTHON_TRACE=1

 005: cdef extern from "<algorithm>" namespace "std":

 006:     Iter find[Iter, T](Iter first, Iter last, const T& value)

 007: 

 008: 

 009: # cythonize -a -i digestfast.pyx

 010: 

 011: from libcpp.vector cimport vector

 012: from libcpp.set cimport set as c_set

 013: 

+014: import itertools

  __Pyx_TraceLine(14,0,__PYX_ERR(0, 14, __pyx_L1_error))
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_itertools, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_itertools, __pyx_t_1) < 0) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+015: import sys

  __Pyx_TraceLine(15,0,__PYX_ERR(0, 15, __pyx_L1_error))
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 016: 

 017: # method for generating the list of peptides

+018: def getDigestedPeptides(seq, int min_len = 6, int max_len = 50, pre2 = ['K', 'R'], not_post2 = ['P'], digestion = 'full', int miscleavages = 0, methionineCleavage = True):

static PyObject *__pyx_pf_3bin_9__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_TraceDeclarations
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__defaults__", 0);
  __Pyx_TraceCall("__defaults__", __pyx_f[0], 18, 0, __PYX_ERR(0, 18, __pyx_L1_error));
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_int(((int)6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_From_int(((int)50)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __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_2);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_pre2);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_pre2);
  PyTuple_SET_ITEM(__pyx_t_4, 2, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_pre2);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_not_post2);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_not_post2);
  PyTuple_SET_ITEM(__pyx_t_4, 3, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_not_post2);
  __Pyx_INCREF(((PyObject*)__pyx_n_s_full));
  __Pyx_GIVEREF(((PyObject*)__pyx_n_s_full));
  PyTuple_SET_ITEM(__pyx_t_4, 4, ((PyObject*)__pyx_n_s_full));
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_3);
  __Pyx_INCREF(((PyObject *)Py_True));
  __Pyx_GIVEREF(((PyObject *)Py_True));
  PyTuple_SET_ITEM(__pyx_t_4, 6, ((PyObject *)Py_True));
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  PyTuple_SET_ITEM(__pyx_t_3, 1, Py_None);
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* 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_AddTraceback("bin.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_3bin_1getDigestedPeptides(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_3bin_1getDigestedPeptides = {"getDigestedPeptides", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3bin_1getDigestedPeptides, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_3bin_1getDigestedPeptides(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_seq = 0;
  int __pyx_v_min_len;
  int __pyx_v_max_len;
  PyObject *__pyx_v_pre2 = 0;
  PyObject *__pyx_v_not_post2 = 0;
  PyObject *__pyx_v_digestion = 0;
  int __pyx_v_miscleavages;
  PyObject *__pyx_v_methionineCleavage = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDigestedPeptides (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_seq,&__pyx_n_s_min_len,&__pyx_n_s_max_len,&__pyx_n_s_pre2,&__pyx_n_s_not_post2,&__pyx_n_s_digestion,&__pyx_n_s_miscleavages,&__pyx_n_s_methionineCleavage,0};
    PyObject* values[8] = {0,0,0,0,0,0,0,0};
    __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self);
    values[3] = __pyx_dynamic_args->__pyx_arg_pre2;
    values[4] = __pyx_dynamic_args->__pyx_arg_not_post2;
    values[5] = ((PyObject *)((PyObject*)__pyx_n_s_full));
    values[7] = ((PyObject *)((PyObject *)Py_True));
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        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_seq)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_min_len);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_len);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pre2);
          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_not_post2);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_digestion);
          if (value) { values[5] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_miscleavages);
          if (value) { values[6] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_methionineCleavage);
          if (value) { values[7] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getDigestedPeptides") < 0)) __PYX_ERR(0, 18, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        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);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_seq = values[0];
    if (values[1]) {
      __pyx_v_min_len = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_min_len == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 18, __pyx_L3_error)
    } else {
      __pyx_v_min_len = ((int)((int)6));
    }
    if (values[2]) {
      __pyx_v_max_len = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_max_len == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 18, __pyx_L3_error)
    } else {
      __pyx_v_max_len = ((int)((int)50));
    }
    __pyx_v_pre2 = values[3];
    __pyx_v_not_post2 = values[4];
    __pyx_v_digestion = values[5];
    if (values[6]) {
      __pyx_v_miscleavages = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_miscleavages == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 18, __pyx_L3_error)
    } else {
      __pyx_v_miscleavages = ((int)((int)0));
    }
    __pyx_v_methionineCleavage = values[7];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getDigestedPeptides", 0, 1, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 18, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("bin.getDigestedPeptides", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_3bin_getDigestedPeptides(__pyx_self, __pyx_v_seq, __pyx_v_min_len, __pyx_v_max_len, __pyx_v_pre2, __pyx_v_not_post2, __pyx_v_digestion, __pyx_v_miscleavages, __pyx_v_methionineCleavage);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_3bin_getDigestedPeptides(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_seq, int __pyx_v_min_len, int __pyx_v_max_len, PyObject *__pyx_v_pre2, PyObject *__pyx_v_not_post2, PyObject *__pyx_v_digestion, int __pyx_v_miscleavages, PyObject *__pyx_v_methionineCleavage) {
  struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDigestedPeptides", 0);
  __pyx_cur_scope = (struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *)__pyx_tp_new_3bin___pyx_scope_struct__getDigestedPeptides(__pyx_ptype_3bin___pyx_scope_struct__getDigestedPeptides, __pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 18, __pyx_L1_error)
  } else {
    __Pyx_GOTREF(__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_seq = __pyx_v_seq;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_seq);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_seq);
  __pyx_cur_scope->__pyx_v_min_len = __pyx_v_min_len;
  __pyx_cur_scope->__pyx_v_max_len = __pyx_v_max_len;
  __pyx_cur_scope->__pyx_v_pre2 = __pyx_v_pre2;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pre2);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pre2);
  __pyx_cur_scope->__pyx_v_not_post2 = __pyx_v_not_post2;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_not_post2);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_not_post2);
  __pyx_cur_scope->__pyx_v_digestion = __pyx_v_digestion;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_digestion);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_digestion);
  __pyx_cur_scope->__pyx_v_miscleavages = __pyx_v_miscleavages;
  __pyx_cur_scope->__pyx_v_methionineCleavage = __pyx_v_methionineCleavage;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_3bin_2generator, __pyx_codeobj__2, (PyObject *) __pyx_cur_scope, __pyx_n_s_getDigestedPeptides, __pyx_n_s_getDigestedPeptides, __pyx_n_s_bin); if (unlikely(!gen)) __PYX_ERR(0, 18, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("bin.getDigestedPeptides", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_3bin_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDigestedPeptides", 0);
  __Pyx_TraceDeclarations
  __Pyx_TraceFrameInit(__pyx_codeobj__2)
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 18, __pyx_L1_error)
/* … */
  /* function exit code */
  PyErr_SetNone(PyExc_StopIteration);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("getDigestedPeptides", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_3bin_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
  __pyx_tuple__10 = PyTuple_Pack(25, __pyx_n_s_seq, __pyx_n_s_min_len, __pyx_n_s_max_len, __pyx_n_s_pre2, __pyx_n_s_not_post2, __pyx_n_s_digestion, __pyx_n_s_miscleavages, __pyx_n_s_methionineCleavage, __pyx_n_s_cleavageSites, __pyx_n_s_starts, __pyx_n_s_i, __pyx_n_s_lenS, __pyx_n_s_lenP, __pyx_n_s_start, __pyx_n_s_methionineCleaved, __pyx_n_s_one, __pyx_n_s_c, __pyx_n_s_pre, __pyx_n_s_not_post, __pyx_n_s_p, __pyx_n_s_length_accepted, __pyx_n_s_j, __pyx_n_s_isCleavageSite, __pyx_n_s_isMethionineCleavageSite, __pyx_n_s_hasMethionineCleavage); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);
/* … */
  __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error))
  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_3bin_1getDigestedPeptides, 0, __pyx_n_s_getDigestedPeptides, NULL, __pyx_n_s_bin, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_1, sizeof(__pyx_defaults), 2)) __PYX_ERR(0, 18, __pyx_L1_error)
  __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_K);
  __Pyx_GIVEREF(__pyx_n_s_K);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_K);
  __Pyx_INCREF(__pyx_n_s_R);
  __Pyx_GIVEREF(__pyx_n_s_R);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_R);
  __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_1)->__pyx_arg_pre2 = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_P);
  __Pyx_GIVEREF(__pyx_n_s_P);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_P);
  __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_1)->__pyx_arg_not_post2 = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_1, __pyx_pf_3bin_9__defaults__);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_getDigestedPeptides, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(8, 0, 25, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_bin_digestfast_pyx, __pyx_n_s_getDigestedPeptides, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 18, __pyx_L1_error)
/* … */
struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides {
  PyObject_HEAD
  int __pyx_v_c;
  std::vector<int>  __pyx_v_cleavageSites;
  PyObject *__pyx_v_digestion;
  int __pyx_v_hasMethionineCleavage;
  int __pyx_v_i;
  PyObject *__pyx_v_isCleavageSite;
  PyObject *__pyx_v_isMethionineCleavageSite;
  PyObject *__pyx_v_j;
  int __pyx_v_lenP;
  int __pyx_v_lenS;
  PyObject *__pyx_v_length_accepted;
  int __pyx_v_max_len;
  PyObject *__pyx_v_methionineCleavage;
  int __pyx_v_methionineCleaved;
  int __pyx_v_min_len;
  int __pyx_v_miscleavages;
  std::set<int>  __pyx_v_not_post;
  PyObject *__pyx_v_not_post2;
  int __pyx_v_one;
  PyObject *__pyx_v_p;
  std::set<int>  __pyx_v_pre;
  PyObject *__pyx_v_pre2;
  PyObject *__pyx_v_seq;
  int __pyx_v_start;
  std::vector<int>  __pyx_v_starts;
  Py_ssize_t __pyx_t_0;
  PyObject *(*__pyx_t_1)(PyObject *);
  PyObject *__pyx_t_2;
  long __pyx_t_3;
  long __pyx_t_4;
  int __pyx_t_5;
  std::vector<int> ::iterator __pyx_t_6;
  std::vector<int> ::iterator __pyx_t_7;
};

 019:   cdef vector[int] cleavageSites, starts

 020:   cdef int i, lenS, lenP, start, methionineCleaved, one, c

 021:   cdef c_set[int] pre, not_post

 022: 

+023:   one = 1

  __Pyx_TraceLine(23,0,__PYX_ERR(0, 23, __pyx_L1_error))
  __pyx_cur_scope->__pyx_v_one = 1;

 024: 

+025:   for p in pre2:

  __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error))
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_pre2)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_pre2)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_v_pre2; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_pre2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 25, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 25, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      } else {
        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 25, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      }
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 25, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
/* … */
    __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error))
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+026:     pre.insert(ord(p))

    __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error))
    __pyx_t_5 = __Pyx_PyObject_Ord(__pyx_cur_scope->__pyx_v_p); if (unlikely(__pyx_t_5 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 26, __pyx_L1_error)
    try {
      __pyx_cur_scope->__pyx_v_pre.insert(__pyx_t_5);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 26, __pyx_L1_error)
    }

 027: 

+028:   for p in not_post2:

  __Pyx_TraceLine(28,0,__PYX_ERR(0, 28, __pyx_L1_error))
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_not_post2)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_not_post2)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_v_not_post2; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_not_post2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 28, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 28, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 28, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      } else {
        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 28, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 28, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      }
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 28, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
/* … */
    __Pyx_TraceLine(28,0,__PYX_ERR(0, 28, __pyx_L1_error))
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+029:     not_post.insert(ord(p))

    __Pyx_TraceLine(29,0,__PYX_ERR(0, 29, __pyx_L1_error))
    __pyx_t_5 = __Pyx_PyObject_Ord(__pyx_cur_scope->__pyx_v_p); if (unlikely(__pyx_t_5 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 29, __pyx_L1_error)
    try {
      __pyx_cur_scope->__pyx_v_not_post.insert(__pyx_t_5);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 29, __pyx_L1_error)
    }

 030: 

+031:   lenS = len(seq)

  __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error))
  __pyx_t_2 = PyObject_Length(__pyx_cur_scope->__pyx_v_seq); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 31, __pyx_L1_error)
  __pyx_cur_scope->__pyx_v_lenS = __pyx_t_2;

+032:   starts.push_back(0)

  __Pyx_TraceLine(32,0,__PYX_ERR(0, 32, __pyx_L1_error))
  try {
    __pyx_cur_scope->__pyx_v_starts.push_back(0);
  } catch(...) {
    __Pyx_CppExn2PyErr();
    __PYX_ERR(0, 32, __pyx_L1_error)
  }

+033:   length_accepted = lambda x : x >= min_len and x <= max_len

/* Python wrapper */
static PyObject *__pyx_pw_3bin_19getDigestedPeptides_lambda(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/
static PyMethodDef __pyx_mdef_3bin_19getDigestedPeptides_lambda = {"lambda", (PyCFunction)__pyx_pw_3bin_19getDigestedPeptides_lambda, METH_O, 0};
static PyObject *__pyx_pw_3bin_19getDigestedPeptides_lambda(PyObject *__pyx_self, PyObject *__pyx_v_x) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda (wrapper)", 0);
  __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, ((PyObject *)__pyx_v_x));

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

static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_x) {
  struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *__pyx_cur_scope;
  struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *__pyx_outer_scope;
  PyObject *__pyx_r = NULL;
  __Pyx_TraceDeclarations
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda", 0);
  __pyx_outer_scope = (struct __pyx_obj_3bin___pyx_scope_struct__getDigestedPeptides *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
  __Pyx_TraceCall("lambda", __pyx_f[0], 33, 0, __PYX_ERR(0, 33, __pyx_L1_error));
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_min_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_x, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 33, __pyx_L1_error)
  if (__pyx_t_4) {
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = __pyx_t_3;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_max_len); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_RichCompare(__pyx_v_x, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_1 = __pyx_t_2;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_L3_bool_binop_done:;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("bin.getDigestedPeptides.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error))
  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_3bin_19getDigestedPeptides_lambda, 0, __pyx_n_s_getDigestedPeptides_locals_lambd, ((PyObject*)__pyx_cur_scope), __pyx_n_s_bin, __pyx_d, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_length_accepted = __pyx_t_1;
  __pyx_t_1 = 0;

+034:   methionineCleavage = methionineCleavage and seq[0] == "M"

  __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error))
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_methionineCleavage); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 34, __pyx_L1_error)
  if (__pyx_t_6) {
  } else {
    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
    __pyx_t_1 = __pyx_cur_scope->__pyx_v_methionineCleavage;
    goto __pyx_L8_bool_binop_done;
  }
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_4, __pyx_n_s_M, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_1 = __pyx_t_7;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_L8_bool_binop_done:;
  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
  __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_methionineCleavage, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 035: 

+036:   if digestion == 'none':

  __Pyx_TraceLine(36,0,__PYX_ERR(0, 36, __pyx_L1_error))
  __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_cur_scope->__pyx_v_digestion, __pyx_n_s_none, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 36, __pyx_L1_error)
  if (__pyx_t_6) {
/* … */
    goto __pyx_L10;
  }

+037:     for i in range(lenS + 1):

    __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error))
    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_lenS + 1);
    __pyx_t_8 = __pyx_t_5;
    for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
      __pyx_cur_scope->__pyx_v_i = __pyx_t_9;

+038:       for j in range(i + min_len, i + max_len + 1):

      __Pyx_TraceLine(38,0,__PYX_ERR(0, 38, __pyx_L1_error))
      __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_i + __pyx_cur_scope->__pyx_v_min_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_7 = __Pyx_PyInt_From_long(((__pyx_cur_scope->__pyx_v_i + __pyx_cur_scope->__pyx_v_max_len) + 1)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __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_7);
      PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7);
      __pyx_t_1 = 0;
      __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
        __pyx_t_4 = __pyx_t_7; __Pyx_INCREF(__pyx_t_4); __pyx_t_2 = 0;
        __pyx_t_3 = NULL;
      } else {
        __pyx_t_2 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_3 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      for (;;) {
        if (likely(!__pyx_t_3)) {
          if (likely(PyList_CheckExact(__pyx_t_4))) {
            if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_4)) break;
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 38, __pyx_L1_error)
            #else
            __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            #endif
          } else {
            if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 38, __pyx_L1_error)
            #else
            __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            #endif
          }
        } else {
          __pyx_t_7 = __pyx_t_3(__pyx_t_4);
          if (unlikely(!__pyx_t_7)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
              else __PYX_ERR(0, 38, __pyx_L1_error)
            }
            break;
          }
          __Pyx_GOTREF(__pyx_t_7);
        }
        __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_j);
        __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_j, __pyx_t_7);
        __Pyx_GIVEREF(__pyx_t_7);
        __pyx_t_7 = 0;
/* … */
        __Pyx_TraceLine(38,0,__PYX_ERR(0, 38, __pyx_L1_error))
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }

+039:         if j < lenS:

        __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error))
        __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_lenS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_1 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_j, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 39, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (__pyx_t_6) {
/* … */
        }

+040:           yield seq[i:j]

          __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error))
          __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_i, 0, NULL, &__pyx_cur_scope->__pyx_v_j, NULL, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_r = __pyx_t_1;
          __pyx_t_1 = 0;
          __pyx_cur_scope->__pyx_t_0 = __pyx_t_2;
          __pyx_cur_scope->__pyx_t_1 = __pyx_t_3;
          __Pyx_XGIVEREF(__pyx_t_4);
          __pyx_cur_scope->__pyx_t_2 = __pyx_t_4;
          __pyx_cur_scope->__pyx_t_3 = __pyx_t_5;
          __pyx_cur_scope->__pyx_t_4 = __pyx_t_8;
          __pyx_cur_scope->__pyx_t_5 = __pyx_t_9;
          __Pyx_XGIVEREF(__pyx_r);
          __Pyx_TraceReturn(__pyx_r, 0);
          __Pyx_RefNannyFinishContext();
          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
          /* return from generator, yielding value */
          __pyx_generator->resume_label = 1;
          return __pyx_r;
          __pyx_L16_resume_from_yield:;
          __pyx_t_2 = __pyx_cur_scope->__pyx_t_0;
          __pyx_t_3 = __pyx_cur_scope->__pyx_t_1;
          __pyx_t_4 = __pyx_cur_scope->__pyx_t_2;
          __pyx_cur_scope->__pyx_t_2 = 0;
          __Pyx_XGOTREF(__pyx_t_4);
          __pyx_t_5 = __pyx_cur_scope->__pyx_t_3;
          __pyx_t_8 = __pyx_cur_scope->__pyx_t_4;
          __pyx_t_9 = __pyx_cur_scope->__pyx_t_5;
          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 40, __pyx_L1_error)

+041:   elif digestion == 'semi':

  __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L1_error))
  __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_cur_scope->__pyx_v_digestion, __pyx_n_s_semi, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 41, __pyx_L1_error)
  if (__pyx_t_6) {
/* … */
    goto __pyx_L10;
  }

+042:     for i in range(lenS + 1):

    __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error))
    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_lenS + 1);
    __pyx_t_8 = __pyx_t_5;
    for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
      __pyx_cur_scope->__pyx_v_i = __pyx_t_9;

+043:       isCleavageSite = (seq[min([lenS-1,i])] in pre2 and seq[min([lenS-1,i+1])] not in not_post2)

      __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error))
      __pyx_t_10 = __pyx_cur_scope->__pyx_v_i;
      __pyx_t_11 = (__pyx_cur_scope->__pyx_v_lenS - 1);
      if (((__pyx_t_10 < __pyx_t_11) != 0)) {
        __pyx_t_12 = __pyx_t_10;
      } else {
        __pyx_t_12 = __pyx_t_11;
      }
      __pyx_t_11 = __pyx_t_12;
      __pyx_t_1 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_cur_scope->__pyx_v_pre2, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_6) {
      } else {
        __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __pyx_t_1 = 0;
        goto __pyx_L19_bool_binop_done;
      }
      __pyx_t_11 = (__pyx_cur_scope->__pyx_v_i + 1);
      __pyx_t_12 = (__pyx_cur_scope->__pyx_v_lenS - 1);
      if (((__pyx_t_11 < __pyx_t_12) != 0)) {
        __pyx_t_13 = __pyx_t_11;
      } else {
        __pyx_t_13 = __pyx_t_12;
      }
      __pyx_t_11 = __pyx_t_13;
      __pyx_t_1 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_cur_scope->__pyx_v_not_post2, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __pyx_t_1;
      __pyx_t_1 = 0;
      __pyx_L19_bool_binop_done:;
      __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_isCleavageSite);
      __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_isCleavageSite, __pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_4);
      __pyx_t_4 = 0;

+044:       isMethionineCleavageSite = (i == 0 and methionineCleavage)

      __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error))
      __pyx_t_6 = (__pyx_cur_scope->__pyx_v_i == 0);
      if (__pyx_t_6) {
      } else {
        __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __pyx_t_1 = 0;
        goto __pyx_L21_bool_binop_done;
      }
      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
      __pyx_t_4 = __pyx_cur_scope->__pyx_v_methionineCleavage;
      __pyx_L21_bool_binop_done:;
      __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_isMethionineCleavageSite);
      __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_isMethionineCleavageSite, __pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_4);
      __pyx_t_4 = 0;

+045:       if i == lenS or isCleavageSite or isMethionineCleavageSite:

      __Pyx_TraceLine(45,0,__PYX_ERR(0, 45, __pyx_L1_error))
      __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_i == __pyx_cur_scope->__pyx_v_lenS) != 0);
      if (!__pyx_t_14) {
      } else {
        __pyx_t_6 = __pyx_t_14;
        goto __pyx_L24_bool_binop_done;
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_isCleavageSite); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 45, __pyx_L1_error)
      if (!__pyx_t_14) {
      } else {
        __pyx_t_6 = __pyx_t_14;
        goto __pyx_L24_bool_binop_done;
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_isMethionineCleavageSite); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 45, __pyx_L1_error)
      __pyx_t_6 = __pyx_t_14;
      __pyx_L24_bool_binop_done:;
      if (__pyx_t_6) {
/* … */
        goto __pyx_L23;
      }

 046:         # peptides with enzymatic C-terminal (both enzymatic and non-enzymatic N-terminal)

+047:         start = starts[0]

        __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error))
        __pyx_cur_scope->__pyx_v_start = (__pyx_cur_scope->__pyx_v_starts[0]);

+048:         for j in range(start, min([i+1, lenS])):

        __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error))
        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_10 = __pyx_cur_scope->__pyx_v_lenS;
        __pyx_t_11 = (__pyx_cur_scope->__pyx_v_i + 1);
        if (((__pyx_t_10 < __pyx_t_11) != 0)) {
          __pyx_t_13 = __pyx_t_10;
        } else {
          __pyx_t_13 = __pyx_t_11;
        }
        __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_GIVEREF(__pyx_t_4);
        PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_1);
        PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_1);
        __pyx_t_4 = 0;
        __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
          __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); __pyx_t_2 = 0;
          __pyx_t_3 = NULL;
        } else {
          __pyx_t_2 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_3 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        for (;;) {
          if (likely(!__pyx_t_3)) {
            if (likely(PyList_CheckExact(__pyx_t_7))) {
              if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_7)) break;
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 48, __pyx_L1_error)
              #else
              __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              #endif
            } else {
              if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 48, __pyx_L1_error)
              #else
              __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              #endif
            }
          } else {
            __pyx_t_1 = __pyx_t_3(__pyx_t_7);
            if (unlikely(!__pyx_t_1)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
                else __PYX_ERR(0, 48, __pyx_L1_error)
              }
              break;
            }
            __Pyx_GOTREF(__pyx_t_1);
          }
          __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_j);
          __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_j, __pyx_t_1);
          __Pyx_GIVEREF(__pyx_t_1);
          __pyx_t_1 = 0;
/* … */
          __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error))
        }
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+049:           lenP = min([i, lenS - 1]) - j + 1

          __Pyx_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L1_error))
          __pyx_t_13 = (__pyx_cur_scope->__pyx_v_lenS - 1);
          __pyx_t_10 = __pyx_cur_scope->__pyx_v_i;
          if (((__pyx_t_13 < __pyx_t_10) != 0)) {
            __pyx_t_11 = __pyx_t_13;
          } else {
            __pyx_t_11 = __pyx_t_10;
          }
          __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_cur_scope->__pyx_v_j); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_cur_scope->__pyx_v_lenP = __pyx_t_10;

+050:           if length_accepted(lenP):

          __Pyx_TraceLine(50,0,__PYX_ERR(0, 50, __pyx_L1_error))
          __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_lenP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_4 = __pyx_lambda_funcdef_lambda(__pyx_cur_scope->__pyx_v_length_accepted, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 50, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (__pyx_t_6) {
/* … */
          }

+051:             yield (seq[j : i + 1])

            __Pyx_TraceLine(51,0,__PYX_ERR(0, 51, __pyx_L1_error))
            __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_seq, 0, (__pyx_cur_scope->__pyx_v_i + 1), &__pyx_cur_scope->__pyx_v_j, NULL, NULL, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_r = __pyx_t_4;
            __pyx_t_4 = 0;
            __pyx_cur_scope->__pyx_t_0 = __pyx_t_2;
            __pyx_cur_scope->__pyx_t_1 = __pyx_t_3;
            __pyx_cur_scope->__pyx_t_3 = __pyx_t_5;
            __Pyx_XGIVEREF(__pyx_t_7);
            __pyx_cur_scope->__pyx_t_2 = __pyx_t_7;
            __pyx_cur_scope->__pyx_t_4 = __pyx_t_8;
            __pyx_cur_scope->__pyx_t_5 = __pyx_t_9;
            __Pyx_XGIVEREF(__pyx_r);
            __Pyx_TraceReturn(__pyx_r, 0);
            __Pyx_RefNannyFinishContext();
            __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
            /* return from generator, yielding value */
            __pyx_generator->resume_label = 2;
            return __pyx_r;
            __pyx_L30_resume_from_yield:;
            __pyx_t_2 = __pyx_cur_scope->__pyx_t_0;
            __pyx_t_3 = __pyx_cur_scope->__pyx_t_1;
            __pyx_t_5 = __pyx_cur_scope->__pyx_t_3;
            __pyx_t_7 = __pyx_cur_scope->__pyx_t_2;
            __pyx_cur_scope->__pyx_t_2 = 0;
            __Pyx_XGOTREF(__pyx_t_7);
            __pyx_t_8 = __pyx_cur_scope->__pyx_t_4;
            __pyx_t_9 = __pyx_cur_scope->__pyx_t_5;
            if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 51, __pyx_L1_error)

+052:         starts.push_back(i + 1)

        __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error))
        try {
          __pyx_cur_scope->__pyx_v_starts.push_back((__pyx_cur_scope->__pyx_v_i + 1));
        } catch(...) {
          __Pyx_CppExn2PyErr();
          __PYX_ERR(0, 52, __pyx_L1_error)
        }

+053:         methionineCleaved = int(methionineCleavage and starts[0] == 0)

        __Pyx_TraceLine(53,0,__PYX_ERR(0, 53, __pyx_L1_error))
        __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_methionineCleavage); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 53, __pyx_L1_error)
        if (__pyx_t_6) {
        } else {
          __Pyx_INCREF(__pyx_cur_scope->__pyx_v_methionineCleavage);
          __pyx_t_7 = __pyx_cur_scope->__pyx_v_methionineCleavage;
          goto __pyx_L31_bool_binop_done;
        }
        __pyx_t_6 = ((__pyx_cur_scope->__pyx_v_starts[0]) == 0);
        __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_7 = __pyx_t_4;
        __pyx_t_4 = 0;
        __pyx_L31_bool_binop_done:;
        __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_cur_scope->__pyx_v_methionineCleaved = __pyx_t_10;

+054:         if len(starts) > miscleavages + 1 + methionineCleaved or i == lenS:

        __Pyx_TraceLine(54,0,__PYX_ERR(0, 54, __pyx_L1_error))
        __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_cur_scope->__pyx_v_starts); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 54, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_2 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 54, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_14 = ((__pyx_t_2 > ((__pyx_cur_scope->__pyx_v_miscleavages + 1) + __pyx_cur_scope->__pyx_v_methionineCleaved)) != 0);
        if (!__pyx_t_14) {
        } else {
          __pyx_t_6 = __pyx_t_14;
          goto __pyx_L34_bool_binop_done;
        }
        __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_i == __pyx_cur_scope->__pyx_v_lenS) != 0);
        __pyx_t_6 = __pyx_t_14;
        __pyx_L34_bool_binop_done:;
        if (__pyx_t_6) {
/* … */
        }

+055:           starts = starts[1 + methionineCleaved:]

          __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error))
          __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_cur_scope->__pyx_v_starts); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_4, (1 + __pyx_cur_scope->__pyx_v_methionineCleaved), 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 55, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_15 = __pyx_convert_vector_from_py_int(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_cur_scope->__pyx_v_starts = __pyx_t_15;

 056:       else: # peptides with non enzymatic C-terminal

+057:         for start in starts:

      __Pyx_TraceLine(57,0,__PYX_ERR(0, 57, __pyx_L1_error))
      /*else*/ {
        __pyx_t_16 = __pyx_cur_scope->__pyx_v_starts.begin();
        for (;;) {
          if (!(__pyx_t_16 != __pyx_cur_scope->__pyx_v_starts.end())) break;
          __pyx_t_10 = *__pyx_t_16;
          ++__pyx_t_16;
          __pyx_cur_scope->__pyx_v_start = __pyx_t_10;
/* … */
          __Pyx_TraceLine(57,0,__PYX_ERR(0, 57, __pyx_L1_error))
        }
      }
      __pyx_L23:;
    }

+058:           lenP = i - start + 1

          __Pyx_TraceLine(58,0,__PYX_ERR(0, 58, __pyx_L1_error))
          __pyx_cur_scope->__pyx_v_lenP = ((__pyx_cur_scope->__pyx_v_i - __pyx_cur_scope->__pyx_v_start) + 1);

+059:           if length_accepted(lenP) and starts[-1] == i + 1:

          __Pyx_TraceLine(59,0,__PYX_ERR(0, 59, __pyx_L1_error))
          __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_lenP); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_4 = __pyx_lambda_funcdef_lambda(__pyx_cur_scope->__pyx_v_length_accepted, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 59, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 59, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (__pyx_t_14) {
          } else {
            __pyx_t_6 = __pyx_t_14;
            goto __pyx_L39_bool_binop_done;
          }
          __pyx_t_14 = (((__pyx_cur_scope->__pyx_v_starts[-1L]) == (__pyx_cur_scope->__pyx_v_i + 1)) != 0);
          __pyx_t_6 = __pyx_t_14;
          __pyx_L39_bool_binop_done:;
          if (__pyx_t_6) {
/* … */
          }

+060:             yield (seq[start : i + 1])

            __Pyx_TraceLine(60,0,__PYX_ERR(0, 60, __pyx_L1_error))
            __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_start, (__pyx_cur_scope->__pyx_v_i + 1), NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_r = __pyx_t_4;
            __pyx_t_4 = 0;
            __pyx_cur_scope->__pyx_t_3 = __pyx_t_5;
            __pyx_cur_scope->__pyx_t_4 = __pyx_t_8;
            __pyx_cur_scope->__pyx_t_5 = __pyx_t_9;
            __pyx_cur_scope->__pyx_t_6 = __pyx_t_16;
            __Pyx_XGIVEREF(__pyx_r);
            __Pyx_TraceReturn(__pyx_r, 0);
            __Pyx_RefNannyFinishContext();
            __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
            /* return from generator, yielding value */
            __pyx_generator->resume_label = 3;
            return __pyx_r;
            __pyx_L41_resume_from_yield:;
            __pyx_t_5 = __pyx_cur_scope->__pyx_t_3;
            __pyx_t_8 = __pyx_cur_scope->__pyx_t_4;
            __pyx_t_9 = __pyx_cur_scope->__pyx_t_5;
            __pyx_t_16 = __pyx_cur_scope->__pyx_t_6;
            if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 60, __pyx_L1_error)

 061:   else:

+062:     hasMethionineCleavage = False

  __Pyx_TraceLine(62,0,__PYX_ERR(0, 62, __pyx_L1_error))
  /*else*/ {
    __pyx_cur_scope->__pyx_v_hasMethionineCleavage = 0;

+063:     if methionineCleavage and seq[0] == 'M':

    __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error))
    __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_methionineCleavage); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 63, __pyx_L1_error)
    if (__pyx_t_14) {
    } else {
      __pyx_t_6 = __pyx_t_14;
      goto __pyx_L43_bool_binop_done;
    }
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_M, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 63, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_6 = __pyx_t_14;
    __pyx_L43_bool_binop_done:;
    if (__pyx_t_6) {
/* … */
    }

+064:       cleavageSites.push_back(0)

      __Pyx_TraceLine(64,0,__PYX_ERR(0, 64, __pyx_L1_error))
      try {
        __pyx_cur_scope->__pyx_v_cleavageSites.push_back(0);
      } catch(...) {
        __Pyx_CppExn2PyErr();
        __PYX_ERR(0, 64, __pyx_L1_error)
      }

+065:       hasMethionineCleavage = True

      __Pyx_TraceLine(65,0,__PYX_ERR(0, 65, __pyx_L1_error))
      __pyx_cur_scope->__pyx_v_hasMethionineCleavage = 1;

+066:     for i in range(lenS):

    __Pyx_TraceLine(66,0,__PYX_ERR(0, 66, __pyx_L1_error))
    __pyx_t_9 = __pyx_cur_scope->__pyx_v_lenS;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_10; __pyx_t_17+=1) {
      __pyx_cur_scope->__pyx_v_i = __pyx_t_17;

+067:       if pre.find(ord(seq[i])) != pre.end() and not_post.find(ord(seq[min([lenS-1,i+1])])) == not_post.end():

      __Pyx_TraceLine(67,0,__PYX_ERR(0, 67, __pyx_L1_error))
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_PyObject_Ord(__pyx_t_4); if (unlikely(__pyx_t_5 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 67, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_pre.find(__pyx_t_5) != __pyx_cur_scope->__pyx_v_pre.end()) != 0);
      if (__pyx_t_14) {
      } else {
        __pyx_t_6 = __pyx_t_14;
        goto __pyx_L48_bool_binop_done;
      }
      __pyx_t_5 = (__pyx_cur_scope->__pyx_v_i + 1);
      __pyx_t_8 = (__pyx_cur_scope->__pyx_v_lenS - 1);
      if (((__pyx_t_5 < __pyx_t_8) != 0)) {
        __pyx_t_11 = __pyx_t_5;
      } else {
        __pyx_t_11 = __pyx_t_8;
      }
      __pyx_t_5 = __pyx_t_11;
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_seq, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_PyObject_Ord(__pyx_t_4); if (unlikely(__pyx_t_5 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 67, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_not_post.find(__pyx_t_5) == __pyx_cur_scope->__pyx_v_not_post.end()) != 0);
      __pyx_t_6 = __pyx_t_14;
      __pyx_L48_bool_binop_done:;
      if (__pyx_t_6) {
/* … */
      }
    }

+068:         cleavageSites.push_back(i)

        __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error))
        try {
          __pyx_cur_scope->__pyx_v_cleavageSites.push_back(__pyx_cur_scope->__pyx_v_i);
        } catch(...) {
          __Pyx_CppExn2PyErr();
          __PYX_ERR(0, 68, __pyx_L1_error)
        }

+069:     cleavageSites.push_back(lenS)

    __Pyx_TraceLine(69,0,__PYX_ERR(0, 69, __pyx_L1_error))
    try {
      __pyx_cur_scope->__pyx_v_cleavageSites.push_back(__pyx_cur_scope->__pyx_v_lenS);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 69, __pyx_L1_error)
    }

+070:     for i in cleavageSites:

    __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error))
    __pyx_t_16 = __pyx_cur_scope->__pyx_v_cleavageSites.begin();
    for (;;) {
      if (!(__pyx_t_16 != __pyx_cur_scope->__pyx_v_cleavageSites.end())) break;
      __pyx_t_9 = *__pyx_t_16;
      ++__pyx_t_16;
      __pyx_cur_scope->__pyx_v_i = __pyx_t_9;
/* … */
      __Pyx_TraceLine(70,0,__PYX_ERR(0, 70, __pyx_L1_error))
    }
  }
  __pyx_L10:;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

+071:       for start in starts:

      __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error))
      __pyx_t_18 = __pyx_cur_scope->__pyx_v_starts.begin();
      for (;;) {
        if (!(__pyx_t_18 != __pyx_cur_scope->__pyx_v_starts.end())) break;
        __pyx_t_9 = *__pyx_t_18;
        ++__pyx_t_18;
        __pyx_cur_scope->__pyx_v_start = __pyx_t_9;
/* … */
        __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error))
      }

+072:         lenP = i - start + 1

        __Pyx_TraceLine(72,0,__PYX_ERR(0, 72, __pyx_L1_error))
        __pyx_cur_scope->__pyx_v_lenP = ((__pyx_cur_scope->__pyx_v_i - __pyx_cur_scope->__pyx_v_start) + 1);

+073:         if lenP >= min_len and lenP <= max_len:

        __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error))
        __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_lenP >= __pyx_cur_scope->__pyx_v_min_len) != 0);
        if (__pyx_t_14) {
        } else {
          __pyx_t_6 = __pyx_t_14;
          goto __pyx_L55_bool_binop_done;
        }
        __pyx_t_14 = ((__pyx_cur_scope->__pyx_v_lenP <= __pyx_cur_scope->__pyx_v_max_len) != 0);
        __pyx_t_6 = __pyx_t_14;
        __pyx_L55_bool_binop_done:;
        if (__pyx_t_6) {
/* … */
        }

+074:           yield (seq[start : i + 1])

          __Pyx_TraceLine(74,0,__PYX_ERR(0, 74, __pyx_L1_error))
          __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_start, (__pyx_cur_scope->__pyx_v_i + 1), NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 74, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_r = __pyx_t_4;
          __pyx_t_4 = 0;
          __pyx_cur_scope->__pyx_t_6 = __pyx_t_16;
          __pyx_cur_scope->__pyx_t_7 = __pyx_t_18;
          __Pyx_XGIVEREF(__pyx_r);
          __Pyx_TraceReturn(__pyx_r, 0);
          __Pyx_RefNannyFinishContext();
          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
          /* return from generator, yielding value */
          __pyx_generator->resume_label = 4;
          return __pyx_r;
          __pyx_L57_resume_from_yield:;
          __pyx_t_16 = __pyx_cur_scope->__pyx_t_6;
          __pyx_t_18 = __pyx_cur_scope->__pyx_t_7;
          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 74, __pyx_L1_error)

+075:       starts.push_back(i + 1)

      __Pyx_TraceLine(75,0,__PYX_ERR(0, 75, __pyx_L1_error))
      try {
        __pyx_cur_scope->__pyx_v_starts.push_back((__pyx_cur_scope->__pyx_v_i + 1));
      } catch(...) {
        __Pyx_CppExn2PyErr();
        __PYX_ERR(0, 75, __pyx_L1_error)
      }

+076:       methionineCleaved = int(starts[0] == 0 and hasMethionineCleavage)

      __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error))
      __pyx_t_6 = ((__pyx_cur_scope->__pyx_v_starts[0]) == 0);
      if (__pyx_t_6) {
      } else {
        __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 76, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_4 = __pyx_t_7;
        __pyx_t_7 = 0;
        goto __pyx_L58_bool_binop_done;
      }
      __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_cur_scope->__pyx_v_hasMethionineCleavage); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 76, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_4 = __pyx_t_7;
      __pyx_t_7 = 0;
      __pyx_L58_bool_binop_done:;
      __pyx_t_7 = __Pyx_PyNumber_Int(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 76, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_cur_scope->__pyx_v_methionineCleaved = __pyx_t_9;

+077:       if starts.size() > miscleavages + one + methionineCleaved:

      __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error))
      __pyx_t_6 = ((__pyx_cur_scope->__pyx_v_starts.size() > ((__pyx_cur_scope->__pyx_v_miscleavages + __pyx_cur_scope->__pyx_v_one) + __pyx_cur_scope->__pyx_v_methionineCleaved)) != 0);
      if (__pyx_t_6) {
/* … */
      }

+078:         starts = starts[one + methionineCleaved:]

        __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error))
        __pyx_t_7 = __pyx_convert_vector_to_py_int(__pyx_cur_scope->__pyx_v_starts); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_7, (__pyx_cur_scope->__pyx_v_one + __pyx_cur_scope->__pyx_v_methionineCleaved), 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_15 = __pyx_convert_vector_from_py_int(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 78, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_cur_scope->__pyx_v_starts = __pyx_t_15;

 079: 

+080: def readFastaMaxQuant(filePath, db = "target", parseId = lambda x : x.split(" ")[0], specialAAs = ['R', 'K']):

/* Python wrapper */
static PyObject *__pyx_pw_3bin_8lambda1(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/
static PyMethodDef __pyx_mdef_3bin_8lambda1 = {"lambda1", (PyCFunction)__pyx_pw_3bin_8lambda1, METH_O, 0};
static PyObject *__pyx_pw_3bin_8lambda1(PyObject *__pyx_self, PyObject *__pyx_v_x) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda1 (wrapper)", 0);
  __pyx_r = __pyx_lambda_funcdef_3bin_lambda1(__pyx_self, ((PyObject *)__pyx_v_x));

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

static PyObject *__pyx_lambda_funcdef_3bin_lambda1(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_TraceDeclarations
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda1", 0);
  __Pyx_TraceCall("lambda1", __pyx_f[0], 80, 0, __PYX_ERR(0, 80, __pyx_L1_error));
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s_);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("bin.lambda1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_3bin_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
static PyObject *__pyx_pf_3bin_11__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_TraceDeclarations
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__defaults__", 0);
  __Pyx_TraceCall("__defaults__", __pyx_f[0], 80, 0, __PYX_ERR(0, 80, __pyx_L1_error));
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject*)__pyx_n_s_target));
  __Pyx_GIVEREF(((PyObject*)__pyx_n_s_target));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject*)__pyx_n_s_target));
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_parseId);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_parseId);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_parseId);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_specialAAs);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_specialAAs);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_specialAAs);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("bin.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_3bin_4readFastaMaxQuant(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_3bin_4readFastaMaxQuant = {"readFastaMaxQuant", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3bin_4readFastaMaxQuant, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_3bin_4readFastaMaxQuant(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_filePath = 0;
  PyObject *__pyx_v_db = 0;
  PyObject *__pyx_v_parseId = 0;
  PyObject *__pyx_v_specialAAs = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("readFastaMaxQuant (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filePath,&__pyx_n_s_db,&__pyx_n_s_parseId,&__pyx_n_s_specialAAs,0};
    PyObject* values[4] = {0,0,0,0};
    __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self);
    values[1] = ((PyObject *)((PyObject*)__pyx_n_s_target));
    values[2] = __pyx_dynamic_args->__pyx_arg_parseId;
    values[3] = __pyx_dynamic_args->__pyx_arg_specialAAs;
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        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_filePath)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_db);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_parseId);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_specialAAs);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readFastaMaxQuant") < 0)) __PYX_ERR(0, 80, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        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);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_filePath = values[0];
    __pyx_v_db = values[1];
    __pyx_v_parseId = values[2];
    __pyx_v_specialAAs = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("readFastaMaxQuant", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 80, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("bin.readFastaMaxQuant", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_3bin_3readFastaMaxQuant(__pyx_self, __pyx_v_filePath, __pyx_v_db, __pyx_v_parseId, __pyx_v_specialAAs);

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

static PyObject *__pyx_pf_3bin_3readFastaMaxQuant(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filePath, PyObject *__pyx_v_db, PyObject *__pyx_v_parseId, PyObject *__pyx_v_specialAAs) {
  struct __pyx_obj_3bin___pyx_scope_struct_1_readFastaMaxQuant *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("readFastaMaxQuant", 0);
  __pyx_cur_scope = (struct __pyx_obj_3bin___pyx_scope_struct_1_readFastaMaxQuant *)__pyx_tp_new_3bin___pyx_scope_struct_1_readFastaMaxQuant(__pyx_ptype_3bin___pyx_scope_struct_1_readFastaMaxQuant, __pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_3bin___pyx_scope_struct_1_readFastaMaxQuant *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 80, __pyx_L1_error)
  } else {
    __Pyx_GOTREF(__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_filePath = __pyx_v_filePath;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_filePath);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_filePath);
  __pyx_cur_scope->__pyx_v_db = __pyx_v_db;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_db);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_db);
  __pyx_cur_scope->__pyx_v_parseId = __pyx_v_parseId;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_parseId);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_parseId);
  __pyx_cur_scope->__pyx_v_specialAAs = __pyx_v_specialAAs;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_specialAAs);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_specialAAs);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_3bin_5generator1, __pyx_codeobj__3, (PyObject *) __pyx_cur_scope, __pyx_n_s_readFastaMaxQuant, __pyx_n_s_readFastaMaxQuant, __pyx_n_s_bin); if (unlikely(!gen)) __PYX_ERR(0, 80, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("bin.readFastaMaxQuant", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_3bin_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("readFastaMaxQuant", 0);
  __Pyx_TraceDeclarations
  __Pyx_TraceFrameInit(__pyx_codeobj__3)
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 80, __pyx_L1_error)
/* … */
  /* function exit code */
  PyErr_SetNone(PyExc_StopIteration);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_AddTraceback("readFastaMaxQuant", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__11 = PyTuple_Pack(10, __pyx_n_s_filePath, __pyx_n_s_db, __pyx_n_s_parseId, __pyx_n_s_specialAAs, __pyx_n_s_i, __pyx_n_s_hasSpecialAAs, __pyx_n_s_name_2, __pyx_n_s_seq, __pyx_n_s_fp, __pyx_n_s_line); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);
/* … */
  __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error))
  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_3bin_4readFastaMaxQuant, 0, __pyx_n_s_readFastaMaxQuant, NULL, __pyx_n_s_bin, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_1, sizeof(__pyx_defaults1), 2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_3bin_8lambda1, 0, __pyx_n_s_readFastaMaxQuant_locals_lambda, NULL, __pyx_n_s_bin, __pyx_d, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_1)->__pyx_arg_parseId = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_R);
  __Pyx_GIVEREF(__pyx_n_s_R);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_R);
  __Pyx_INCREF(__pyx_n_s_K);
  __Pyx_GIVEREF(__pyx_n_s_K);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_K);
  __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_1)->__pyx_arg_specialAAs = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_1, __pyx_pf_3bin_11__defaults__);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_readFastaMaxQuant, __pyx_t_1) < 0) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_bin_digestfast_pyx, __pyx_n_s_readFastaMaxQuant, 80, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 80, __pyx_L1_error)

 081:   cdef int i

+082:   if db not in ["target", "decoy", "concat"]:

  __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error))
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_db);
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_db;
  __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_target, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 82, __pyx_L1_error)
  if (__pyx_t_3) {
  } else {
    __pyx_t_2 = __pyx_t_3;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_decoy, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 82, __pyx_L1_error)
  if (__pyx_t_3) {
  } else {
    __pyx_t_2 = __pyx_t_3;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_concat, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 82, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_3;
  __pyx_L5_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
/* … */
  }

+083:     sys.exit("unknown db mode: %s" % db)

    __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error))
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyString_FormatSafe(__pyx_kp_s_unknown_db_mode_s, __pyx_cur_scope->__pyx_v_db); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
      if (likely(__pyx_t_6)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_5, function);
      }
    }
    __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 084: 

+085:   hasSpecialAAs = len(specialAAs) > 0

  __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __pyx_L1_error))
  __pyx_t_7 = PyObject_Length(__pyx_cur_scope->__pyx_v_specialAAs); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 85, __pyx_L1_error)
  __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_t_7 > 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_hasSpecialAAs = __pyx_t_1;
  __pyx_t_1 = 0;

+086:   name, seq = None, []

  __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error))
  __pyx_t_1 = Py_None;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_name = __pyx_t_1;
  __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_seq = ((PyObject*)__pyx_t_5);
  __pyx_t_5 = 0;

+087:   with open(filePath, 'r') as fp:

  __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error))
  /*with:*/ {
    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_filePath);
    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_filePath);
    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_filePath);
    __Pyx_INCREF(__pyx_n_s_r);
    __Pyx_GIVEREF(__pyx_n_s_r);
    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_r);
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_exit_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L8_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_6)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L8_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __pyx_t_5;
    __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          __Pyx_GIVEREF(__pyx_t_4);
          __pyx_cur_scope->__pyx_v_fp = __pyx_t_4;
          __pyx_t_4 = 0;
/* … */
        }
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
        goto __pyx_L17_try_end;
        __pyx_L12_error:;
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        /*except:*/ {
          __Pyx_AddTraceback("bin.readFastaMaxQuant", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_13, &__pyx_t_19) < 0) __PYX_ERR(0, 87, __pyx_L14_except_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_4 = PyTuple_Pack(3, __pyx_t_5, __pyx_t_13, __pyx_t_19); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L14_except_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_21 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, NULL);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 87, __pyx_L14_except_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          if (__pyx_t_2 < 0) __PYX_ERR(0, 87, __pyx_L14_except_error)
          __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
          if (__pyx_t_3) {
            __Pyx_GIVEREF(__pyx_t_5);
            __Pyx_GIVEREF(__pyx_t_13);
            __Pyx_XGIVEREF(__pyx_t_19);
            __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_13, __pyx_t_19);
            __pyx_t_5 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; 
            __PYX_ERR(0, 87, __pyx_L14_except_error)
          }
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          goto __pyx_L13_exception_handled;
        }
        __pyx_L14_except_error:;
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_XGIVEREF(__pyx_t_11);
        __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
        goto __pyx_L1_error;
        __pyx_L13_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_XGIVEREF(__pyx_t_11);
        __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
        __pyx_L17_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_8) {
          __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__8, NULL);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_11);
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        }
        goto __pyx_L11;
      }
      __pyx_L11:;
    }
    goto __pyx_L38;
    __pyx_L8_error:;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    goto __pyx_L1_error;
    __pyx_L38:;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* … */
  __pyx_tuple__8 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

+088:     for line in itertools.chain(fp, [">"]):

          __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L12_error))
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_itertools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L12_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_chain); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L12_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L12_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_INCREF(__pyx_kp_s__4);
          __Pyx_GIVEREF(__pyx_kp_s__4);
          PyList_SET_ITEM(__pyx_t_1, 0, __pyx_kp_s__4);
          __pyx_t_6 = NULL;
          __pyx_t_12 = 0;
          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
            if (likely(__pyx_t_6)) {
              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
              __Pyx_INCREF(__pyx_t_6);
              __Pyx_INCREF(function);
              __Pyx_DECREF_SET(__pyx_t_5, function);
              __pyx_t_12 = 1;
            }
          }
          #if CYTHON_FAST_PYCALL
          if (PyFunction_Check(__pyx_t_5)) {
            PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_fp, __pyx_t_1};
            __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L12_error)
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          } else
          #endif
          #if CYTHON_FAST_PYCCALL
          if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
            PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_fp, __pyx_t_1};
            __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L12_error)
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          } else
          #endif
          {
            __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 88, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_13);
            if (__pyx_t_6) {
              __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_6); __pyx_t_6 = NULL;
            }
            __Pyx_INCREF(__pyx_cur_scope->__pyx_v_fp);
            __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_fp);
            PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_cur_scope->__pyx_v_fp);
            __Pyx_GIVEREF(__pyx_t_1);
            PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_1);
            __pyx_t_1 = 0;
            __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
            __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_7 = 0;
            __pyx_t_14 = NULL;
          } else {
            __pyx_t_7 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_14 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 88, __pyx_L12_error)
          }
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          for (;;) {
            if (likely(!__pyx_t_14)) {
              if (likely(PyList_CheckExact(__pyx_t_5))) {
                if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_5)) break;
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 88, __pyx_L12_error)
                #else
                __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L12_error)
                __Pyx_GOTREF(__pyx_t_4);
                #endif
              } else {
                if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 88, __pyx_L12_error)
                #else
                __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L12_error)
                __Pyx_GOTREF(__pyx_t_4);
                #endif
              }
            } else {
              __pyx_t_4 = __pyx_t_14(__pyx_t_5);
              if (unlikely(!__pyx_t_4)) {
                PyObject* exc_type = PyErr_Occurred();
                if (exc_type) {
                  if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
                  else __PYX_ERR(0, 88, __pyx_L12_error)
                }
                break;
              }
              __Pyx_GOTREF(__pyx_t_4);
            }
            __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_line);
            __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_line, __pyx_t_4);
            __Pyx_GIVEREF(__pyx_t_4);
            __pyx_t_4 = 0;
/* … */
            __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L12_error))
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+089:       line = line.rstrip()

            __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L12_error))
            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_line, __pyx_n_s_rstrip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 89, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_1 = NULL;
            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
              __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_13);
              if (likely(__pyx_t_1)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
                __Pyx_INCREF(__pyx_t_1);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_13, function);
              }
            }
            __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_13);
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_line);
            __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_line, __pyx_t_4);
            __Pyx_GIVEREF(__pyx_t_4);
            __pyx_t_4 = 0;

+090:       if line.startswith(">"):

            __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L12_error))
            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_line, __pyx_n_s_startswith); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 90, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_1 = NULL;
            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
              __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_13);
              if (likely(__pyx_t_1)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
                __Pyx_INCREF(__pyx_t_1);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_13, function);
              }
            }
            __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_1, __pyx_kp_s__4) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__4);
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 90, __pyx_L12_error)
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (__pyx_t_3) {
/* … */
              goto __pyx_L20;
            }

+091:         if name:

              __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L12_error))
              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_name); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 91, __pyx_L12_error)
              if (__pyx_t_3) {
/* … */
              }

+092:           if db in ["target", "concat"]:

                __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L12_error))
                __Pyx_INCREF(__pyx_cur_scope->__pyx_v_db);
                __pyx_t_4 = __pyx_cur_scope->__pyx_v_db;
                __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_target, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 92, __pyx_L12_error)
                if (!__pyx_t_2) {
                } else {
                  __pyx_t_3 = __pyx_t_2;
                  goto __pyx_L23_bool_binop_done;
                }
                __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_concat, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 92, __pyx_L12_error)
                __pyx_t_3 = __pyx_t_2;
                __pyx_L23_bool_binop_done:;
                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                __pyx_t_2 = (__pyx_t_3 != 0);
                if (__pyx_t_2) {
/* … */
                }

+093:             yield (name, "".join(seq))

                  __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L12_error))
                  __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_cur_scope->__pyx_v_seq); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_4);
                  __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 93, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name);
                  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name);
                  PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_cur_scope->__pyx_v_name);
                  __Pyx_GIVEREF(__pyx_t_4);
                  PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_4);
                  __pyx_t_4 = 0;
                  __pyx_r = __pyx_t_13;
                  __pyx_t_13 = 0;
                  __Pyx_XGIVEREF(__pyx_t_5);
                  __pyx_cur_scope->__pyx_t_0 = __pyx_t_5;
                  __pyx_cur_scope->__pyx_t_1 = __pyx_t_7;
                  __Pyx_XGIVEREF(__pyx_t_8);
                  __pyx_cur_scope->__pyx_t_2 = __pyx_t_8;
                  __Pyx_XGIVEREF(__pyx_t_9);
                  __pyx_cur_scope->__pyx_t_3 = __pyx_t_9;
                  __Pyx_XGIVEREF(__pyx_t_10);
                  __pyx_cur_scope->__pyx_t_4 = __pyx_t_10;
                  __Pyx_XGIVEREF(__pyx_t_11);
                  __pyx_cur_scope->__pyx_t_5 = __pyx_t_11;
                  __pyx_cur_scope->__pyx_t_6 = __pyx_t_14;
                  __Pyx_XGIVEREF(__pyx_r);
                  __Pyx_TraceReturn(__pyx_r, 0);
                  __Pyx_RefNannyFinishContext();
                  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
                  /* return from generator, yielding value */
                  __pyx_generator->resume_label = 1;
                  return __pyx_r;
                  __pyx_L25_resume_from_yield:;
                  __pyx_t_5 = __pyx_cur_scope->__pyx_t_0;
                  __pyx_cur_scope->__pyx_t_0 = 0;
                  __Pyx_XGOTREF(__pyx_t_5);
                  __pyx_t_7 = __pyx_cur_scope->__pyx_t_1;
                  __pyx_t_8 = __pyx_cur_scope->__pyx_t_2;
                  __pyx_cur_scope->__pyx_t_2 = 0;
                  __Pyx_XGOTREF(__pyx_t_8);
                  __pyx_t_9 = __pyx_cur_scope->__pyx_t_3;
                  __pyx_cur_scope->__pyx_t_3 = 0;
                  __Pyx_XGOTREF(__pyx_t_9);
                  __pyx_t_10 = __pyx_cur_scope->__pyx_t_4;
                  __pyx_cur_scope->__pyx_t_4 = 0;
                  __Pyx_XGOTREF(__pyx_t_10);
                  __pyx_t_11 = __pyx_cur_scope->__pyx_t_5;
                  __pyx_cur_scope->__pyx_t_5 = 0;
                  __Pyx_XGOTREF(__pyx_t_11);
                  __pyx_t_14 = __pyx_cur_scope->__pyx_t_6;
                  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 93, __pyx_L12_error)

 094: 

+095:           if db in ["decoy", "concat"]:

                __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L12_error))
                __Pyx_INCREF(__pyx_cur_scope->__pyx_v_db);
                __pyx_t_13 = __pyx_cur_scope->__pyx_v_db;
                __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_13, __pyx_n_s_decoy, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 95, __pyx_L12_error)
                if (!__pyx_t_3) {
                } else {
                  __pyx_t_2 = __pyx_t_3;
                  goto __pyx_L27_bool_binop_done;
                }
                __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_13, __pyx_n_s_concat, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 95, __pyx_L12_error)
                __pyx_t_2 = __pyx_t_3;
                __pyx_L27_bool_binop_done:;
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __pyx_t_3 = (__pyx_t_2 != 0);
                if (__pyx_t_3) {
/* … */
                }

+096:             seq = list("".join(seq)[::-1])

                  __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L12_error))
                  __pyx_t_13 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_cur_scope->__pyx_v_seq); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 96, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_13, __pyx_slice__6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_4);
                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                  __pyx_t_13 = PySequence_List(__pyx_t_4); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 96, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_seq);
                  __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_seq, ((PyObject*)__pyx_t_13));
                  __Pyx_GIVEREF(__pyx_t_13);
                  __pyx_t_13 = 0;
/* … */
  __pyx_slice__6 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__6)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__6);
  __Pyx_GIVEREF(__pyx_slice__6);

+097:             if hasSpecialAAs:

                  __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L12_error))
                  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_hasSpecialAAs); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 97, __pyx_L12_error)
                  if (__pyx_t_3) {
/* … */
                  }

+098:               for i in range(1, len(seq)):

                    __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L12_error))
                    __pyx_t_15 = PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_seq); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 98, __pyx_L12_error)
                    __pyx_t_16 = __pyx_t_15;
                    for (__pyx_t_12 = 1; __pyx_t_12 < __pyx_t_16; __pyx_t_12+=1) {
                      __pyx_cur_scope->__pyx_v_i = __pyx_t_12;

+099:                 if seq[i] in specialAAs:

                      __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L12_error))
                      __pyx_t_13 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 99, __pyx_L12_error)
                      __Pyx_GOTREF(__pyx_t_13);
                      __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_13, __pyx_cur_scope->__pyx_v_specialAAs, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 99, __pyx_L12_error)
                      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                      __pyx_t_2 = (__pyx_t_3 != 0);
                      if (__pyx_t_2) {
/* … */
                      }
                    }

+100:                   swapPositions(seq, i, i-1)

                        __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L12_error))
                        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_swapPositions); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L12_error)
                        __Pyx_GOTREF(__pyx_t_4);
                        __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L12_error)
                        __Pyx_GOTREF(__pyx_t_1);
                        __pyx_t_6 = __Pyx_PyInt_From_long((__pyx_cur_scope->__pyx_v_i - 1)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 100, __pyx_L12_error)
                        __Pyx_GOTREF(__pyx_t_6);
                        __pyx_t_17 = NULL;
                        __pyx_t_18 = 0;
                        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
                          __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_4);
                          if (likely(__pyx_t_17)) {
                            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
                            __Pyx_INCREF(__pyx_t_17);
                            __Pyx_INCREF(function);
                            __Pyx_DECREF_SET(__pyx_t_4, function);
                            __pyx_t_18 = 1;
                          }
                        }
                        #if CYTHON_FAST_PYCALL
                        if (PyFunction_Check(__pyx_t_4)) {
                          PyObject *__pyx_temp[4] = {__pyx_t_17, __pyx_cur_scope->__pyx_v_seq, __pyx_t_1, __pyx_t_6};
                          __pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 100, __pyx_L12_error)
                          __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
                          __Pyx_GOTREF(__pyx_t_13);
                          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                          __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[4] = {__pyx_t_17, __pyx_cur_scope->__pyx_v_seq, __pyx_t_1, __pyx_t_6};
                          __pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 100, __pyx_L12_error)
                          __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
                          __Pyx_GOTREF(__pyx_t_13);
                          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                        } else
                        #endif
                        {
                          __pyx_t_19 = PyTuple_New(3+__pyx_t_18); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 100, __pyx_L12_error)
                          __Pyx_GOTREF(__pyx_t_19);
                          if (__pyx_t_17) {
                            __Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_17); __pyx_t_17 = NULL;
                          }
                          __Pyx_INCREF(__pyx_cur_scope->__pyx_v_seq);
                          __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_seq);
                          PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_18, __pyx_cur_scope->__pyx_v_seq);
                          __Pyx_GIVEREF(__pyx_t_1);
                          PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_18, __pyx_t_1);
                          __Pyx_GIVEREF(__pyx_t_6);
                          PyTuple_SET_ITEM(__pyx_t_19, 2+__pyx_t_18, __pyx_t_6);
                          __pyx_t_1 = 0;
                          __pyx_t_6 = 0;
                          __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_19, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 100, __pyx_L12_error)
                          __Pyx_GOTREF(__pyx_t_13);
                          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
                        }
                        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+101:             yield ("REV__" + name, "".join(seq))

                  __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L12_error))
                  __pyx_t_13 = PyNumber_Add(__pyx_n_s_REV, __pyx_cur_scope->__pyx_v_name); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 101, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_cur_scope->__pyx_v_seq); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_4);
                  __pyx_t_19 = PyTuple_New(2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 101, __pyx_L12_error)
                  __Pyx_GOTREF(__pyx_t_19);
                  __Pyx_GIVEREF(__pyx_t_13);
                  PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_13);
                  __Pyx_GIVEREF(__pyx_t_4);
                  PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_4);
                  __pyx_t_13 = 0;
                  __pyx_t_4 = 0;
                  __pyx_r = __pyx_t_19;
                  __pyx_t_19 = 0;
                  __Pyx_XGIVEREF(__pyx_t_5);
                  __pyx_cur_scope->__pyx_t_0 = __pyx_t_5;
                  __pyx_cur_scope->__pyx_t_1 = __pyx_t_7;
                  __Pyx_XGIVEREF(__pyx_t_8);
                  __pyx_cur_scope->__pyx_t_2 = __pyx_t_8;
                  __Pyx_XGIVEREF(__pyx_t_9);
                  __pyx_cur_scope->__pyx_t_3 = __pyx_t_9;
                  __Pyx_XGIVEREF(__pyx_t_10);
                  __pyx_cur_scope->__pyx_t_4 = __pyx_t_10;
                  __Pyx_XGIVEREF(__pyx_t_11);
                  __pyx_cur_scope->__pyx_t_5 = __pyx_t_11;
                  __pyx_cur_scope->__pyx_t_6 = __pyx_t_14;
                  __Pyx_XGIVEREF(__pyx_r);
                  __Pyx_TraceReturn(__pyx_r, 0);
                  __Pyx_RefNannyFinishContext();
                  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
                  /* return from generator, yielding value */
                  __pyx_generator->resume_label = 2;
                  return __pyx_r;
                  __pyx_L33_resume_from_yield:;
                  __pyx_t_5 = __pyx_cur_scope->__pyx_t_0;
                  __pyx_cur_scope->__pyx_t_0 = 0;
                  __Pyx_XGOTREF(__pyx_t_5);
                  __pyx_t_7 = __pyx_cur_scope->__pyx_t_1;
                  __pyx_t_8 = __pyx_cur_scope->__pyx_t_2;
                  __pyx_cur_scope->__pyx_t_2 = 0;
                  __Pyx_XGOTREF(__pyx_t_8);
                  __pyx_t_9 = __pyx_cur_scope->__pyx_t_3;
                  __pyx_cur_scope->__pyx_t_3 = 0;
                  __Pyx_XGOTREF(__pyx_t_9);
                  __pyx_t_10 = __pyx_cur_scope->__pyx_t_4;
                  __pyx_cur_scope->__pyx_t_4 = 0;
                  __Pyx_XGOTREF(__pyx_t_10);
                  __pyx_t_11 = __pyx_cur_scope->__pyx_t_5;
                  __pyx_cur_scope->__pyx_t_5 = 0;
                  __Pyx_XGOTREF(__pyx_t_11);
                  __pyx_t_14 = __pyx_cur_scope->__pyx_t_6;
                  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 101, __pyx_L12_error)

 102: 

+103:         if len(line) > 1:

              __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L12_error))
              __pyx_t_15 = PyObject_Length(__pyx_cur_scope->__pyx_v_line); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 103, __pyx_L12_error)
              __pyx_t_2 = ((__pyx_t_15 > 1) != 0);
              if (__pyx_t_2) {
/* … */
              }

+104:           name, seq = parseId(line[1:]), []

                __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L12_error))
                __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_line, 1, 0, NULL, NULL, &__pyx_slice__7, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L12_error)
                __Pyx_GOTREF(__pyx_t_4);
                __Pyx_INCREF(__pyx_cur_scope->__pyx_v_parseId);
                __pyx_t_13 = __pyx_cur_scope->__pyx_v_parseId; __pyx_t_6 = NULL;
                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
                  __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_13);
                  if (likely(__pyx_t_6)) {
                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
                    __Pyx_INCREF(__pyx_t_6);
                    __Pyx_INCREF(function);
                    __Pyx_DECREF_SET(__pyx_t_13, function);
                  }
                }
                __pyx_t_19 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_6, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4);
                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 104, __pyx_L12_error)
                __Pyx_GOTREF(__pyx_t_19);
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __pyx_t_13 = PyList_New(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 104, __pyx_L12_error)
                __Pyx_GOTREF(__pyx_t_13);
                __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_name);
                __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_name, __pyx_t_19);
                __Pyx_GIVEREF(__pyx_t_19);
                __pyx_t_19 = 0;
                __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_seq);
                __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_seq, ((PyObject*)__pyx_t_13));
                __Pyx_GIVEREF(__pyx_t_13);
                __pyx_t_13 = 0;
/* … */
  __pyx_slice__7 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__7)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__7);
  __Pyx_GIVEREF(__pyx_slice__7);

+105:       else: seq.append(line)

            __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L12_error))
            /*else*/ {
              __pyx_t_20 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_seq, __pyx_cur_scope->__pyx_v_line); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(0, 105, __pyx_L12_error)
            }
            __pyx_L20:;

 106: 

+107: def swapPositions(seq, pos1, pos2):

/* Python wrapper */
static PyObject *__pyx_pw_3bin_7swapPositions(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_3bin_7swapPositions = {"swapPositions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3bin_7swapPositions, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_3bin_7swapPositions(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_seq = 0;
  PyObject *__pyx_v_pos1 = 0;
  PyObject *__pyx_v_pos2 = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("swapPositions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_seq,&__pyx_n_s_pos1,&__pyx_n_s_pos2,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_seq)) != 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_pos1)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("swapPositions", 1, 3, 3, 1); __PYX_ERR(0, 107, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pos2)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("swapPositions", 1, 3, 3, 2); __PYX_ERR(0, 107, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "swapPositions") < 0)) __PYX_ERR(0, 107, __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_seq = values[0];
    __pyx_v_pos1 = values[1];
    __pyx_v_pos2 = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("swapPositions", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 107, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("bin.swapPositions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_3bin_6swapPositions(__pyx_self, __pyx_v_seq, __pyx_v_pos1, __pyx_v_pos2);

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

static PyObject *__pyx_pf_3bin_6swapPositions(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_seq, PyObject *__pyx_v_pos1, PyObject *__pyx_v_pos2) {
  PyObject *__pyx_r = NULL;
  __Pyx_TraceDeclarations
  __Pyx_TraceFrameInit(__pyx_codeobj__9)
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("swapPositions", 0);
  __Pyx_TraceCall("swapPositions", __pyx_f[0], 107, 0, __PYX_ERR(0, 107, __pyx_L1_error));
/* … */
  /* 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_AddTraceback("bin.swapPositions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_TraceReturn(__pyx_r, 0);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_seq, __pyx_n_s_pos1, __pyx_n_s_pos2); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);
/* … */
  __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error))
  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_3bin_7swapPositions, 0, __pyx_n_s_swapPositions, NULL, __pyx_n_s_bin, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_swapPositions, __pyx_t_1) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+108:   seq[pos1], seq[pos2] = seq[pos2], seq[pos1]

  __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error))
  __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_seq, __pyx_v_pos2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_seq, __pyx_v_pos1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(PyObject_SetItem(__pyx_v_seq, __pyx_v_pos1, __pyx_t_1) < 0)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(PyObject_SetItem(__pyx_v_seq, __pyx_v_pos2, __pyx_t_2) < 0)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;