+001: # -*- coding: utf-8 -*-

  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 002: # cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False

 003: """

 004: Internal use only base class for objects

 005: that can be waited on and then asked to notify (wake up)

 006: waiters.  Examples include locks, events, semaphores.

 007: 

 008: gevent has the generic concept of "linkable" objects, or the "linkable"

 009: protocol, which is the ``link`` and ``rawlink`` methods. (Actually sending

 010: the notification is up to the implementation of the individual

 011: objects.) `gevent.greenlet.Greenlet` implements this protocol but

 012: does not extend this object (TODO: It probably should.)

 013: """

+014: import sys

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_sys, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sys, __pyx_t_2) < (0)) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+015: from gc import get_objects

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_objects};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gc, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_objects};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_XGOTREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_get_objects);
        __Pyx_DECREF_SET(__pyx_v_6gevent_27_gevent_c_abstract_linkable_get_objects, __pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_4);
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 016: 

+017: from greenlet import greenlet

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_greenlet};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_greenlet, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+018: from greenlet import error as greenlet_error

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_error};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_greenlet, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_error};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_greenlet_error, __pyx_t_4) < (0)) __PYX_ERR(0, 18, __pyx_L1_error)
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 019: 

+020: from gevent._compat import thread_mod_name

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_thread_mod_name};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent__compat, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_thread_mod_name};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 20, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 20, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+021: from gevent._hub_local import get_hub_noargs as get_hub

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_hub_noargs};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent__hub_local, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_hub_noargs};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 21, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_hub_noargs, __pyx_t_4) < (0)) __PYX_ERR(0, 21, __pyx_L1_error)
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+022: from gevent._hub_local import get_hub_if_exists

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_hub_if_exists};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent__hub_local, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_hub_if_exists};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 22, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 023: 

+024: from gevent.exceptions import InvalidSwitchError

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_InvalidSwitchError};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent_exceptions, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_InvalidSwitchError};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 24, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_XGOTREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidSwitchError);
        __Pyx_DECREF_SET(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidSwitchError, __pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_4);
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+025: from gevent.exceptions import InvalidThreadUseError

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_InvalidThreadUseError};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent_exceptions, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_InvalidThreadUseError};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_XGOTREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidThreadUseError);
        __Pyx_DECREF_SET(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidThreadUseError, __pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_4);
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+026: from gevent.timeout import Timeout

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Timeout};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent_timeout, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Timeout};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_XGOTREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout);
        __Pyx_DECREF_SET(__pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout, __pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_4);
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 027: 

+028: locals()['getcurrent'] = __import__('greenlet').getcurrent

  __pyx_t_4 = NULL;
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_n_u_greenlet};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin___import__, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_getcurrent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_Globals(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely((PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_getcurrent, __pyx_t_4) < 0))) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+029: locals()['greenlet_init'] = lambda: None

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_lambda = {"lambda", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_lambda, METH_NOARGS, 0};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_lambda_funcdef_6gevent_27_gevent_c_abstract_linkable_lambda(__pyx_self);

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

static PyObject *__pyx_lambda_funcdef_6gevent_27_gevent_c_abstract_linkable_lambda(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_lambda, 0, __pyx_mstate_global->__pyx_n_u_lambda, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4);
  #endif
  __pyx_t_2 = __Pyx_Globals(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely((PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_greenlet_init, __pyx_t_4) < 0))) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 030: 

+031: __all__ = [

  __pyx_t_4 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_AbstractLinkable); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_t_4) < (0)) __PYX_ERR(0, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 032:     'AbstractLinkable',

 033: ]

 034: 

 035: # Need the real get_ident. We're imported early enough during monkey-patching

 036: # that we can be sure nothing is monkey patched yet.

+037: _get_thread_ident = __import__(thread_mod_name).get_ident

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_thread_mod_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_6};
    __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin___import__, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_ident); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_XGOTREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident);
  __Pyx_DECREF_SET(__pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_6);
  __pyx_t_6 = 0;

+038: _allocate_thread_lock = __import__(thread_mod_name).allocate_lock

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_thread_mod_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_2};
    __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin___import__, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 38, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_allocate_lock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_allocate_thread_lock, __pyx_t_2) < (0)) __PYX_ERR(0, 38, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 039: 

 040: # Reserve _notifier before a foreign thread wakes the owner loop. It mirrors

 041: # the callback attributes used by the wait and unlink paths.

 042: class _FakeNotifier(object):

 043:     __slots__ = (

+044:         'args',

  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable__FakeNotifier, __pyx_mstate_global->__pyx_n_u_slots, __pyx_mstate_global->__pyx_tuple[2]) < (0)) __PYX_ERR(0, 43, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_args, __pyx_mstate_global->__pyx_n_u_pending); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 44, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);

 045:         'pending',

 046:     )

 047: 

+048:     def __init__(self):

/* Python wrapper */
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return -1;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__init__", __pyx_kwds); return -1;}
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier___init__(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *)__pyx_v_self));

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

static int __pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier___init__(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *__pyx_v_self) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable._FakeNotifier.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+049:         self.args = ([],)

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 49, __pyx_L1_error);
  __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_GOTREF(__pyx_v_self->args);
  __Pyx_DECREF(__pyx_v_self->args);
  __pyx_v_self->args = __pyx_t_2;
  __pyx_t_2 = 0;

+050:         self.pending = True

  __pyx_v_self->pending = 1;

 051: 

+052:     def stop(self):

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_3stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_2stop, "_FakeNotifier.stop(self)");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_3stop = {"stop", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_3stop, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_2stop};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_3stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("stop (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_2stop(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_2stop(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_3stop, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_FakeNotifier_stop, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable__FakeNotifier, __pyx_mstate_global->__pyx_n_u_stop, __pyx_t_2) < (0)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+053:         self.args = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->args);
  __Pyx_DECREF(__pyx_v_self->args);
  __pyx_v_self->args = Py_None;

+054:         self.pending = False

  __pyx_v_self->pending = 0;

 055: 

+056:     def __bool__(self):

/* Python wrapper */
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_5__bool__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_5__bool__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__bool__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_4__bool__(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *)__pyx_v_self));

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

static int __pyx_pf_6gevent_27_gevent_c_abstract_linkable_13_FakeNotifier_4__bool__(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *__pyx_v_self) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

+057:         return self.args is not None

  __pyx_t_1 = (__pyx_v_self->args != Py_None);
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

 058: 

+059: def get_roots_and_hubs():

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_get_roots_and_hubs(void) {
  PyObject *__pyx_v_Hub = NULL;
  PyObject *__pyx_7genexpr__pyx_v_x = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.get_roots_and_hubs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_Hub);
  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_x);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+060:     from gevent.hub import Hub # delay import

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Hub};
    __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent_hub, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Hub};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_1, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      switch (__pyx_t_3) {
        case 0:
        __Pyx_INCREF(__pyx_t_4);
        __pyx_v_Hub = __pyx_t_4;
        break;
        default:;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+061:     return {

  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);

+062:         x.parent: x

        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_7genexpr__pyx_v_x, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_t_4, (PyObject*)__pyx_7genexpr__pyx_v_x))) __PYX_ERR(0, 62, __pyx_L5_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+063:         for x in get_objects()

    __pyx_t_5 = NULL;
    __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_get_objects);
    __pyx_t_6 = __pyx_v_6gevent_27_gevent_c_abstract_linkable_get_objects; 
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
      __pyx_t_6 = __pyx_t_4; __Pyx_INCREF(__pyx_t_6);
      __pyx_t_3 = 0;
      __pyx_t_8 = NULL;
    } else {
      __pyx_t_3 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 63, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 63, __pyx_L5_error)
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    for (;;) {
      if (likely(!__pyx_t_8)) {
        if (likely(PyList_CheckExact(__pyx_t_6))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 63, __pyx_L5_error)
            #endif
            if (__pyx_t_3 >= __pyx_temp) break;
          }
          __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_6, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference);
          ++__pyx_t_3;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 63, __pyx_L5_error)
            #endif
            if (__pyx_t_3 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_3));
          #else
          __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_3);
          #endif
          ++__pyx_t_3;
        }
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L5_error)
      } else {
        __pyx_t_4 = __pyx_t_8(__pyx_t_6);
        if (unlikely(!__pyx_t_4)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 63, __pyx_L5_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_x, __pyx_t_4);
      __pyx_t_4 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_x); __pyx_7genexpr__pyx_v_x = 0;
    goto __pyx_L12_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_x); __pyx_7genexpr__pyx_v_x = 0;
    goto __pyx_L1_error;
    __pyx_L12_exit_scope:;
  } /* exit inner scope */
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 064:         # Make sure to only find hubs that have a loop

 065:         # and aren't destroyed. If we don't do that, we can

 066:         # get an old hub that no longer works leading to issues in

 067:         # combined test cases.

+068:         if isinstance(x, Hub) and x.loop is not None

      __pyx_t_10 = PyObject_IsInstance(__pyx_7genexpr__pyx_v_x, __pyx_v_Hub); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 68, __pyx_L5_error)
      if (__pyx_t_10) {
      } else {
        __pyx_t_9 = __pyx_t_10;
        goto __pyx_L9_bool_binop_done;
      }
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_7genexpr__pyx_v_x, __pyx_mstate_global->__pyx_n_u_loop); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 68, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_10 = (__pyx_t_4 != Py_None);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_9 = __pyx_t_10;
      __pyx_L9_bool_binop_done:;
      if (__pyx_t_9) {
/* … */
      }

 069:     }

 070: 

 071: 

+072: class AbstractLinkable(object):

struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable {
  PyObject *(*linkcount)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int __pyx_skip_dispatch);
  PyObject *(*rawlink)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *, int __pyx_skip_dispatch);
  int (*ready)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int __pyx_skip_dispatch);
  PyObject *(*unlink)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *, int __pyx_skip_dispatch);
  PyObject *(*_check_and_notify)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *);
  PyObject *(*_notify_links_from_threadsafe)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *);
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *(*_capture_hub)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int);
  PyObject *(*_AbstractLinkable__wait_to_be_notified)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int);
  void (*_quiet_unlink_all)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *);
  int (*_switch_to_hub)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *);
  PyObject *(*_notify_link_list)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *);
  PyObject *(*_notify_links)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *, int __pyx_skip_dispatch);
  PyObject *(*_handle_unswitched_notifications)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *);
  PyObject *(*_AbstractLinkable__print_unswitched_warning)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *, int);
  PyObject *(*_drop_lock_for_switch_out)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int __pyx_skip_dispatch);
  PyObject *(*_acquire_lock_for_switch_in)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int __pyx_skip_dispatch);
  PyObject *(*_wait_core)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, PyObject *, struct __pyx_opt_args_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait_core *__pyx_optional_args);
  PyObject *(*_wait_return_value)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, int, int);
  PyObject *(*_wait)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *, struct __pyx_opt_args_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait *__pyx_optional_args);
  PyObject *(*_allocate_lock)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *);
  PyGreenlet *(*_getcurrent)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *);
  PyObject *(*_get_thread_ident)(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *);
};
static struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_vtabptr_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable;

 073:     # Encapsulates the standard parts of the linking and notifying

 074:     # protocol common to both repeatable events (Event, Semaphore) and

 075:     # one-time events (AsyncResult).

 076:     #

 077:     # With a few careful exceptions, instances of this object can only

 078:     # be used from a single thread. The exception is that certain methods

 079:     # may be used from multiple threads IFF:

 080:     #

 081:     # 1.  They are documented as safe for that purpose; AND

 082:     # 2a. This object is compiled with Cython and thus is holding the GIL

 083:     #     for the entire duration of the method; OR

 084:     # 2b. A subclass ensures that a Python-level native thread lock is held

 085:     #     for the duration of the method; this is necessary in pure-Python mode.

 086:     #     The only known implementation of such

 087:     #     a subclass is for Semaphore. AND

 088:     # 3. The subclass that calls ``capture_hub`` catches

 089:     #    and handles ``InvalidThreadUseError``

 090:     #

 091:     # TODO: As of gevent 1.5, we use the same datastructures and almost

 092:     # the same algorithm as Greenlet. See about unifying them more.

 093: 

 094:     __slots__ = (

+095:         'hub',

  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_slots, __pyx_mstate_global->__pyx_tuple[3]) < (0)) __PYX_ERR(0, 94, __pyx_L1_error)

 096:         '_links',

 097:         '_notifier',

 098:         '_notify_all',

 099:         '__weakref__'

 100:     )

 101: 

+102:     def __init__(self, hub=None):

/* Python wrapper */
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_hub = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_hub,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 102, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 102, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 102, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 102, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_hub = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 102, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable___init__(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self), __pyx_v_hub);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable___init__(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_hub) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 103:         # Before this implementation, AsyncResult and Semaphore

 104:         # maintained the order of notifications, but Event did not.

 105: 

 106:         # In gevent 1.3, before Semaphore extended this class, that

 107:         # was changed to not maintain the order. It was done because

 108:         # Event guaranteed to only call callbacks once (a set) but

 109:         # AsyncResult had no such guarantees. When Semaphore was

 110:         # changed to extend this class, it lost its ordering

 111:         # guarantees. Unfortunately, that made it unfair. There are

 112:         # rare cases that this can starve a greenlet

 113:         # (https://github.com/gevent/gevent/issues/1487) and maybe

 114:         # even lead to deadlock (not tested).

 115: 

 116:         # So in gevent 1.5 we go back to maintaining order. But it's

 117:         # still important not to make duplicate calls, and it's also

 118:         # important to avoid O(n^2) behaviour that can result from

 119:         # naive use of a simple list due to the need to handle removed

 120:         # links in the _notify_links loop. Cython has special support for

 121:         # built-in sets, lists, and dicts, but not ordereddict. Rather than

 122:         # use two data structures, or a dict({link: order}), we simply use a

 123:         # list and remove objects as we go, keeping track of them so as not to

 124:         # have duplicates called. This makes `unlink` O(n), but we can avoid

 125:         # calling it in the common case in _wait_core (even so, the number of

 126:         # waiters should usually be pretty small)

+127:         self._links = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->_links);
  __Pyx_DECREF(__pyx_v_self->_links);
  __pyx_v_self->_links = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+128:         self._notifier = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->_notifier);
  __Pyx_DECREF(__pyx_v_self->_notifier);
  __pyx_v_self->_notifier = Py_None;

 129:         # This is conceptually a class attribute, defined here for ease of access in

 130:         # cython. If it's true, when notifiers fire, all existing callbacks are called.

 131:         # If its false, we only call callbacks as long as ready() returns true.

+132:         self._notify_all = True

  __pyx_v_self->_notify_all = 1;

 133:         # we don't want to do get_hub() here to allow defining module-level objects

 134:         # without initializing the hub. However, for multiple-thread safety, as soon

 135:         # as a waiting method is entered, even if it won't have to wait, we

 136:         # need to grab the hub and assign ownership. But we don't want to grab one prematurely.

 137:         # The example is three threads, the main thread and two worker threads; if we create

 138:         # a Semaphore in the main thread but only use it in the two threads, if we had grabbed

 139:         # the main thread's hub, the two worker threads would have a dependency on it, meaning that

 140:         # if the main event loop is blocked, the worker threads might get blocked too.

+141:         self.hub = hub

  __pyx_t_1 = __pyx_v_hub;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop))))) __PYX_ERR(0, 141, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->hub);
  __Pyx_DECREF((PyObject *)__pyx_v_self->hub);
  __pyx_v_self->hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_1);
  __pyx_t_1 = 0;

 142: 

+143:     def linkcount(self):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_linkcount(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_linkcount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* 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("gevent._gevent_c_abstract_linkable.AbstractLinkable.linkcount", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_2linkcount, "AbstractLinkable.linkcount(self)");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount = {"linkcount", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_2linkcount};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("linkcount (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_2linkcount(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_2linkcount(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_linkcount(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.linkcount", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_3linkcount, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable_linkcount, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_linkcount, __pyx_t_2) < (0)) __PYX_ERR(0, 143, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 144:         # For testing: how many objects are linked to this one?

+145:         return len(self._links)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_v_self->_links;
  __Pyx_INCREF(__pyx_t_1);
  if (unlikely(__pyx_t_1 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 145, __pyx_L1_error)
  }
  __pyx_t_6 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 145, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 146: 

+147:     def ready(self):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static int __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_ready(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_skip_dispatch) {
  int __pyx_r;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_ready); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready)) {
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_r = __pyx_t_6;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* 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("gevent._gevent_c_abstract_linkable.AbstractLinkable.ready", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_4ready, "AbstractLinkable.ready(self) -> bool");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready = {"ready", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_4ready};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ready (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_4ready(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_4ready(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_ready(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.ready", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_5ready, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable_ready, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_ready, __pyx_t_2) < (0)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 148:         # Instances must define this

+149:         raise NotImplementedError

  __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_NotImplementedError))), 0, 0, 0);
  __PYX_ERR(0, 149, __pyx_L1_error)

 150: 

+151:     def rawlink(self, callback):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_rawlink(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_rawlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_callback};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.rawlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_6rawlink, "AbstractLinkable.rawlink(self, callback)\n\nRegister a callback to call when this object is ready.\n\n*callback* will be called in the :class:`Hub\n<gevent.hub.Hub>`, so it must not use blocking gevent API.\n*callback* will be passed one argument: this instance.");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink = {"rawlink", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink, METH_O, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_6rawlink};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("rawlink (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_6rawlink(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self), ((PyObject *)__pyx_v_callback));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_6rawlink(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_callback) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_rawlink(__pyx_v_self, __pyx_v_callback, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.rawlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_7rawlink, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable_rawlink, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_rawlink, __pyx_t_2) < (0)) __PYX_ERR(0, 151, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 152:         """

 153:         Register a callback to call when this object is ready.

 154: 

 155:         *callback* will be called in the :class:`Hub

 156:         <gevent.hub.Hub>`, so it must not use blocking gevent API.

 157:         *callback* will be passed one argument: this instance.

 158:         """

+159:         if not callable(callback):

  __pyx_t_6 = __Pyx_PyCallable_Check(__pyx_v_callback); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 159, __pyx_L1_error)
  __pyx_t_7 = (!__pyx_t_6);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+160:             raise TypeError('Expected callable: %r' % (callback, ))

    __pyx_t_2 = NULL;
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_callback), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Expected_callable, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 160, __pyx_L1_error)

+161:         self._links.append(callback)

  if (unlikely(__pyx_v_self->_links == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
    __PYX_ERR(0, 161, __pyx_L1_error)
  }
  __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_self->_links, __pyx_v_callback); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 161, __pyx_L1_error)

+162:         self._check_and_notify()

  __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_check_and_notify(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 163: 

+164:     def unlink(self, callback):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_unlink(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_unlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_callback};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.unlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_8unlink, "AbstractLinkable.unlink(self, callback)\n\nRemove the callback set by :meth:`rawlink`");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink = {"unlink", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink, METH_O, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_8unlink};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("unlink (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_8unlink(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self), ((PyObject *)__pyx_v_callback));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_8unlink(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_callback) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_unlink(__pyx_v_self, __pyx_v_callback, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable.unlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_9unlink, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable_unlink, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_unlink, __pyx_t_2) < (0)) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 165:         """Remove the callback set by :meth:`rawlink`"""

+166:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_6);
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
    goto __pyx_L1_error;
    __pyx_L4_exception_handled:;
    __Pyx_XGIVEREF(__pyx_t_6);
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
    __pyx_L8_try_end:;
  }

+167:             self._links.remove(callback)

      __pyx_t_2 = __pyx_v_self->_links;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_callback};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_remove, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+168:         except ValueError:

    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ValueError))));
    if (__pyx_t_9) {
      __Pyx_ErrRestore(0,0,0);
      goto __pyx_L4_exception_handled;
    }
    goto __pyx_L5_except_error;

 169:             pass

 170: 

+171:         if not self._links and self._notifier is not None and self._notifier.pending:

  if (__pyx_v_self->_links == Py_None) __pyx_t_11 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_self->_links);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 171, __pyx_L1_error)
    __pyx_t_11 = (__pyx_temp != 0);
  }

  __pyx_t_12 = (!__pyx_t_11);
  if (__pyx_t_12) {
  } else {
    __pyx_t_10 = __pyx_t_12;
    goto __pyx_L12_bool_binop_done;
  }
  __pyx_t_12 = (__pyx_v_self->_notifier != Py_None);
  if (__pyx_t_12) {
  } else {
    __pyx_t_10 = __pyx_t_12;
    goto __pyx_L12_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_notifier, __pyx_mstate_global->__pyx_n_u_pending); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 171, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_10 = __pyx_t_12;
  __pyx_L12_bool_binop_done:;
  if (__pyx_t_10) {
/* … */
  }

 172:             # If we currently have one queued, but not running, de-queue it.

 173:             # This will break a reference cycle.

 174:             # (self._notifier -> self._notify_links -> self)

 175:             # If it's actually running, though, (and we're here as a result of callbacks)

 176:             # we don't want to change it; it needs to finish what its doing

 177:             # so we don't attempt to start a fresh one or swap it out from underneath the

 178:             # _notify_links method.

+179:             self._notifier.stop()

    __pyx_t_2 = __pyx_v_self->_notifier;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_stop, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 180: 

+181:     def _allocate_lock(self):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__allocate_lock(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._allocate_lock", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+182:         return _allocate_thread_lock()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_allocate_thread_lock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 183: 

+184:     def _getcurrent(self):

static PyGreenlet *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__getcurrent(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyGreenlet *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._getcurrent", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+185:         return getcurrent() # pylint:disable=undefined-variable

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_1 = ((PyObject *)__pyx_f_6gevent_27_gevent_c_abstract_linkable_getcurrent()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyGreenlet *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 186: 

+187:     def _get_thread_ident(self):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__get_thread_ident(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._get_thread_ident", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+188:         return _get_thread_ident()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident);
  __pyx_t_3 = __pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident; 
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 189: 

+190:     def _capture_hub(self, create):

static struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__capture_hub(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_v_create) {
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_v_my_hub = NULL;
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_v_current_hub = NULL;
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._capture_hub", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_my_hub);
  __Pyx_XDECREF((PyObject *)__pyx_v_current_hub);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 191:         # Subclasses should call this as the first action from any

 192:         # public method that could, in theory, block and switch

 193:         # to the hub. This may release the GIL. It may

 194:         # raise InvalidThreadUseError if the result would

 195: 

 196:         # First, detect a dead hub and drop it.

+197:         while 1:

  while (1) {

+198:             my_hub = self.hub

    __pyx_t_1 = ((PyObject *)__pyx_v_self->hub);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_my_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_1));
    __pyx_t_1 = 0;

+199:             if my_hub is None:

    __pyx_t_2 = (((PyObject *)__pyx_v_my_hub) == Py_None);
    if (__pyx_t_2) {
/* … */
    }

+200:                 break

      goto __pyx_L4_break;

+201:             if my_hub.dead: # dead is a property, could release GIL

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_my_hub), __pyx_mstate_global->__pyx_n_u_dead); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 201, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_2) {
/* … */
      goto __pyx_L6;
    }

 202:                 # back, holding GIL

+203:                 if self.hub is my_hub:

      __pyx_t_2 = (__pyx_v_self->hub == __pyx_v_my_hub);
      if (__pyx_t_2) {
/* … */
      }

+204:                     self.hub = None

        __Pyx_INCREF(Py_None);
        __Pyx_GIVEREF(Py_None);
        __Pyx_GOTREF((PyObject *)__pyx_v_self->hub);
        __Pyx_DECREF((PyObject *)__pyx_v_self->hub);
        __pyx_v_self->hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)Py_None);

+205:                     my_hub = None

        __Pyx_INCREF(Py_None);
        __Pyx_DECREF_SET(__pyx_v_my_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)Py_None));

+206:                     break

        goto __pyx_L4_break;

 207:             else:

+208:                 break

    /*else*/ {
      goto __pyx_L4_break;
    }
    __pyx_L6:;
  }
  __pyx_L4_break:;

 209: 

+210:         if self.hub is None:

  __pyx_t_2 = (((PyObject *)__pyx_v_self->hub) == Py_None);
  if (__pyx_t_2) {
/* … */
  }

 211:             # This next line might release the GIL.

+212:             current_hub = get_hub() if create else get_hub_if_exists()

    if (__pyx_v_create) {
      __pyx_t_3 = ((PyObject *)__pyx_f_6gevent_19_gevent_c_hub_local_get_hub_noargs(0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __pyx_t_3;
      __pyx_t_3 = 0;
    } else {
      __pyx_t_3 = ((PyObject *)__pyx_f_6gevent_19_gevent_c_hub_local_get_hub_if_exists(0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __pyx_t_3;
      __pyx_t_3 = 0;
    }
    __pyx_v_current_hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_1);
    __pyx_t_1 = 0;

 213: 

 214:             # We have the GIL again. Did anything change? If so,

 215:             # we lost the race.

+216:             if self.hub is None:

    __pyx_t_2 = (((PyObject *)__pyx_v_self->hub) == Py_None);
    if (__pyx_t_2) {
/* … */
    }

+217:                 self.hub = current_hub

      __Pyx_INCREF((PyObject *)__pyx_v_current_hub);
      __Pyx_GIVEREF((PyObject *)__pyx_v_current_hub);
      __Pyx_GOTREF((PyObject *)__pyx_v_self->hub);
      __Pyx_DECREF((PyObject *)__pyx_v_self->hub);
      __pyx_v_self->hub = __pyx_v_current_hub;

 218: 

+219:         if self.hub is not None and self.hub.thread_ident != _get_thread_ident():

  __pyx_t_4 = (((PyObject *)__pyx_v_self->hub) != Py_None);
  if (__pyx_t_4) {
  } else {
    __pyx_t_2 = __pyx_t_4;
    goto __pyx_L11_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->hub), __pyx_mstate_global->__pyx_n_u_thread_ident); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = NULL;
  __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident);
  __pyx_t_6 = __pyx_v_6gevent_27_gevent_c_abstract_linkable__get_thread_ident; 
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_2 = __pyx_t_4;
  __pyx_L11_bool_binop_done:;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+220:             raise InvalidThreadUseError(

    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidThreadUseError);
    __pyx_t_1 = __pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidThreadUseError; 

 221:                 self.hub,

+222:                 get_hub_if_exists(),

    __pyx_t_5 = ((PyObject *)__pyx_f_6gevent_19_gevent_c_hub_local_get_hub_if_exists(0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+223:                 getcurrent() # pylint:disable=undefined-variable

    __pyx_t_8 = ((PyObject *)__pyx_f_6gevent_27_gevent_c_abstract_linkable_getcurrent()); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 223, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_3, ((PyObject *)__pyx_v_self->hub), __pyx_t_5, __pyx_t_8};
      __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(0, 220, __pyx_L1_error)

 224:             )

+225:         return self.hub

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self->hub);
  __pyx_r = __pyx_v_self->hub;
  goto __pyx_L0;

 226: 

+227:     def _check_and_notify(self):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__check_and_notify(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_v_hub = NULL;
  PyObject *__pyx_v_loop = NULL;
  struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *__pyx_v_notifier = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF((PyObject *)__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._check_and_notify", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_hub);
  __Pyx_XDECREF(__pyx_v_loop);
  __Pyx_XDECREF((PyObject *)__pyx_v_notifier);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 228:         # If this object is ready to be notified, begin the process.

+229:         if self.ready() and self._links and not self._notifier:

  __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->ready(__pyx_v_self, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 229, __pyx_L1_error)
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  if (__pyx_v_self->_links == Py_None) __pyx_t_2 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_self->_links);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 229, __pyx_L1_error)
    __pyx_t_2 = (__pyx_temp != 0);
  }

  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->_notifier); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 229, __pyx_L1_error)
  __pyx_t_3 = (!__pyx_t_2);
  __pyx_t_1 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+230:             hub = None

    __Pyx_INCREF(Py_None);
    __pyx_v_hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)Py_None);

+231:             try:

    {
      /*try:*/ {
/* … */
      }
      __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;
      goto __pyx_L12_try_end;
      __pyx_L7_error:;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* … */
      __pyx_L9_except_error:;
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      goto __pyx_L1_error;
      __pyx_L10_except_return:;
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      goto __pyx_L0;
      __pyx_L12_try_end:;
    }

+232:                 hub = self._capture_hub(False) # Must create, we need it.

        __pyx_t_7 = ((PyObject *)((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_capture_hub(__pyx_v_self, 0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L7_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF_SET(__pyx_v_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_7));
        __pyx_t_7 = 0;

+233:             except InvalidThreadUseError:

      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidThreadUseError);
      if (__pyx_t_8) {
        __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._check_and_notify", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(0, 233, __pyx_L9_except_error)
        __Pyx_XGOTREF(__pyx_t_7);
        __Pyx_XGOTREF(__pyx_t_9);
        __Pyx_XGOTREF(__pyx_t_10);

 234:                 # Links are normally greenlet.switch methods and must be

 235:                 # notified by their owning hub. First publish a notifier that

 236:                 # coalesces foreign-thread wakeups, then wake that hub. The

 237:                 # callback returned by run_callback_threadsafe cannot itself

 238:                 # be used as _notifier: the hub may run it before this thread

 239:                 # has received and stored it.

+240:                 hub = self.hub

        __pyx_t_11 = ((PyObject *)__pyx_v_self->hub);
        __Pyx_INCREF(__pyx_t_11);
        __Pyx_DECREF_SET(__pyx_v_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_11));
        __pyx_t_11 = 0;

+241:                 loop = hub.loop

        __pyx_t_11 = __pyx_v_hub->loop;
        __Pyx_INCREF(__pyx_t_11);
        __pyx_v_loop = __pyx_t_11;
        __pyx_t_11 = 0;

+242:                 if loop is None:

        __pyx_t_1 = (__pyx_v_loop == Py_None);
        if (unlikely(__pyx_t_1)) {
/* … */
        }

 243:                     # The owner was destroyed while this thread was using the

 244:                     # linkable. Its callbacks cannot safely run anywhere else.

+245:                     raise

          __Pyx_GIVEREF(__pyx_t_7);
          __Pyx_GIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_10);
          __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_9, __pyx_t_10);
          __pyx_t_7 = 0;  __pyx_t_9 = 0;  __pyx_t_10 = 0; 
          __PYX_ERR(0, 245, __pyx_L9_except_error)

 246:                 # The check on self._notifier above and this assignment are

 247:                 # not atomic: another thread could install its own notifier

 248:                 # in between, and one of the two would be lost. That's safe

 249:                 # per the class comment above (2a/2b) when this is compiled

 250:                 # with Cython (the GIL is held for the whole method) or the

 251:                 # subclass holds a native lock (only Semaphore does). In

 252:                 # pure-Python mode without such a lock (Event, AsyncResult),

 253:                 # this is a real, currently-unclosed race.

+254:                 notifier = _FakeNotifier()

        __pyx_t_12 = NULL;
        __pyx_t_13 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL};
          __pyx_t_11 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable__FakeNotifier, __pyx_callargs+__pyx_t_13, (1-__pyx_t_13) | (__pyx_t_13*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 254, __pyx_L9_except_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_11);
        }
        __pyx_v_notifier = ((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable__FakeNotifier *)__pyx_t_11);
        __pyx_t_11 = 0;

+255:                 self._notifier = notifier

        __Pyx_INCREF((PyObject *)__pyx_v_notifier);
        __Pyx_GIVEREF((PyObject *)__pyx_v_notifier);
        __Pyx_GOTREF(__pyx_v_self->_notifier);
        __Pyx_DECREF(__pyx_v_self->_notifier);
        __pyx_v_self->_notifier = ((PyObject *)__pyx_v_notifier);

+256:                 try:

        {
          /*try:*/ {
/* … */
          }
          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
          goto __pyx_L23_try_end;
          __pyx_L16_error:;
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_XDECREF((PyObject *)__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
/* … */
          __pyx_L18_except_error:;
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
          goto __pyx_L9_except_error;
          __pyx_L23_try_end:;
        }

+257:                     loop.run_callback_threadsafe(

            __pyx_t_12 = __pyx_v_loop;
            __Pyx_INCREF(__pyx_t_12);

+258:                         self._notify_links_from_threadsafe,

            __Pyx_INCREF((PyObject *)__pyx_v_self);
            __pyx_t_17 = __pyx_v_self;
            __pyx_t_18 = __Pyx_CFunc_fbdf99__6gevent_27_gevent_c_abstract_linkable_16Abstra__etc_to_py_4self_8notifier(((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_t_17->__pyx_vtab)->_notify_links_from_threadsafe); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 258, __pyx_L16_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_19 = ((PyObject *)__pyx_t_17);
            __Pyx_INCREF(__pyx_t_19);
            __pyx_t_20 = __Pyx_PyMethod_New2Arg(__pyx_t_18, __pyx_t_19); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 258, __pyx_L16_error)
            __Pyx_GOTREF(__pyx_t_20);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF((PyObject *)__pyx_t_17); __pyx_t_17 = 0;

+259:                         notifier

            __pyx_t_13 = 0;
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_20, ((PyObject *)__pyx_v_notifier)};
              __pyx_t_11 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_run_callback_threadsafe, __pyx_callargs+__pyx_t_13, (3-__pyx_t_13) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
              if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 257, __pyx_L16_error)
              __Pyx_GOTREF(__pyx_t_11);
            }
            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

 260:                     )

+261:                 except:

          /*except:*/ {
            __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._check_and_notify", __pyx_clineno, __pyx_lineno, __pyx_filename);
            if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_20, &__pyx_t_12) < 0) __PYX_ERR(0, 261, __pyx_L18_except_error)
            __Pyx_XGOTREF(__pyx_t_11);
            __Pyx_XGOTREF(__pyx_t_20);
            __Pyx_XGOTREF(__pyx_t_12);

+262:                     if self._notifier is notifier:

            __pyx_t_1 = (__pyx_v_self->_notifier == ((PyObject *)__pyx_v_notifier));
            if (__pyx_t_1) {
/* … */
            }

+263:                         self._notifier = None

              __Pyx_INCREF(Py_None);
              __Pyx_GIVEREF(Py_None);
              __Pyx_GOTREF(__pyx_v_self->_notifier);
              __Pyx_DECREF(__pyx_v_self->_notifier);
              __pyx_v_self->_notifier = Py_None;

+264:                     raise

            __Pyx_GIVEREF(__pyx_t_11);
            __Pyx_GIVEREF(__pyx_t_20);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ErrRestoreWithState(__pyx_t_11, __pyx_t_20, __pyx_t_12);
            __pyx_t_11 = 0;  __pyx_t_20 = 0;  __pyx_t_12 = 0; 
            __PYX_ERR(0, 264, __pyx_L18_except_error)
          }

+265:                 return

        __Pyx_XDECREF(__pyx_r);
        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        goto __pyx_L10_except_return;
      }
      goto __pyx_L9_except_error;

+266:             if hub is not None:

    __pyx_t_1 = (((PyObject *)__pyx_v_hub) != Py_None);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L27;
    }

+267:                 self._notifier = hub.loop.run_callback(self._notify_links, [])

      __pyx_t_9 = __pyx_v_hub->loop;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_notify_links); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 267, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_13 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_7, __pyx_t_12};
        __pyx_t_10 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_run_callback, __pyx_callargs+__pyx_t_13, (3-__pyx_t_13) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 267, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __Pyx_GIVEREF(__pyx_t_10);
      __Pyx_GOTREF(__pyx_v_self->_notifier);
      __Pyx_DECREF(__pyx_v_self->_notifier);
      __pyx_v_self->_notifier = __pyx_t_10;
      __pyx_t_10 = 0;

 268:             else:

 269:                 # Hmm, no hub. We must be the only thing running. Then its OK

 270:                 # to just directly call the callbacks.

+271:                 self._notifier = 1

    /*else*/ {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
      __Pyx_GOTREF(__pyx_v_self->_notifier);
      __Pyx_DECREF(__pyx_v_self->_notifier);
      __pyx_v_self->_notifier = __pyx_mstate_global->__pyx_int_1;

+272:                 try:

      /*try:*/ {

+273:                     self._notify_links([])

        __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 273, __pyx_L29_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_12 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_notify_links(__pyx_v_self, ((PyObject*)__pyx_t_10), 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 273, __pyx_L29_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      }

 274:                 finally:

+275:                     self._notifier = None

      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_INCREF(Py_None);
          __Pyx_GIVEREF(Py_None);
          __Pyx_GOTREF(__pyx_v_self->_notifier);
          __Pyx_DECREF(__pyx_v_self->_notifier);
          __pyx_v_self->_notifier = Py_None;
          goto __pyx_L30;
        }
        __pyx_L29_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_XDECREF((PyObject *)__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14);
          if ( unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
          __Pyx_XGOTREF(__pyx_t_6);
          __Pyx_XGOTREF(__pyx_t_5);
          __Pyx_XGOTREF(__pyx_t_4);
          __Pyx_XGOTREF(__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_14);
          __pyx_t_8 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
          {
            __Pyx_INCREF(Py_None);
            __Pyx_GIVEREF(Py_None);
            __Pyx_GOTREF(__pyx_v_self->_notifier);
            __Pyx_DECREF(__pyx_v_self->_notifier);
            __pyx_v_self->_notifier = Py_None;
          }
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_15, __pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_6);
          __Pyx_XGIVEREF(__pyx_t_5);
          __Pyx_XGIVEREF(__pyx_t_4);
          __Pyx_ErrRestore(__pyx_t_6, __pyx_t_5, __pyx_t_4);
          __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22;
          goto __pyx_L1_error;
        }
        __pyx_L30:;
      }
    }
    __pyx_L27:;

 276: 

+277:     def _notify_links_from_threadsafe(self, notifier):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__notify_links_from_threadsafe(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_notifier) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_links_from_threadsafe", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 278:         # notifier.args[0] starts out empty, but it is not necessarily

 279:         # still empty by the time this runs: if a greenlet calls wait()

 280:         # (see _wait() below) while we're already ready() and this

 281:         # notifier is still pending, instead of registering a normal

 282:         # rawlink it appends its resume callback directly to

 283:         # notifier.args[0] (see __wait_to_be_notified()), so that it gets

 284:         # woken up along with everyone else once this callback finally

 285:         # runs.

 286:         #

 287:         # The callback may be stale after cancellation, fork, or a newer

 288:         # notification. Only the notifier that requested this wakeup may run.

+289:         if self._notifier is notifier:

  __pyx_t_1 = (__pyx_v_self->_notifier == __pyx_v_notifier);
  if (__pyx_t_1) {
/* … */
  }

+290:             if notifier:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_notifier); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 290, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
      goto __pyx_L4;
    }

+291:                 notifier.pending = False

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_notifier, __pyx_mstate_global->__pyx_n_u_pending, Py_False) < (0)) __PYX_ERR(0, 291, __pyx_L1_error)

+292:                 self._notify_links(notifier.args[0])

      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_notifier, __pyx_mstate_global->__pyx_n_u_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 292, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 292, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_3))) __PYX_ERR(0, 292, __pyx_L1_error)
      __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_notify_links(__pyx_v_self, ((PyObject*)__pyx_t_3), 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 292, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 293:             else:

+294:                 self._notifier = None

    /*else*/ {
      __Pyx_INCREF(Py_None);
      __Pyx_GIVEREF(Py_None);
      __Pyx_GOTREF(__pyx_v_self->_notifier);
      __Pyx_DECREF(__pyx_v_self->_notifier);
      __pyx_v_self->_notifier = Py_None;
    }
    __pyx_L4:;

 295: 

+296:     def _notify_link_list(self, links):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__notify_link_list(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_links) {
  int __pyx_v_only_while_ready;
  PyObject *__pyx_v_final_link = NULL;
  PyObject *__pyx_v_done = NULL;
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_v_hub = NULL;
  PyObject *__pyx_v_unswitched = NULL;
  PyObject *__pyx_v_link = NULL;
  PyObject *__pyx_v_id_link = NULL;
  PyObject *__pyx_v_traceback = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_XDECREF(__pyx_t_26);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_link_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_final_link);
  __Pyx_XDECREF(__pyx_v_done);
  __Pyx_XDECREF((PyObject *)__pyx_v_hub);
  __Pyx_XDECREF(__pyx_v_unswitched);
  __Pyx_XDECREF(__pyx_v_link);
  __Pyx_XDECREF(__pyx_v_id_link);
  __Pyx_XDECREF(__pyx_v_traceback);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 297:         # The core of the _notify_links method to notify

 298:         # links in order. Lets the ``links`` list be mutated,

 299:         # and only notifies up to the last item in the list, in case

 300:         # objects are added to it.

+301:         if not links:

  if (__pyx_v_links == Py_None) __pyx_t_1 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_links);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 301, __pyx_L1_error)
    __pyx_t_1 = (__pyx_temp != 0);
  }

  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

 302:             # HMM. How did we get here? Running two threads at once?

 303:             # Seen once on Py27/Win/Appveyor

 304:             # https://ci.appveyor.com/project/jamadden/gevent/builds/36875645/job/9wahj9ft4h4qa170

+305:             return []

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_r = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;
    goto __pyx_L0;

 306: 

+307:         only_while_ready = not self._notify_all

  __pyx_v_only_while_ready = (!__pyx_v_self->_notify_all);

+308:         final_link = links[-1]

  if (unlikely(__pyx_v_links == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
    __PYX_ERR(0, 308, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_links, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 308, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_final_link = __pyx_t_3;
  __pyx_t_3 = 0;

+309:         done = set() # of ids

  __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_done = ((PyObject*)__pyx_t_3);
  __pyx_t_3 = 0;

+310:         hub = self.hub if self.hub is not None else get_hub_if_exists()

  __pyx_t_2 = (((PyObject *)__pyx_v_self->hub) != Py_None);
  if (__pyx_t_2) {
    __Pyx_INCREF((PyObject *)__pyx_v_self->hub);
    __pyx_t_3 = ((PyObject *)__pyx_v_self->hub);
  } else {
    __pyx_t_4 = ((PyObject *)__pyx_f_6gevent_19_gevent_c_hub_local_get_hub_if_exists(0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 310, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  __pyx_v_hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_3);
  __pyx_t_3 = 0;

+311:         unswitched = []

  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_unswitched = ((PyObject*)__pyx_t_3);
  __pyx_t_3 = 0;

+312:         while links: # remember this can be mutated

  while (1) {
    if (__pyx_v_links == Py_None) __pyx_t_2 = 0;
    else
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_links);
      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 312, __pyx_L1_error)
      __pyx_t_2 = (__pyx_temp != 0);
    }

    if (!__pyx_t_2) break;

+313:             if only_while_ready and not self.ready():

    if (__pyx_v_only_while_ready) {
    } else {
      __pyx_t_2 = __pyx_v_only_while_ready;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->ready(__pyx_v_self, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 313, __pyx_L1_error)
    __pyx_t_5 = (!__pyx_t_1);
    __pyx_t_2 = __pyx_t_5;
    __pyx_L7_bool_binop_done:;
    if (__pyx_t_2) {
/* … */
    }

+314:                 break

      goto __pyx_L5_break;

 315: 

+316:             link = links.pop(0) # Cython optimizes using list internals

    if (unlikely(__pyx_v_links == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
      __PYX_ERR(0, 316, __pyx_L1_error)
    }
    __pyx_t_3 = __Pyx_PyList_PopIndex(__pyx_v_links, __pyx_mstate_global->__pyx_int_0, 0, 1, Py_ssize_t, PyLong_FromSsize_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 316, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_link, __pyx_t_3);
    __pyx_t_3 = 0;

+317:             id_link = id(link)

    __pyx_t_4 = NULL;
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_link};
      __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_id, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_XDECREF_SET(__pyx_v_id_link, __pyx_t_3);
    __pyx_t_3 = 0;

+318:             if id_link not in done:

    __pyx_t_2 = (__Pyx_PySet_ContainsTF(__pyx_v_id_link, __pyx_v_done, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 318, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
    }

 319:                 # XXX: JAM: What was I thinking? This doesn't make much sense,

 320:                 # there's a good chance `link` will be deallocated, and its id() will

 321:                 # be free to be reused. This also makes looping difficult, you have to

 322:                 # create new functions inside a loop rather than just once outside the loop.

+323:                 done.add(id_link)

      __pyx_t_7 = PySet_Add(__pyx_v_done, __pyx_v_id_link); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 323, __pyx_L1_error)

+324:                 try:

      {
        /*try:*/ {
/* … */
        }
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        goto __pyx_L17_try_end;
        __pyx_L10_error:;
        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
        __pyx_L12_except_error:;
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
        goto __pyx_L1_error;
        __pyx_L11_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
        __pyx_L17_try_end:;
      }

+325:                     self._drop_lock_for_switch_out()

          __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_drop_lock_for_switch_out(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 325, __pyx_L10_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+326:                     try:

          /*try:*/ {
            {
              /*try:*/ {
/* … */
              }
              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
              goto __pyx_L30_try_end;
              __pyx_L23_error:;
              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
              __pyx_L25_except_error:;
              __Pyx_XGIVEREF(__pyx_t_11);
              __Pyx_XGIVEREF(__pyx_t_12);
              __Pyx_XGIVEREF(__pyx_t_13);
              __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
              goto __pyx_L21_error;
              __pyx_L24_exception_handled:;
              __Pyx_XGIVEREF(__pyx_t_11);
              __Pyx_XGIVEREF(__pyx_t_12);
              __Pyx_XGIVEREF(__pyx_t_13);
              __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
              __pyx_L30_try_end:;
            }
          }

+327:                         link(self)

                __pyx_t_4 = NULL;
                __Pyx_INCREF(__pyx_v_link);
                __pyx_t_14 = __pyx_v_link; 
                __pyx_t_6 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_14))) {
                  __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_14);
                  assert(__pyx_t_4);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
                  __Pyx_INCREF(__pyx_t_4);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
                  __pyx_t_6 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_self)};
                  __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_14, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
                  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
                  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 327, __pyx_L23_error)
                  __Pyx_GOTREF(__pyx_t_3);
                }
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+328:                     except greenlet_error:

              __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_14, &__pyx_t_4);
              __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_greenlet_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 328, __pyx_L25_except_error)
              __Pyx_GOTREF(__pyx_t_15);
              __pyx_t_16 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_15);
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              __Pyx_ErrRestore(__pyx_t_3, __pyx_t_14, __pyx_t_4);
              __pyx_t_3 = 0; __pyx_t_14 = 0; __pyx_t_4 = 0;
              if (__pyx_t_16) {
                __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_link_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
                if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_14, &__pyx_t_3) < 0) __PYX_ERR(0, 328, __pyx_L25_except_error)
                __Pyx_XGOTREF(__pyx_t_4);
                __Pyx_XGOTREF(__pyx_t_14);
                __Pyx_XGOTREF(__pyx_t_3);

 329:                         # couldn't switch to a greenlet, we must be

 330:                         # running in a different thread. back on the list it goes for next time.

+331:                         unswitched.append(link)

                __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_unswitched, __pyx_v_link); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 331, __pyx_L25_except_error)
                __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
                __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
                __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
                goto __pyx_L24_exception_handled;
              }
              goto __pyx_L25_except_error;

 332:                     finally:

+333:                         self._acquire_lock_for_switch_in()

          /*finally:*/ {
            /*normal exit:*/{
              __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_acquire_lock_for_switch_in(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L10_error)
              __Pyx_GOTREF(__pyx_t_3);
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              goto __pyx_L22;
            }
            __pyx_L21_error:;
            /*exception exit:*/{
              __Pyx_PyThreadState_declare
              __Pyx_PyThreadState_assign
              __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
               __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
              if ( unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
              __Pyx_XGOTREF(__pyx_t_13);
              __Pyx_XGOTREF(__pyx_t_12);
              __Pyx_XGOTREF(__pyx_t_11);
              __Pyx_XGOTREF(__pyx_t_19);
              __Pyx_XGOTREF(__pyx_t_20);
              __Pyx_XGOTREF(__pyx_t_21);
              __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
              {
                __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_acquire_lock_for_switch_in(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L36_error)
                __Pyx_GOTREF(__pyx_t_3);
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              }
              __Pyx_XGIVEREF(__pyx_t_19);
              __Pyx_XGIVEREF(__pyx_t_20);
              __Pyx_XGIVEREF(__pyx_t_21);
              __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
              __Pyx_XGIVEREF(__pyx_t_13);
              __Pyx_XGIVEREF(__pyx_t_12);
              __Pyx_XGIVEREF(__pyx_t_11);
              __Pyx_ErrRestore(__pyx_t_13, __pyx_t_12, __pyx_t_11);
              __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
              __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18;
              goto __pyx_L10_error;
              __pyx_L36_error:;
              __Pyx_XGIVEREF(__pyx_t_19);
              __Pyx_XGIVEREF(__pyx_t_20);
              __Pyx_XGIVEREF(__pyx_t_21);
              __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
              __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
              goto __pyx_L10_error;
            }
            __pyx_L22:;
          }

 334: 

+335:                 except: # pylint:disable=bare-except

        /*except:*/ {
          __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_link_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_14, &__pyx_t_4) < 0) __PYX_ERR(0, 335, __pyx_L12_except_error)
          __Pyx_XGOTREF(__pyx_t_3);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_4);

 336:                     # We're running in the hub, errors must not escape.

+337:                     if hub is not None:

          __pyx_t_2 = (((PyObject *)__pyx_v_hub) != Py_None);
          if (__pyx_t_2) {
/* … */
            goto __pyx_L39;
          }

+338:                         hub.handle_error((link, self), *sys.exc_info())

            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_hub), __pyx_mstate_global->__pyx_n_u_handle_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_t_22 = PyTuple_New(2); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_22);
            __Pyx_INCREF(__pyx_v_link);
            __Pyx_GIVEREF(__pyx_v_link);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_v_link) != (0)) __PYX_ERR(0, 338, __pyx_L12_except_error);
            __Pyx_INCREF((PyObject *)__pyx_v_self);
            __Pyx_GIVEREF((PyObject *)__pyx_v_self);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 1, ((PyObject *)__pyx_v_self)) != (0)) __PYX_ERR(0, 338, __pyx_L12_except_error);
            __pyx_t_23 = PyTuple_New(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_23);
            __Pyx_GIVEREF(__pyx_t_22);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_22) != (0)) __PYX_ERR(0, 338, __pyx_L12_except_error);
            __pyx_t_22 = 0;
            __pyx_t_24 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_25);
            __pyx_t_26 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_exc_info); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_26);
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_26))) {
              __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_26);
              assert(__pyx_t_24);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_26);
              __Pyx_INCREF(__pyx_t_24);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_26, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_24, NULL};
              __pyx_t_22 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_26, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
              __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
              if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 338, __pyx_L12_except_error)
              __Pyx_GOTREF(__pyx_t_22);
            }
            __pyx_t_26 = __Pyx_PySequence_Tuple(__pyx_t_22); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_26);
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __pyx_t_22 = PyNumber_Add(__pyx_t_23, __pyx_t_26); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_22);
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
            __pyx_t_26 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_22, NULL); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 338, __pyx_L12_except_error)
            __Pyx_GOTREF(__pyx_t_26);
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;

 339:                     else:

+340:                         import traceback

          /*else*/ {
            __pyx_t_21 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_traceback, 0, 0, NULL, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 340, __pyx_L12_except_error)
            __pyx_t_26 = __pyx_t_21;
            __Pyx_GOTREF(__pyx_t_26);
            __Pyx_XDECREF_SET(__pyx_v_traceback, __pyx_t_26);
            __pyx_t_26 = 0;

+341:                         traceback.print_exc()

            __pyx_t_22 = __pyx_v_traceback;
            __Pyx_INCREF(__pyx_t_22);
            __pyx_t_6 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
              __pyx_t_26 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_print_exc, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
              if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 341, __pyx_L12_except_error)
              __Pyx_GOTREF(__pyx_t_26);
            }
            __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
          }
          __pyx_L39:;
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          goto __pyx_L11_exception_handled;
        }

 342: 

+343:             if link is final_link:

    __pyx_t_2 = (__pyx_v_link == __pyx_v_final_link);
    if (__pyx_t_2) {
/* … */
    }
  }
  __pyx_L5_break:;

+344:                 break

      goto __pyx_L5_break;

+345:         return unswitched

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

 346: 

+347:     def _notify_links(self, arrived_while_waiting):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links(PyObject *__pyx_v_self, PyObject *__pyx_v_arrived_while_waiting); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__notify_links(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_arrived_while_waiting, int __pyx_skip_dispatch) {
  PyObject *__pyx_v_notifier = NULL;
  PyObject *__pyx_v_unswitched = NULL;
  PyObject *__pyx_v_un2 = NULL;
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_notify_links); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_arrived_while_waiting};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_links", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_notifier);
  __Pyx_XDECREF(__pyx_v_unswitched);
  __Pyx_XDECREF(__pyx_v_un2);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links(PyObject *__pyx_v_self, PyObject *__pyx_v_arrived_while_waiting); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_10_notify_links, "AbstractLinkable._notify_links(self, list arrived_while_waiting)");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links = {"_notify_links", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links, METH_O, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_10_notify_links};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links(PyObject *__pyx_v_self, PyObject *__pyx_v_arrived_while_waiting) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_notify_links (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arrived_while_waiting), (&PyList_Type), 1, "arrived_while_waiting", 1))) __PYX_ERR(0, 347, __pyx_L1_error)
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_10_notify_links(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self), ((PyObject*)__pyx_v_arrived_while_waiting));
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  goto __pyx_L5_cleaned_up;
  __pyx_L0:;
  __pyx_L5_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_10_notify_links(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_arrived_while_waiting) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__notify_links(__pyx_v_self, __pyx_v_arrived_while_waiting, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._notify_links", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_11_notify_links, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable__notify_links, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_notify_links, __pyx_t_2) < (0)) __PYX_ERR(0, 347, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 348:         # This method must hold the GIL, or be guarded with the lock that guards

 349:         # this object. Thus, while we are notifying objects, an object from another

 350:         # thread simply cannot arrive and mutate ``_links`` or ``arrived_while_waiting``

 351: 

 352:         # ``arrived_while_waiting`` is a list of greenlet.switch methods

 353:         # to call. These were objects that called wait() while we were processing,

 354:         # and which would have run *before* those that had actually waited

 355:         # and blocked. Instead of returning True immediately, we add them to this

 356:         # list so they wait their turn.

 357: 

 358:         # We release self._notifier here when done invoking links.

 359:         # The object itself becomes false in a boolean way as soon

 360:         # as this method returns.

+361:         notifier = self._notifier

  __pyx_t_1 = __pyx_v_self->_notifier;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_notifier = __pyx_t_1;
  __pyx_t_1 = 0;

+362:         if notifier is None:

  __pyx_t_6 = (__pyx_v_notifier == Py_None);
  if (__pyx_t_6) {
/* … */
  }

 363:             # XXX: How did we get here?

+364:             self._check_and_notify()

    __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_check_and_notify(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+365:             return

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

 366:         # Early links are allowed to remove later links, and links

 367:         # are allowed to add more links, thus we must not

 368:         # make a copy of our the ``_links`` list, we must traverse it and

 369:         # mutate in place.

 370:         #

 371:         # We were ready() at the time this callback was scheduled; we

 372:         # may not be anymore, and that status may change during

 373:         # callback processing. Some of our subclasses (Event) will

 374:         # want to notify everyone who was registered when the status

 375:         # became true that it was once true, even though it may not be

 376:         # any more. In that case, we must not keep notifying anyone that's

 377:         # newly added after that, even if we go ready again.

+378:         try:

  /*try:*/ {

+379:             unswitched = self._notify_link_list(self._links)

    __pyx_t_1 = __pyx_v_self->_links;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_notify_link_list(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_unswitched = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;

 380:             # Now, those that arrived after we had begun the notification

 381:             # process. Follow the same rules, stop with those that are

 382:             # added so far to prevent starvation.

+383:             if arrived_while_waiting:

    if (__pyx_v_arrived_while_waiting == Py_None) __pyx_t_6 = 0;
    else
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_arrived_while_waiting);
      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 383, __pyx_L5_error)
      __pyx_t_6 = (__pyx_temp != 0);
    }

    if (__pyx_t_6) {
/* … */
    }
  }

+384:                 un2 = self._notify_link_list(arrived_while_waiting)

      __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_notify_link_list(__pyx_v_self, __pyx_v_arrived_while_waiting); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_v_un2 = ((PyObject*)__pyx_t_2);
      __pyx_t_2 = 0;

+385:                 unswitched.extend(un2)

      if (unlikely(__pyx_v_unswitched == Py_None)) {
        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "extend");
        __PYX_ERR(0, 385, __pyx_L5_error)
      }
      __pyx_t_7 = __Pyx_PyList_Extend(__pyx_v_unswitched, __pyx_v_un2); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 385, __pyx_L5_error)

 386: 

 387:                 # Anything left needs to go back on the main list.

+388:                 self._links.extend(arrived_while_waiting)

      if (unlikely(__pyx_v_self->_links == Py_None)) {
        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "extend");
        __PYX_ERR(0, 388, __pyx_L5_error)
      }
      __pyx_t_7 = __Pyx_PyList_Extend(__pyx_v_self->_links, __pyx_v_arrived_while_waiting); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 388, __pyx_L5_error)

 389:         finally:

 390:             # We should not have created a new notifier even if callbacks

 391:             # released us because we loop through *all* of our links on the

 392:             # same callback while self._notifier is still true.

 393:             # However, one of our callbacks could have called ``os.fork``,

 394:             # which invokes ``_at_fork_reinit`` and destroys the notifier and

 395:             # hub *while this method is running*.

+396:             assert self._notifier is notifier or (

  /*finally:*/ {
    /*normal exit:*/{
      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_8 = (__pyx_v_self->_notifier == __pyx_v_notifier);
        if (!__pyx_t_8) {
        } else {
          __pyx_t_6 = __pyx_t_8;
          goto __pyx_L8_bool_binop_done;
        }
/* … */
        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_8 = (__pyx_v_self->_notifier == __pyx_v_notifier);
          if (!__pyx_t_8) {
          } else {
            __pyx_t_6 = __pyx_t_8;
            goto __pyx_L13_bool_binop_done;
          }

+397:                 self._notifier is None and self.hub is None

        __pyx_t_8 = (__pyx_v_self->_notifier == Py_None);
        if (__pyx_t_8) {
        } else {
          __pyx_t_6 = __pyx_t_8;
          goto __pyx_L8_bool_binop_done;
        }
        __pyx_t_8 = (((PyObject *)__pyx_v_self->hub) == Py_None);
        __pyx_t_6 = __pyx_t_8;
        __pyx_L8_bool_binop_done:;
        if (unlikely(!__pyx_t_6)) {
/* … */
          __pyx_t_8 = (__pyx_v_self->_notifier == Py_None);
          if (__pyx_t_8) {
          } else {
            __pyx_t_6 = __pyx_t_8;
            goto __pyx_L13_bool_binop_done;
          }
          __pyx_t_8 = (((PyObject *)__pyx_v_self->hub) == Py_None);
          __pyx_t_6 = __pyx_t_8;
          __pyx_L13_bool_binop_done:;
          if (unlikely(!__pyx_t_6)) {

+398:             ), (self, self._notifier, notifier)

          __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_INCREF((PyObject *)__pyx_v_self);
          __Pyx_GIVEREF((PyObject *)__pyx_v_self);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)) != (0)) __PYX_ERR(0, 398, __pyx_L1_error);
          __Pyx_INCREF(__pyx_v_self->_notifier);
          __Pyx_GIVEREF(__pyx_v_self->_notifier);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->_notifier) != (0)) __PYX_ERR(0, 398, __pyx_L1_error);
          __Pyx_INCREF(__pyx_v_notifier);
          __Pyx_GIVEREF(__pyx_v_notifier);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_notifier) != (0)) __PYX_ERR(0, 398, __pyx_L1_error);
          __pyx_t_1 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 398, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), __pyx_t_1, 0, 0);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __PYX_ERR(0, 396, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 396, __pyx_L1_error)
      #endif
/* … */
            __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 398, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_INCREF((PyObject *)__pyx_v_self);
            __Pyx_GIVEREF((PyObject *)__pyx_v_self);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)) != (0)) __PYX_ERR(0, 398, __pyx_L12_error);
            __Pyx_INCREF(__pyx_v_self->_notifier);
            __Pyx_GIVEREF(__pyx_v_self->_notifier);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->_notifier) != (0)) __PYX_ERR(0, 398, __pyx_L12_error);
            __Pyx_INCREF(__pyx_v_notifier);
            __Pyx_GIVEREF(__pyx_v_notifier);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_notifier) != (0)) __PYX_ERR(0, 398, __pyx_L12_error);
            __pyx_t_2 = PyTuple_Pack(1, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), __pyx_t_2, 0, 0);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __PYX_ERR(0, 396, __pyx_L12_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 396, __pyx_L12_error)
        #endif

+399:             self._notifier = None

      __Pyx_INCREF(Py_None);
      __Pyx_GIVEREF(Py_None);
      __Pyx_GOTREF(__pyx_v_self->_notifier);
      __Pyx_DECREF(__pyx_v_self->_notifier);
      __pyx_v_self->_notifier = Py_None;
      goto __pyx_L6;
    }
    __pyx_L5_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
      if ( unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
      __Pyx_XGOTREF(__pyx_t_12);
      __Pyx_XGOTREF(__pyx_t_13);
      __Pyx_XGOTREF(__pyx_t_14);
      __Pyx_XGOTREF(__pyx_t_15);
      __Pyx_XGOTREF(__pyx_t_16);
      __Pyx_XGOTREF(__pyx_t_17);
      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
      {
/* … */
        __Pyx_INCREF(Py_None);
        __Pyx_GIVEREF(Py_None);
        __Pyx_GOTREF(__pyx_v_self->_notifier);
        __Pyx_DECREF(__pyx_v_self->_notifier);
        __pyx_v_self->_notifier = Py_None;
      }
      __Pyx_XGIVEREF(__pyx_t_15);
      __Pyx_XGIVEREF(__pyx_t_16);
      __Pyx_XGIVEREF(__pyx_t_17);
      __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_13);
      __Pyx_XGIVEREF(__pyx_t_14);
      __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
      goto __pyx_L1_error;
      __pyx_L12_error:;
      __Pyx_XGIVEREF(__pyx_t_15);
      __Pyx_XGIVEREF(__pyx_t_16);
      __Pyx_XGIVEREF(__pyx_t_17);
      __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L6:;
  }

 400:             # TODO: Maybe we should intelligently reset self.hub to

 401:             # free up thread affinity? In case of a pathological situation where

 402:             # one object was used from one thread once & first,  but usually is

 403:             # used by another thread.

 404:             #

 405:             # BoundedSemaphore does this.

 406:         # Now we may be ready or not ready. If we're ready, which

 407:         # could have happened during the last link we called, then we

 408:         # must have more links than we started with. We need to schedule the

 409:         # wakeup.

+410:         self._check_and_notify()

  __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_check_and_notify(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+411:         if unswitched:

  if (__pyx_v_unswitched == Py_None) __pyx_t_6 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_unswitched);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 411, __pyx_L1_error)
    __pyx_t_6 = (__pyx_temp != 0);
  }

  if (__pyx_t_6) {
/* … */
  }

+412:             self._handle_unswitched_notifications(unswitched)

    __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_handle_unswitched_notifications(__pyx_v_self, __pyx_v_unswitched); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 413: 

 414: 

+415:     def _handle_unswitched_notifications(self, unswitched):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__handle_unswitched_notifications(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_unswitched) {
  struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *__pyx_v_hub = 0;
  PyObject *__pyx_v_root_greenlets = NULL;
  int __pyx_v_printed_tb;
  int __pyx_v_only_while_ready;
  PyObject *__pyx_v_link = NULL;
  PyObject *__pyx_v_glet = NULL;
  PyObject *__pyx_v_parent = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._handle_unswitched_notifications", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_hub);
  __Pyx_XDECREF(__pyx_v_root_greenlets);
  __Pyx_XDECREF(__pyx_v_link);
  __Pyx_XDECREF(__pyx_v_glet);
  __Pyx_XDECREF(__pyx_v_parent);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 416:         # Given a list of callable objects that raised

 417:         # ``greenlet.error`` when we called them: If we can determine

 418:         # that it is a parked greenlet (the callablle is a

 419:         # ``greenlet.switch`` method) and we can determine the hub

 420:         # that the greenlet belongs to (either its parent, or, in the

 421:         # case of a main greenlet, find a hub with the same parent as

 422:         # this greenlet object) then:

 423: 

 424:         # Move this to be a callback in that thread.

 425:         # (This relies on holding the GIL *or* ``Hub.loop.run_callback`` being

 426:         # thread-safe! Note that the CFFI implementations are definitely

 427:         # NOT thread-safe. TODO: Make them? Or an alternative?)

 428:         #

 429:         # Otherwise, print some error messages.

 430: 

 431:         # TODO: Inline this for individual links. That handles the

 432:         # "only while ready" case automatically. Be careful about locking in that case.

 433:         #

 434:         # TODO: Add a 'strict' mode that prevents doing this dance, since it's

 435:         # inherently not safe.

+436:         root_greenlets = None

  __Pyx_INCREF(Py_None);
  __pyx_v_root_greenlets = ((PyObject*)Py_None);

+437:         printed_tb = False

  __pyx_v_printed_tb = 0;

+438:         only_while_ready = not self._notify_all

  __pyx_v_only_while_ready = (!__pyx_v_self->_notify_all);

 439: 

+440:         while unswitched:

  while (1) {
    if (__pyx_v_unswitched == Py_None) __pyx_t_1 = 0;
    else
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_unswitched);
      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 440, __pyx_L1_error)
      __pyx_t_1 = (__pyx_temp != 0);
    }

    if (!__pyx_t_1) break;

+441:             if only_while_ready and not self.ready():

    if (__pyx_v_only_while_ready) {
    } else {
      __pyx_t_1 = __pyx_v_only_while_ready;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->ready(__pyx_v_self, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 441, __pyx_L1_error)
    __pyx_t_3 = (!__pyx_t_2);
    __pyx_t_1 = __pyx_t_3;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+442:                 self.__print_unswitched_warning(unswitched, printed_tb)

      __pyx_t_4 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_AbstractLinkable__print_unswitched_warning(__pyx_v_self, __pyx_v_unswitched, __pyx_v_printed_tb); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 442, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+443:                 break

      goto __pyx_L4_break;

 444: 

+445:             link = unswitched.pop(0)

    if (unlikely(__pyx_v_unswitched == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
      __PYX_ERR(0, 445, __pyx_L1_error)
    }
    __pyx_t_4 = __Pyx_PyList_PopIndex(__pyx_v_unswitched, __pyx_mstate_global->__pyx_int_0, 0, 1, Py_ssize_t, PyLong_FromSsize_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 445, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_link, __pyx_t_4);
    __pyx_t_4 = 0;

 446: 

+447:             hub = None # Also serves as a "handled?" flag

    __Pyx_INCREF(Py_None);
    __Pyx_XDECREF_SET(__pyx_v_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)Py_None));

 448:             # Is it a greenlet.switch method?

+449:             if (getattr(link, '__name__', None) == 'switch'

    __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_link, __pyx_mstate_global->__pyx_n_u_name, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_switch, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_3) {
    } else {
      __pyx_t_1 = __pyx_t_3;
      goto __pyx_L9_bool_binop_done;
    }
/* … */
    if (__pyx_t_1) {
/* … */
    }

+450:                 and isinstance(getattr(link, '__self__', None), greenlet)):

    __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_link, __pyx_mstate_global->__pyx_n_u_self_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 450, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_TypeCheck(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_greenlet); 
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_1 = __pyx_t_3;
    __pyx_L9_bool_binop_done:;

+451:                 glet = link.__self__

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_link, __pyx_mstate_global->__pyx_n_u_self_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 451, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_glet, __pyx_t_4);
      __pyx_t_4 = 0;

+452:                 parent = glet.parent

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_glet, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 452, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_parent, __pyx_t_4);
      __pyx_t_4 = 0;

 453: 

+454:                 while parent is not None:

      while (1) {
        __pyx_t_1 = (__pyx_v_parent != Py_None);
        if (!__pyx_t_1) break;

+455:                     if hasattr(parent, 'loop'): # Assuming the hub.

        __pyx_t_1 = __Pyx_HasAttr(__pyx_v_parent, __pyx_mstate_global->__pyx_n_u_loop); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 455, __pyx_L1_error)
        if (__pyx_t_1) {
/* … */
        }

+456:                         hub = glet.parent

          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_glet, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop))))) __PYX_ERR(0, 456, __pyx_L1_error)
          __Pyx_DECREF_SET(__pyx_v_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_4));
          __pyx_t_4 = 0;

+457:                         break

          goto __pyx_L12_break;

+458:                     parent = glet.parent

        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_glet, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 458, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF_SET(__pyx_v_parent, __pyx_t_4);
        __pyx_t_4 = 0;
      }
      __pyx_L12_break:;

 459: 

+460:                 if hub is None:

      __pyx_t_1 = (((PyObject *)__pyx_v_hub) == Py_None);
      if (__pyx_t_1) {
/* … */
      }

+461:                     if root_greenlets is None:

        __pyx_t_1 = (__pyx_v_root_greenlets == ((PyObject*)Py_None));
        if (__pyx_t_1) {
/* … */
        }

+462:                         root_greenlets = get_roots_and_hubs()

          __pyx_t_4 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_get_roots_and_hubs(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 462, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF_SET(__pyx_v_root_greenlets, ((PyObject*)__pyx_t_4));
          __pyx_t_4 = 0;

+463:                     hub = root_greenlets.get(glet)

        if (unlikely(__pyx_v_root_greenlets == Py_None)) {
          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get");
          __PYX_ERR(0, 463, __pyx_L1_error)
        }
        __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_root_greenlets, __pyx_v_glet, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 463, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop))))) __PYX_ERR(0, 463, __pyx_L1_error)
        __Pyx_DECREF_SET(__pyx_v_hub, ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)__pyx_t_4));
        __pyx_t_4 = 0;

 464: 

+465:                 if hub is not None and hub.loop is not None:

      __pyx_t_3 = (((PyObject *)__pyx_v_hub) != Py_None);
      if (__pyx_t_3) {
      } else {
        __pyx_t_1 = __pyx_t_3;
        goto __pyx_L17_bool_binop_done;
      }
      __pyx_t_3 = (__pyx_v_hub->loop != Py_None);
      __pyx_t_1 = __pyx_t_3;
      __pyx_L17_bool_binop_done:;
      if (__pyx_t_1) {
/* … */
      }

+466:                     hub.loop.run_callback_threadsafe(link, self)

        __pyx_t_5 = __pyx_v_hub->loop;
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_link, ((PyObject *)__pyx_v_self)};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_run_callback_threadsafe, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 466, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+467:             if hub is None or hub.loop is None:

    __pyx_t_3 = (((PyObject *)__pyx_v_hub) == Py_None);
    if (!__pyx_t_3) {
    } else {
      __pyx_t_1 = __pyx_t_3;
      goto __pyx_L20_bool_binop_done;
    }
    __pyx_t_3 = (__pyx_v_hub->loop == Py_None);
    __pyx_t_1 = __pyx_t_3;
    __pyx_L20_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }
  }
  __pyx_L4_break:;

 468:                 # We couldn't handle it

+469:                 self.__print_unswitched_warning(link, printed_tb)

      __pyx_t_4 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_AbstractLinkable__print_unswitched_warning(__pyx_v_self, __pyx_v_link, __pyx_v_printed_tb); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 469, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+470:                 printed_tb = True

      __pyx_v_printed_tb = 1;

 471: 

 472: 

+473:     def __print_unswitched_warning(self, link, printed_tb):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__AbstractLinkable__print_unswitched_warning(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_link, int __pyx_v_printed_tb) {
  PyObject *__pyx_v_traceback = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._AbstractLinkable__print_unswitched_warning", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_traceback);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+474:         print('gevent: error: Unable to switch to greenlet', link,

  __pyx_t_2 = NULL;

 475:               'from', self, '; crossing thread boundaries is not allowed.',

+476:               file=sys.stderr)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_stderr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[6 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_gevent_error_Unable_to_switch_to, __pyx_v_link, __pyx_mstate_global->__pyx_n_u_from, ((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_kp_u_crossing_thread_boundaries_is_n};
    __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_file, __pyx_t_4, __pyx_t_3, __pyx_callargs+6, 0) < (0)) __PYX_ERR(0, 474, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_builtin_print, __pyx_callargs+__pyx_t_5, (6-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 474, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 477: 

+478:         if not printed_tb:

  __pyx_t_6 = (!__pyx_v_printed_tb);
  if (__pyx_t_6) {
/* … */
  }

+479:             printed_tb = True

    __pyx_v_printed_tb = 1;

+480:             print(

    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 480, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_gevent_error_This_is_a_result_of, __pyx_mstate_global->__pyx_kp_u_and_is_a_bug_in_the_calling_code); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 480, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);

 481:                 'gevent: error: '

 482:                 'This is a result of using gevent objects from multiple threads,',

+483:                 'and is a bug in the calling code.', file=sys.stderr)

    __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 483, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_stderr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 483, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_file, __pyx_t_4) < (0)) __PYX_ERR(0, 483, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 484: 

+485:             import traceback

    __pyx_t_7 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_traceback, 0, 0, NULL, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 485, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_7;
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_traceback = __pyx_t_4;
    __pyx_t_4 = 0;

+486:             traceback.print_stack()

    __pyx_t_1 = __pyx_v_traceback;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_print_stack, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 486, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 487: 

+488:     def _quiet_unlink_all(self, obj):

static void __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__quiet_unlink_all(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_obj) {
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._quiet_unlink_all", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

+489:         if obj is None:

  __pyx_t_1 = (__pyx_v_obj == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+490:             return

    goto __pyx_L0;

 491: 

+492:         self.unlink(obj)

  __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->unlink(__pyx_v_self, __pyx_v_obj, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 492, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+493:         if self._notifier is not None and self._notifier.args:

  __pyx_t_3 = (__pyx_v_self->_notifier != Py_None);
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_notifier, __pyx_mstate_global->__pyx_n_u_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 493, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 493, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = __pyx_t_3;
  __pyx_L5_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+494:             try:

    {
      /*try:*/ {
/* … */
      }
      __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;
      goto __pyx_L12_try_end;
      __pyx_L7_error:;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
      __pyx_L9_except_error:;
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      goto __pyx_L1_error;
      __pyx_L8_exception_handled:;
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      __pyx_L12_try_end:;
    }

+495:                 self._notifier.args[0].remove(obj)

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_notifier, __pyx_mstate_global->__pyx_n_u_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 495, __pyx_L7_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 495, __pyx_L7_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_7 = __pyx_t_9;
        __Pyx_INCREF(__pyx_t_7);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_obj};
          __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_remove, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 495, __pyx_L7_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+496:             except ValueError:

      __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ValueError))));
      if (__pyx_t_11) {
        __Pyx_ErrRestore(0,0,0);
        goto __pyx_L8_exception_handled;
      }
      goto __pyx_L9_except_error;

 497:                 pass

 498: 

+499:     def __wait_to_be_notified(self, rawlink): # pylint:disable=too-many-branches

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__AbstractLinkable__wait_to_be_notified(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_v_rawlink) {
  PyObject *__pyx_v_resume_this_greenlet = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* 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("gevent._gevent_c_abstract_linkable.AbstractLinkable._AbstractLinkable__wait_to_be_notified", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_resume_this_greenlet);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+500:         resume_this_greenlet = getcurrent().switch # pylint:disable=undefined-variable

  __pyx_t_1 = ((PyObject *)__pyx_f_6gevent_27_gevent_c_abstract_linkable_getcurrent()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 500, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_switch); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 500, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_resume_this_greenlet = __pyx_t_2;
  __pyx_t_2 = 0;

+501:         if rawlink:

  if (__pyx_v_rawlink) {
/* … */
    goto __pyx_L3;
  }

+502:             self.rawlink(resume_this_greenlet)

    __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->rawlink(__pyx_v_self, __pyx_v_resume_this_greenlet, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 502, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 503:         else:

+504:             self._notifier.args[0].append(resume_this_greenlet)

  /*else*/ {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_notifier, __pyx_mstate_global->__pyx_n_u_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 504, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_3 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_resume_this_greenlet); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 504, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }
  __pyx_L3:;

 505: 

+506:         try:

  /*try:*/ {

+507:             self._switch_to_hub(self.hub)

    __pyx_t_1 = ((PyObject *)__pyx_v_self->hub);
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_4 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_switch_to_hub(__pyx_v_self, __pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 507, __pyx_L5_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 508:             # If we got here, we were automatically unlinked already.

+509:             resume_this_greenlet = None

    __Pyx_INCREF(Py_None);
    __Pyx_DECREF_SET(__pyx_v_resume_this_greenlet, Py_None);
  }

 510:         finally:

+511:             self._quiet_unlink_all(resume_this_greenlet)

  /*finally:*/ {
    /*normal exit:*/{
      ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_quiet_unlink_all(__pyx_v_self, __pyx_v_resume_this_greenlet); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error)
      goto __pyx_L6;
    }
    __pyx_L5_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
      if ( unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __Pyx_XGOTREF(__pyx_t_11);
      __Pyx_XGOTREF(__pyx_t_12);
      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
      {
        ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_quiet_unlink_all(__pyx_v_self, __pyx_v_resume_this_greenlet); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L8_error)
      }
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
      goto __pyx_L1_error;
      __pyx_L8_error:;
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L6:;
  }

 512: 

+513:     def _switch_to_hub(self, the_hub):

static int __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__switch_to_hub(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_the_hub) {
  PyObject *__pyx_v_result = NULL;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._switch_to_hub", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_result);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+514:         self._drop_lock_for_switch_out()

  __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_drop_lock_for_switch_out(__pyx_v_self, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 514, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+515:         try:

  /*try:*/ {

+516:             result = the_hub.switch()

    __pyx_t_2 = __pyx_v_the_hub;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_switch, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 516, __pyx_L4_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_result = __pyx_t_1;
    __pyx_t_1 = 0;
  }

 517:         finally:

+518:             self._acquire_lock_for_switch_in()

  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_acquire_lock_for_switch_in(__pyx_v_self, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
      if ( unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __Pyx_XGOTREF(__pyx_t_11);
      __Pyx_XGOTREF(__pyx_t_12);
      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
      {
        __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_acquire_lock_for_switch_in(__pyx_v_self, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L7_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      }
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

+519:         if result is not self: # pragma: no cover

  __pyx_t_13 = (__pyx_v_result != ((PyObject *)__pyx_v_self));
  if (unlikely(__pyx_t_13)) {
/* … */
  }

+520:             raise InvalidSwitchError(

    __pyx_t_2 = NULL;
    __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidSwitchError);
    __pyx_t_14 = __pyx_v_6gevent_27_gevent_c_abstract_linkable_InvalidSwitchError; 

+521:                 'Invalid switch into %s.wait(): %r' % (

    __pyx_t_18 = __Pyx_PyUnicode_Join(__pyx_t_17, 4, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16));
    if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 521, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __pyx_t_3 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_14))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_14);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
      __pyx_t_3 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_18};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_14, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 520, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 520, __pyx_L1_error)

+522:                     self.__class__.__name__,

    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_16), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;

+523:                     result,

    __pyx_t_16 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_result), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_17[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_switch_into;
    __pyx_t_17[1] = __pyx_t_15;
    __pyx_t_17[2] = __pyx_mstate_global->__pyx_kp_u_wait;
    __pyx_t_17[3] = __pyx_t_16;

 524:                 )

 525:             )

 526: 

+527:     def _acquire_lock_for_switch_in(self):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__acquire_lock_for_switch_in(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_acquire_lock_for_switch_in); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 527, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* 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("gevent._gevent_c_abstract_linkable.AbstractLinkable._acquire_lock_for_switch_in", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_12_acquire_lock_for_switch_in, "AbstractLinkable._acquire_lock_for_switch_in(self)");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in = {"_acquire_lock_for_switch_in", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_12_acquire_lock_for_switch_in};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_acquire_lock_for_switch_in (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_12_acquire_lock_for_switch_in(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_12_acquire_lock_for_switch_in(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__acquire_lock_for_switch_in(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._acquire_lock_for_switch_in", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_13_acquire_lock_for_switch_in, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable__acquire_lock_f, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 527, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_acquire_lock_for_switch_in, __pyx_t_2) < (0)) __PYX_ERR(0, 527, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+528:         return

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

 529: 

+530:     def _drop_lock_for_switch_out(self):

static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__drop_lock_for_switch_out(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (
  #if !CYTHON_USE_TYPE_SLOTS
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable &&
  __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC))
  #else
  unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))
  #endif
  ) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_drop_lock_for_switch_out); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 530, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = NULL;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; 
        __pyx_t_5 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_5 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
          __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 530, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* 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("gevent._gevent_c_abstract_linkable.AbstractLinkable._drop_lock_for_switch_out", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_14_drop_lock_for_switch_out, "AbstractLinkable._drop_lock_for_switch_out(self)");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out = {"_drop_lock_for_switch_out", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_14_drop_lock_for_switch_out};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_drop_lock_for_switch_out (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_14_drop_lock_for_switch_out(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_14_drop_lock_for_switch_out(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__drop_lock_for_switch_out(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 530, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._drop_lock_for_switch_out", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_15_drop_lock_for_switch_out, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable__drop_lock_for, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 530, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_drop_lock_for_switch_out, __pyx_t_2) < (0)) __PYX_ERR(0, 530, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+531:         return

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

 532: 

+533:     def _wait_core(self, timeout, catch=Timeout):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait_core(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, PyObject *__pyx_v_timeout, struct __pyx_opt_args_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait_core *__pyx_optional_args) {
  PyObject *__pyx_v_catch = __pyx_mstate_global->__pyx_k__2;
  PyObject *__pyx_v_timer = NULL;
  PyObject *__pyx_v_ex = NULL;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_catch = __pyx_optional_args->__pyx_catch;
    }
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._wait_core", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_timer);
  __Pyx_XDECREF(__pyx_v_ex);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __Pyx_INCREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout);
  __pyx_mstate_global->__pyx_k__2 = __pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout;
  __Pyx_GIVEREF(__pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout);

 534:         """

 535:         The core of the wait implementation, handling switching and

 536:         linking.

 537: 

 538:         This method is NOT safe to call from multiple threads.

 539: 

 540:         ``self.hub`` must be initialized before entering this method.

 541:         The hub that is set is considered the owner and cannot be changed

 542:         while this method is running. It must only be called from the thread

 543:         where ``self.hub`` is the current hub.

 544: 

 545:         If *catch* is set to ``()``, a timeout that elapses will be

 546:         allowed to be raised.

 547: 

 548:         :return: A true value if the wait succeeded without timing out.

 549:           That is, a true return value means we were notified and control

 550:           resumed in this greenlet.

 551:         """

+552:         with Timeout._start_new_or_dummy(timeout) as timer: # Might release

  /*with:*/ {
    __pyx_t_2 = __pyx_v_6gevent_27_gevent_c_abstract_linkable_Timeout;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_timeout};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_start_new_or_dummy, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 552, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 552, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 552, __pyx_L3_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_3 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 552, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_6 = __pyx_t_2;
    __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          __pyx_v_timer = __pyx_t_6;
          __pyx_t_6 = 0;
/* … */
        }
        __pyx_L7_error:;
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        /*except:*/ {
          __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._wait_core", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_6) < 0) __PYX_ERR(0, 552, __pyx_L9_except_error)
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_1);
          __Pyx_XGOTREF(__pyx_t_6);
          __pyx_t_5 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 552, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 552, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_12);
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          if (__pyx_t_14 < (0)) __PYX_ERR(0, 552, __pyx_L9_except_error)
          __pyx_t_23 = (!__pyx_t_14);
          if (unlikely(__pyx_t_23)) {
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_1);
            __Pyx_XGIVEREF(__pyx_t_6);
            __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_1, __pyx_t_6);
            __pyx_t_2 = 0;  __pyx_t_1 = 0;  __pyx_t_6 = 0; 
            __PYX_ERR(0, 552, __pyx_L9_except_error)
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          goto __pyx_L8_exception_handled;
        }
        __pyx_L9_except_error:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
        goto __pyx_L1_error;
        __pyx_L11_try_return:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
        goto __pyx_L4_return;
        __pyx_L8_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_4) {
          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[1], NULL);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 552, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        goto __pyx_L6;
      }
      __pyx_L4_return: {
        __pyx_t_9 = __pyx_r;
        __pyx_r = 0;
        if (__pyx_t_4) {
          __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[1], NULL);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        }
        __pyx_r = __pyx_t_9;
        __pyx_t_9 = 0;
        goto __pyx_L0;
      }
      __pyx_L6:;
    }
    goto __pyx_L34;
    __pyx_L3_error:;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L1_error;
    __pyx_L34:;
  }
/* … */
  __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 552, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]);

 553:             # We already checked above (_wait()) if we're ready()

+554:             try:

          {
            /*try:*/ {
/* … */
            }
            __pyx_L13_error:;
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* … */
            __pyx_L15_except_error:;
            __Pyx_XGIVEREF(__pyx_t_10);
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
            goto __pyx_L7_error;
            __pyx_L17_try_return:;
            __Pyx_XGIVEREF(__pyx_t_10);
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
            goto __pyx_L11_try_return;
            __pyx_L16_except_return:;
            __Pyx_XGIVEREF(__pyx_t_10);
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
            goto __pyx_L11_try_return;
          }

+555:                 self.__wait_to_be_notified(

              __pyx_t_6 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_AbstractLinkable__wait_to_be_notified(__pyx_v_self, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 555, __pyx_L13_error)
              __Pyx_GOTREF(__pyx_t_6);
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 556:                     True,# Use rawlink()

 557:                 )

+558:                 return True

              __Pyx_XDECREF(__pyx_r);
              __Pyx_INCREF(Py_True);
              __pyx_r = Py_True;
              goto __pyx_L17_try_return;

+559:             except catch as ex:

            __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_v_catch);
            if (__pyx_t_13) {
              __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._wait_core", __pyx_clineno, __pyx_lineno, __pyx_filename);
              if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 559, __pyx_L15_except_error)
              __Pyx_XGOTREF(__pyx_t_6);
              __Pyx_XGOTREF(__pyx_t_1);
              __Pyx_XGOTREF(__pyx_t_2);
              __Pyx_INCREF(__pyx_t_1);
              __pyx_v_ex = __pyx_t_1;
              /*try:*/ {
/* … */
              /*finally:*/ {
                __pyx_L24_error:;
                /*exception exit:*/{
                  __Pyx_PyThreadState_declare
                  __Pyx_PyThreadState_assign
                  __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                   __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
                  if ( unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
                  __Pyx_XGOTREF(__pyx_t_17);
                  __Pyx_XGOTREF(__pyx_t_18);
                  __Pyx_XGOTREF(__pyx_t_19);
                  __Pyx_XGOTREF(__pyx_t_20);
                  __Pyx_XGOTREF(__pyx_t_21);
                  __Pyx_XGOTREF(__pyx_t_22);
                  __pyx_t_13 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
                  {
                    __Pyx_DECREF(__pyx_v_ex); __pyx_v_ex = 0;
                  }
                  __Pyx_XGIVEREF(__pyx_t_20);
                  __Pyx_XGIVEREF(__pyx_t_21);
                  __Pyx_XGIVEREF(__pyx_t_22);
                  __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
                  __Pyx_XGIVEREF(__pyx_t_17);
                  __Pyx_XGIVEREF(__pyx_t_18);
                  __Pyx_XGIVEREF(__pyx_t_19);
                  __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
                  __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
                  __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
                  goto __pyx_L15_except_error;
                }
                __pyx_L23_return: {
                  __pyx_t_22 = __pyx_r;
                  __pyx_r = 0;
                  __Pyx_DECREF(__pyx_v_ex); __pyx_v_ex = 0;
                  __pyx_r = __pyx_t_22;
                  __pyx_t_22 = 0;
                  goto __pyx_L16_except_return;
                }
              }
            }
            goto __pyx_L15_except_error;

+560:                 if ex is not timer:

                __pyx_t_14 = (__pyx_v_ex != ((PyObject*)__pyx_v_timer));
                if (unlikely(__pyx_t_14)) {
/* … */
                }

+561:                     raise

                  __Pyx_GIVEREF(__pyx_t_6);
                  __Pyx_GIVEREF(__pyx_t_1);
                  __Pyx_XGIVEREF(__pyx_t_2);
                  __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_1, __pyx_t_2);
                  __pyx_t_6 = 0;  __pyx_t_1 = 0;  __pyx_t_2 = 0; 
                  __PYX_ERR(0, 561, __pyx_L24_error)

 562:                 # test_set_and_clear and test_timeout in test_threading

 563:                 # rely on the exact return values, not just truthish-ness

+564:                 return False

                __Pyx_XDECREF(__pyx_r);
                __Pyx_INCREF(Py_False);
                __pyx_r = Py_False;
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                goto __pyx_L23_return;
              }

 565: 

+566:     def _wait_return_value(self, waited, wait_success):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait_return_value(CYTHON_UNUSED struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, CYTHON_UNUSED int __pyx_v_waited, CYTHON_UNUSED int __pyx_v_wait_success) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 567:         # pylint:disable=unused-argument

 568:         # Subclasses should override this to return a value from _wait.

 569:         # By default we return None.

+570:         return None # pragma: no cover all extent subclasses override

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

 571: 

+572:     def _wait(self, timeout=None):

static PyObject *__pyx_f_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self, struct __pyx_opt_args_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable__wait *__pyx_optional_args) {
  PyObject *__pyx_v_timeout = ((PyObject *)Py_None);
  PyObject *__pyx_v_result = NULL;
  PyObject *__pyx_v_gotit = NULL;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_timeout = __pyx_optional_args->timeout;
    }
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("gevent._gevent_c_abstract_linkable.AbstractLinkable._wait", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_result);
  __Pyx_XDECREF(__pyx_v_gotit);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 573:         # Watch where we could potentially release the GIL.

+574:         self._capture_hub(True) # Must create, we must have an owner. Might release

  __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_capture_hub(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 575: 

+576:         if self.ready(): # *might* release, if overridden in Python.

  __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->ready(__pyx_v_self, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 576, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
  }

+577:             result = self._wait_return_value(False, False) # pylint:disable=assignment-from-none

    __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_wait_return_value(__pyx_v_self, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 577, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_result = __pyx_t_1;
    __pyx_t_1 = 0;

+578:             if self._notifier:

    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->_notifier); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 578, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
    }

 579:                 # We're already notifying waiters; one of them must have run

 580:                 # and switched to this greenlet, which arrived here. Alternately,

 581:                 # we could be in a separate thread (but we're holding the GIL/object lock)

+582:                 self.__wait_to_be_notified(False) # Use self._notifier.args[0] instead of self.rawlink

      __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_AbstractLinkable__wait_to_be_notified(__pyx_v_self, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 583: 

+584:             return result

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

 585: 

+586:         gotit = self._wait_core(timeout)

  __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_wait_core(__pyx_v_self, __pyx_v_timeout, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_gotit = __pyx_t_1;
  __pyx_t_1 = 0;

+587:         return self._wait_return_value(True, gotit)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_gotit); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 587, __pyx_L1_error)
  __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self->__pyx_vtab)->_wait_return_value(__pyx_v_self, 1, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 587, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 588: 

+589:     def _at_fork_reinit(self):

/* Python wrapper */
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_17_at_fork_reinit(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_16_at_fork_reinit, "AbstractLinkable._at_fork_reinit(self)\n\nThis method was added in Python 3.9 and is called by logging.py\n``_after_at_fork_child_reinit_locks`` on Lock objects.\n\nIt is also called from threading.py, ``_after_fork`` in\n``_reset_internal_locks``, and that can hit ``Event`` objects.\n\nSubclasses should reset themselves to an initial state. This\nincludes unlocking/releasing, if possible. This method detaches from the\nprevious hub and drops any existing notifier.");
static PyMethodDef __pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_17_at_fork_reinit = {"_at_fork_reinit", (PyCFunction)__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_17_at_fork_reinit, METH_NOARGS, __pyx_doc_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_16_at_fork_reinit};
static PyObject *__pyx_pw_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_17_at_fork_reinit(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_at_fork_reinit (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_16_at_fork_reinit(((struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *)__pyx_v_self));

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

static PyObject *__pyx_pf_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_16_at_fork_reinit(struct __pyx_obj_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6gevent_27_gevent_c_abstract_linkable_16AbstractLinkable_17_at_fork_reinit, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_AbstractLinkable__at_fork_reinit, NULL, __pyx_mstate_global->__pyx_n_u_gevent__gevent_c_abstract_linkab, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_6gevent_27_gevent_c_abstract_linkable_AbstractLinkable, __pyx_mstate_global->__pyx_n_u_at_fork_reinit, __pyx_t_2) < (0)) __PYX_ERR(0, 589, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 590:         """

 591:         This method was added in Python 3.9 and is called by logging.py

 592:         ``_after_at_fork_child_reinit_locks`` on Lock objects.

 593: 

 594:         It is also called from threading.py, ``_after_fork`` in

 595:         ``_reset_internal_locks``, and that can hit ``Event`` objects.

 596: 

 597:         Subclasses should reset themselves to an initial state. This

 598:         includes unlocking/releasing, if possible. This method detaches from the

 599:         previous hub and drops any existing notifier.

 600:         """

+601:         self.hub = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->hub);
  __Pyx_DECREF((PyObject *)__pyx_v_self->hub);
  __pyx_v_self->hub = ((struct __pyx_obj_6gevent_29_gevent_c_greenlet_primitives_SwitchOutGreenletWithLoop *)Py_None);

+602:         self._notifier = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->_notifier);
  __Pyx_DECREF(__pyx_v_self->_notifier);
  __pyx_v_self->_notifier = Py_None;

 603: 

+604: def _init():

static void __pyx_f_6gevent_27_gevent_c_abstract_linkable__init(void) {

+605:     greenlet_init() # pylint:disable=undefined-variable

  __pyx_f_6gevent_27_gevent_c_abstract_linkable_greenlet_init(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 605, __pyx_L1_error)

 606: 

+607: _init()

  __pyx_f_6gevent_27_gevent_c_abstract_linkable__init(); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L1_error)

 608: 

 609: 

+610: from gevent._util import import_c_accel

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_import_c_accel};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_gevent__util, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 610, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_import_c_accel};
    __pyx_t_3 = 0; {
      __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 610, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_6) < (0)) __PYX_ERR(0, 610, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+611: import_c_accel(globals(), 'gevent.__abstract_linkable')

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_import_c_accel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_Globals(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_7, __pyx_mstate_global->__pyx_kp_u_gevent___abstract_linkable};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 611, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;