Glib::ThreadPool::SlotList::SlotList() (struct SlotList * const this)
{
  struct Mutex * D.60013;
  struct list * D.60014;

  D.60013 = &this->mutex_;
  Glib::Threads::Mutex::Mutex (D.60013);
  try
    {
      D.60014 = &this->list_;
      std::list<sigc::slot<void> >::list (D.60014);
      try
        {

        }
      catch
        {
          D.60014 = &this->list_;
          std::list<sigc::slot<void> >::~list (D.60014);
        }
    }
  catch
    {
      D.60013 = &this->mutex_;
      Glib::Threads::Mutex::~Mutex (D.60013);
    }
}


std::list<_Tp, _Alloc>::list() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct list * const this)
{
  struct _List_base * D.60017;

  D.60017 = &this->D.58920;
  std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_List_base (D.60017);
  try
    {

    }
  catch
    {
      D.60017 = &this->D.58920;
      std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::~_List_base (D.60017);
    }
}


std::_List_base<_Tp, _Alloc>::_List_base() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this)
{
  struct _List_impl * D.60018;

  D.60018 = &this->_M_impl;
  std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_List_impl::_List_impl (D.60018);
  try
    {
      std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_init (this);
    }
  catch
    {
      D.60018 = &this->_M_impl;
      std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_List_impl::~_List_impl (D.60018);
    }
}


std::_List_base<_Tp, _Alloc>::_List_impl::_List_impl() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_impl * const this)
{
  std::allocator<std::_List_node<sigc::slot<void> > >::allocator (this);
  try
    {
      this->_M_node._M_next = 0B;
      this->_M_node._M_prev = 0B;
    }
  catch
    {
      std::allocator<std::_List_node<sigc::slot<void> > >::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = std::_List_node<sigc::slot<void> >] (struct allocator * const this)
{
  void * D.60019;

  try
    {
      {
        __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60019 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60019);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::_List_node<sigc::slot<void> >] (struct new_allocator * const this)
{
  void * D.60020;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60020 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60020);
          
        }
    }
}


void std::_List_base<_Tp, _Alloc>::_M_init() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this)
{
  struct _List_node_base * D.60021;

  D.60021 = &this->_M_impl._M_node;
  this->_M_impl._M_node._M_next = D.60021;
  D.60021 = &this->_M_impl._M_node;
  this->_M_impl._M_node._M_prev = D.60021;
}


Glib::ThreadPool::SlotList::~SlotList() (struct SlotList * const this)
{
  struct list * D.60022;
  struct Mutex * D.60023;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.60022 = &this->list_;
                std::list<sigc::slot<void> >::~list (D.60022);
              }
          }
        finally
          {
            D.60023 = &this->mutex_;
            Glib::Threads::Mutex::~Mutex (D.60023);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.58975>:
}


std::list<sigc::slot<void> >::~list() (struct list * const this)
{
  struct _List_base * D.60026;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.60026 = &this->D.58920;
            std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::~_List_base (D.60026);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.58963>:
}


std::_List_base<_Tp, _Alloc>::~_List_base() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this)
{
  struct _List_impl * D.60028;

  {
    try
      {
        try
          {
            std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_clear (this);
          }
        finally
          {
            D.60028 = &this->_M_impl;
            std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_List_impl::~_List_impl (D.60028);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59535>:
}


void std::_List_base<_Tp, _Alloc>::_M_clear() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this)
{
  struct slot * D.60031;
  struct slot * D.60032;
  struct _Tp_alloc_type D.59678;
  struct _List_node_base * D.60033;
  typedef struct _Node _Node;
  struct _Node * __cur;

  __cur = this->_M_impl._M_node._M_next;
  goto <D.59682>;
  <D.59683>:
  {
    struct _Node * __tmp;

    __tmp = __cur;
    __cur = __cur->D.59554._M_next;
    D.60031 = &__tmp->_M_data;
    D.60032 = std::__addressof<sigc::slot<void> > (D.60031);
    D.59678 = std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::slot<void> >::destroy (&D.59678, D.60032);
      }
    finally
      {
        std::allocator<sigc::slot<void> >::~allocator (&D.59678);
        D.59678 = {CLOBBER};
      }
    std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_put_node (this, __tmp);
  }
  <D.59682>:
  D.60033 = &this->_M_impl._M_node;
  if (D.60033 != __cur) goto <D.59683>; else goto <D.59681>;
  <D.59681>:
}


_Tp* std::__addressof(_Tp&) [with _Tp = sigc::slot<void>] (struct slot & __r)
{
  struct slot * D.60035;

  D.60035 = __r;
  return D.60035;
}


std::_List_base<_Tp, _Alloc>::_Tp_alloc_type std::_List_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::_List_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<sigc::slot<void> >] (const struct _List_base * const this)
{
  const struct _Node_alloc_type & D.60038;

  D.60038 = std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_get_Node_allocator (this);
  std::allocator<sigc::slot<void> >::allocator<std::_List_node<sigc::slot<void> > > (<retval>, D.60038);
  return <retval>;
}


const _Node_alloc_type& std::_List_base<_Tp, _Alloc>::_M_get_Node_allocator() const [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::_List_base<_Tp, _Alloc>::_Node_alloc_type = std::allocator<std::_List_node<sigc::slot<void> > >] (const struct _List_base * const this)
{
  const struct _Node_alloc_type & D.60040;

  D.60040 = &this->_M_impl;
  return D.60040;
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator<_Tp1>&) [with _Tp1 = std::_List_node<sigc::slot<void> >; _Tp = sigc::slot<void>] (struct allocator * const this, const struct allocator & D.59853)
{
  void * D.60042;

  try
    {
      {
        __gnu_cxx::new_allocator<sigc::slot<void> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<sigc::slot<void> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60042 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60042);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = sigc::slot<void>] (struct new_allocator * const this)
{
  void * D.60043;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60043 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60043);
          
        }
    }
}


void __gnu_cxx::new_allocator<_Tp>::destroy(__gnu_cxx::new_allocator<_Tp>::pointer) [with _Tp = sigc::slot<void>; __gnu_cxx::new_allocator<_Tp>::pointer = sigc::slot<void>*] (struct new_allocator * const this, struct slot * __p)
{
  sigc::slot<void>::~slot (__p);
}


sigc::slot<void>::~slot() (struct slot * const this)
{
  struct slot0 * D.60044;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.60044 = &this->D.59073;
            sigc::slot0<void>::~slot0 (D.60044);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59109>:
}


sigc::slot0<void>::~slot0() (struct slot0 * const this)
{
  struct slot_base * D.60046;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.60046 = &this->D.59031;
            sigc::slot_base::~slot_base (D.60046);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59104>:
}


void std::_List_base<_Tp, _Alloc>::_M_put_node(std::_List_node<_Tp>*) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this, struct _List_node * __p)
{
  struct _List_impl * D.60048;

  D.60048 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::deallocate (D.60048, __p, 1);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = std::_List_node<sigc::slot<void> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot<void> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _List_node * __p, size_type D.58417)
{
  operator delete (__p);
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = sigc::slot<void>] (struct allocator * const this)
{
  void * D.60049;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<sigc::slot<void> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.59868>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60049 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60049);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = sigc::slot<void>] (struct new_allocator * const this)
{
  void * D.60050;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.59974>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60050 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60050);
          
        }
    }
}


std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_List_impl::~_List_impl() (struct _List_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<std::_List_node<sigc::slot<void> > >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59530>:
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = std::_List_node<sigc::slot<void> >] (struct allocator * const this)
{
  void * D.60051;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.59671>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60051 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60051);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::_List_node<sigc::slot<void> >] (struct new_allocator * const this)
{
  void * D.60052;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.59841>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60052 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60052);
          
        }
    }
}


sigc::slot<void>* Glib::ThreadPool::SlotList::push(const sigc::slot<void>&) (struct SlotList * const this, const struct slot & slot)
{
  struct Mutex * D.60053;
  struct list * D.60054;
  struct slot * D.60055;
  struct Lock lock;

  try
    {
      D.60053 = &this->mutex_;
      Glib::Threads::Mutex::Lock::Lock (&lock, D.60053);
      try
        {
          D.60054 = &this->list_;
          std::list<sigc::slot<void> >::push_back (D.60054, slot);
          D.60054 = &this->list_;
          D.60055 = std::list<sigc::slot<void> >::back (D.60054);
          return D.60055;
        }
      finally
        {
          Glib::Threads::Mutex::Lock::~Lock (&lock);
        }
    }
  finally
    {
      lock = {CLOBBER};
    }
}


Glib::Threads::Mutex::Lock::Lock(Glib::Threads::Mutex&) (struct Lock * const this, struct Mutex & mutex)
{
  struct Mutex & D.60062;

  this->mutex_ = mutex;
  this->locked_ = 1;
  D.60062 = this->mutex_;
  Glib::Threads::Mutex::lock (D.60062);
}


void std::list<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::value_type = sigc::slot<void>] (struct list * const this, const struct value_type & __x)
{
  struct _List_iterator D.60063;

  D.60063 = std::list<sigc::slot<void> >::end (this);
  std::list<sigc::slot<void> >::_M_insert (this, D.60063, __x);
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::end() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot<void> >] (struct list * const this)
{
  struct iterator D.60064;
  struct iterator D.59549;
  struct _List_node_base * D.60065;

  D.60065 = &this->D.58920._M_impl._M_node;
  std::_List_iterator<sigc::slot<void> >::_List_iterator (&D.59549, D.60065);
  try
    {
      D.60064 = D.59549;
      return D.60064;
    }
  finally
    {
      D.59549 = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_List_iterator(std::__detail::_List_node_base*) [with _Tp = sigc::slot<void>] (struct _List_iterator * const this, struct _List_node_base * __x)
{
  this->_M_node = __x;
}


void std::list<_Tp, _Alloc>::_M_insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot<void> >; std::list<_Tp, _Alloc>::value_type = sigc::slot<void>] (struct list * const this, struct iterator __position, const struct value_type & __x)
{
  struct _List_node_base * D.60068;
  struct _List_node_base * D.60069;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot<void> >::_M_create_node (this, __x);
  D.60068 = __position._M_node;
  D.60069 = &__tmp->D.59554;
  std::__detail::_List_node_base::_M_hook (D.60069, D.60068);
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::slot<void> >; std::list<_Tp, _Alloc>::value_type = sigc::slot<void>] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.60071;
  struct slot * D.60072;
  struct slot * D.60073;
  struct _Tp_alloc_type D.59876;
  void * D.60074;
  struct _Node * D.60075;
  struct _Node * __p;

  D.60071 = &this->D.58920;
  __p = std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_get_node (D.60071);
  try
    {
      D.60072 = &__p->_M_data;
      D.60073 = std::__addressof<sigc::slot<void> > (D.60072);
      D.60071 = &this->D.58920;
      D.59876 = std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_get_Tp_allocator (D.60071); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot<void> >::construct (&D.59876, D.60073, __x);
        }
      finally
        {
          std::allocator<sigc::slot<void> >::~allocator (&D.59876);
          D.59876 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.60074 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.60074);
              D.60071 = &this->D.58920;
              std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_put_node (D.60071, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.60075 = __p;
  return D.60075;
}


std::_List_node<_Tp>* std::_List_base<_Tp, _Alloc>::_M_get_node() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >] (struct _List_base * const this)
{
  struct _List_node * D.60082;
  struct _List_impl * D.60083;

  D.60083 = &this->_M_impl;
  D.60082 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::allocate (D.60083, 1, 0B);
  return D.60082;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::slot<void> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot<void> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.58413)
{
  bool retval.0;
  long unsigned int D.60087;
  struct _List_node * D.60090;
  long unsigned int D.60091;

  D.60087 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot<void> > >::max_size (this);
  retval.0 = D.60087 < __n;
  if (retval.0 != 0) goto <D.60088>; else goto <D.60089>;
  <D.60088>:
  std::__throw_bad_alloc ();
  <D.60089>:
  D.60091 = __n * 32;
  D.60090 = operator new (D.60091);
  return D.60090;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::_List_node<sigc::slot<void> >; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.60094;
  void * D.60095;

  try
    {
      D.60094 = 576460752303423487;
      return D.60094;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60095 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60095);
          
        }
    }
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = sigc::slot<void>; __gnu_cxx::new_allocator<_Tp>::pointer = sigc::slot<void>*] (struct new_allocator * const this, struct slot * __p, const struct slot & __val)
{
  void * D.59980;
  void * D.59981;
  struct slot * iftmp.1;

  D.59980 = __p;
  D.59981 = operator new (16, D.59980);
  if (D.59981 != 0B) goto <D.60098>; else goto <D.60099>;
  <D.60098>:
  try
    {
      sigc::slot<void>::slot (D.59981, __val);
    }
  catch
    {
      operator delete (D.59981, D.59980);
    }
  iftmp.1 = D.59981;
  goto <D.60100>;
  <D.60099>:
  iftmp.1 = D.59981;
  <D.60100>:
}


void* operator new(std::size_t, void*) (size_t D.4916, void * __p)
{
  void * D.60102;
  void * D.60103;

  try
    {
      D.60102 = __p;
      return D.60102;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60103 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60103);
          
        }
    }
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void] (struct slot * const this, const struct slot & src)
{
  struct slot0 * D.60105;

  D.60105 = &this->D.59073;
  sigc::slot0<void>::slot0 (D.60105, src);
  try
    {

    }
  catch
    {
      D.60105 = &this->D.59073;
      sigc::slot0<void>::~slot0 (D.60105);
    }
}


sigc::slot0<T_return>::slot0(const sigc::slot0<T_return>&) [with T_return = void] (struct slot0 * const this, const struct slot0 & src)
{
  const struct slot_base * D.60106;
  struct slot_base * D.60107;

  D.60106 = &src->D.59031;
  D.60107 = &this->D.59031;
  sigc::slot_base::slot_base (D.60107, D.60106);
  try
    {

    }
  catch
    {
      D.60107 = &this->D.59031;
      sigc::slot_base::~slot_base (D.60107);
    }
}


void operator delete(void*, void*) (void * D.4924, void * D.4925)
{
  void * D.60108;

  try
    {

    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.60108 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.60108);
          
        }
    }
}


std::list<_Tp, _Alloc>::reference std::list<_Tp, _Alloc>::back() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::reference = sigc::slot<void>&] (struct list * const this)
{
  struct slot & D.60109;
  struct iterator __tmp;

  try
    {
      __tmp = std::list<sigc::slot<void> >::end (this);
      std::_List_iterator<sigc::slot<void> >::operator-- (&__tmp);
      D.60109 = std::_List_iterator<sigc::slot<void> >::operator* (&__tmp);
      return D.60109;
    }
  finally
    {
      __tmp = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_Self& std::_List_iterator<_Tp>::operator--() [with _Tp = sigc::slot<void>; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot<void> >] (struct _List_iterator * const this)
{
  struct _List_node_base * D.60113;
  struct _List_node_base * D.60114;
  struct _Self & D.60115;

  D.60113 = this->_M_node;
  D.60114 = D.60113->_M_prev;
  this->_M_node = D.60114;
  D.60115 = this;
  return D.60115;
}


_Tp& std::_List_iterator<_Tp>::operator*() const [with _Tp = sigc::slot<void>; std::_List_iterator<_Tp>::reference = sigc::slot<void>&] (const struct _List_iterator * const this)
{
  struct slot & D.60117;
  struct _List_node_base * D.60118;

  D.60118 = this->_M_node;
  D.60117 = &MEM[(struct _Node *)D.60118]._M_data;
  return D.60117;
}


Glib::Threads::Mutex::Lock::~Lock() (struct Lock * const this)
{
  bool D.60120;
  struct Mutex & D.60123;

  {
    try
      {
        D.60120 = this->locked_;
        if (D.60120 != 0) goto <D.60121>; else goto <D.60122>;
        <D.60121>:
        D.60123 = this->mutex_;
        Glib::Threads::Mutex::unlock (D.60123);
        goto <D.60124>;
        <D.60122>:
        <D.60124>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.58012>:
}


sigc::slot<void> Glib::ThreadPool::SlotList::pop(sigc::slot<void>*) (struct SlotList * const this, struct slot * slot_ptr)
{
  struct Mutex * D.60127;
  struct list * D.60128;
  bool retval.2;
  bool iftmp.3;
  struct iterator D.59171;
  bool cleanup.4;
  bool D.60136;
  struct slot & D.60138;
  bool retval.5;
  struct iterator D.59172;
  struct slot & D.60143;
  struct iterator D.59178;
  struct slot slot [value-expr: *<retval>];

  sigc::slot<void>::slot (<retval>);
  try
    {
      {
        struct Lock lock;
        struct iterator pslot;

        try
          {
            D.60127 = &this->mutex_;
            Glib::Threads::Mutex::Lock::Lock (&lock, D.60127);
            try
              {
                D.60128 = &this->list_;
                pslot = std::list<sigc::slot<void> >::begin (D.60128);
                goto <D.59190>;
                <D.59191>:
                std::_List_iterator<sigc::slot<void> >::operator++ (&pslot);
                <D.59190>:
                cleanup.4 = 0;
                try
                  {
                    D.60128 = &this->list_;
                    D.59171 = std::list<sigc::slot<void> >::end (D.60128);
                    cleanup.4 = 1;
                    D.60136 = std::_List_iterator<sigc::slot<void> >::operator!= (&pslot, &D.59171);
                    if (D.60136 != 0) goto <D.60137>; else goto <D.60131>;
                    <D.60137>:
                    D.60138 = std::_List_iterator<sigc::slot<void> >::operator* (&pslot);
                    if (D.60138 != slot_ptr) goto <D.60139>; else goto <D.60131>;
                    <D.60139>:
                    iftmp.3 = 1;
                    goto <D.60132>;
                    <D.60131>:
                    iftmp.3 = 0;
                    <D.60132>:
                    retval.2 = iftmp.3;
                  }
                finally
                  {
                    if (cleanup.4 != 0) goto <D.60134>; else goto <D.60135>;
                    <D.60134>:
                    D.59171 = {CLOBBER};
                    <D.60135>:
                  }
                if (retval.2 != 0) goto <D.59191>; else goto <D.59189>;
                <D.59189>:
                D.60128 = &this->list_;
                D.59172 = std::list<sigc::slot<void> >::end (D.60128);
                try
                  {
                    retval.5 = std::_List_iterator<sigc::slot<void> >::operator!= (&pslot, &D.59172);
                  }
                finally
                  {
                    D.59172 = {CLOBBER};
                  }
                if (retval.5 != 0) goto <D.60141>; else goto <D.60142>;
                <D.60141>:
                D.60143 = std::_List_iterator<sigc::slot<void> >::operator* (&pslot);
                sigc::slot<void>::operator= (<retval>, D.60143);
                D.60128 = &this->list_;
                D.59178 = std::list<sigc::slot<void> >::erase (D.60128, pslot);
                goto <D.60144>;
                <D.60142>:
                <D.60144>:
              }
            finally
              {
                Glib::Threads::Mutex::Lock::~Lock (&lock);
              }
          }
        finally
          {
            lock = {CLOBBER};
            pslot = {CLOBBER};
          }
      }
      return <retval>;
    }
  catch
    {
      sigc::slot<void>::~slot (<retval>);
    }
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot() [with T_return = void] (struct slot * const this)
{
  struct slot0 * D.60152;

  D.60152 = &this->D.59073;
  sigc::slot0<void>::slot0 (D.60152);
  try
    {

    }
  catch
    {
      D.60152 = &this->D.59073;
      sigc::slot0<void>::~slot0 (D.60152);
    }
}


sigc::slot0<T_return>::slot0() [with T_return = void] (struct slot0 * const this)
{
  struct slot_base * D.60153;

  D.60153 = &this->D.59031;
  sigc::slot_base::slot_base (D.60153);
  try
    {

    }
  catch
    {
      D.60153 = &this->D.59031;
      sigc::slot_base::~slot_base (D.60153);
    }
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::begin() [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot<void> >] (struct list * const this)
{
  struct iterator D.60154;
  struct iterator D.59547;
  struct _List_node_base * D.60155;

  D.60155 = this->D.58920._M_impl._M_node._M_next;
  std::_List_iterator<sigc::slot<void> >::_List_iterator (&D.59547, D.60155);
  try
    {
      D.60154 = D.59547;
      return D.60154;
    }
  finally
    {
      D.59547 = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_Self& std::_List_iterator<_Tp>::operator++() [with _Tp = sigc::slot<void>; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot<void> >] (struct _List_iterator * const this)
{
  struct _List_node_base * D.60158;
  struct _List_node_base * D.60159;
  struct _Self & D.60160;

  D.60158 = this->_M_node;
  D.60159 = D.60158->_M_next;
  this->_M_node = D.60159;
  D.60160 = this;
  return D.60160;
}


bool std::_List_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = sigc::slot<void>; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot<void> >] (const struct _List_iterator * const this, const struct _Self & __x)
{
  bool D.60162;
  struct _List_node_base * D.60163;
  struct _List_node_base * D.60164;

  D.60163 = this->_M_node;
  D.60164 = __x->_M_node;
  D.60162 = D.60163 != D.60164;
  return D.60162;
}


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.59174)
{
  const struct slot0 * D.60166;
  struct slot0 * D.60167;
  struct slot & D.60168;

  D.60166 = &D.59174->D.59073;
  D.60167 = &this->D.59073;
  sigc::slot0<void>::operator= (D.60167, D.60166);
  D.60168 = this;
  return D.60168;
}


sigc::slot0<T_return>& sigc::slot0<T_return>::operator=(const sigc::slot0<T_return>&) [with T_return = void] (struct slot0 * const this, const struct slot0 & src)
{
  const struct slot_base * D.60170;
  struct slot_base * D.60171;
  struct slot0 & D.60172;

  D.60170 = &src->D.59031;
  D.60171 = &this->D.59031;
  sigc::slot_base::operator= (D.60171, D.60170);
  D.60172 = this;
  return D.60172;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot<void> >] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.60174;
  struct _List_node_base * D.60175;
  struct _List_iterator D.60176;
  struct iterator D.60177;
  struct iterator __ret;

  try
    {
      D.60174 = __position._M_node;
      D.60175 = D.60174->_M_next;
      std::_List_iterator<sigc::slot<void> >::_List_iterator (&__ret, D.60175);
      D.60176 = std::_List_iterator<sigc::slot<void> >::_M_const_cast (&__position);
      std::list<sigc::slot<void> >::_M_erase (this, D.60176);
      D.60177 = __ret;
      return D.60177;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_Self std::_List_iterator<_Tp>::_M_const_cast() const [with _Tp = sigc::slot<void>; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot<void> >] (const struct _List_iterator * const this)
{
  struct _Self D.60181;

  D.60181 = *this;
  return D.60181;
}


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot<void>; _Alloc = std::allocator<sigc::slot<void> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot<void> >] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.60183;
  struct slot * D.60184;
  struct slot * D.60185;
  struct _Tp_alloc_type D.59695;
  struct _List_base * D.60186;
  struct _Node * __n;

  D.60183 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.60183);
  __n = __position._M_node;
  D.60184 = &__n->_M_data;
  D.60185 = std::__addressof<sigc::slot<void> > (D.60184);
  D.60186 = &this->D.58920;
  D.59695 = std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_get_Tp_allocator (D.60186); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot<void> >::destroy (&D.59695, D.60185);
    }
  finally
    {
      std::allocator<sigc::slot<void> >::~allocator (&D.59695);
      D.59695 = {CLOBBER};
    }
  D.60186 = &this->D.58920;
  std::_List_base<sigc::slot<void>, std::allocator<sigc::slot<void> > >::_M_put_node (D.60186, __n);
}


void Glib::ThreadPool::SlotList::lock_and_unlock() (struct SlotList * const this)
{
  struct Mutex * D.60188;

  D.60188 = &this->mutex_;
  Glib::Threads::Mutex::lock (D.60188);
  D.60188 = &this->mutex_;
  Glib::Threads::Mutex::unlock (D.60188);
}


Glib::ThreadPool::ThreadPool(int, bool) (struct ThreadPool * const this, int max_threads, bool exclusive)
{
  void * D.59215;
  int D.60189;
  struct SlotList * D.60190;
  struct GThreadPool * D.60191;
  struct GError * error.6;
  struct SlotList * D.60195;

  this->_vptr.ThreadPool = &MEM[(void *)&_ZTVN4Glib10ThreadPoolE + 16B];
  this->gobject_ = 0B;
  D.59215 = operator new (24);
  try
    {
      Glib::ThreadPool::SlotList::SlotList (D.59215);
    }
  catch
    {
      operator delete (D.59215);
    }
  this->slot_list_ = D.59215;
  {
    struct GError * error;

    try
      {
        error = 0B;
        D.60189 = (int) exclusive;
        D.60190 = this->slot_list_;
        D.60191 = g_thread_pool_new (call_thread_entry_slot, D.60190, max_threads, D.60189, &error);
        this->gobject_ = D.60191;
        error.6 = error;
        if (error.6 != 0B) goto <D.60193>; else goto <D.60194>;
        <D.60193>:
        D.60195 = this->slot_list_;
        if (D.60195 != 0B) goto <D.60196>; else goto <D.60197>;
        <D.60196>:
        Glib::ThreadPool::SlotList::~SlotList (D.60195);
        operator delete (D.60195);
        goto <D.60198>;
        <D.60197>:
        <D.60198>:
        this->slot_list_ = 0B;
        error.6 = error;
        Glib::Error::throw_exception (error.6);
        <D.60194>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
}


void {anonymous}::call_thread_entry_slot(void*, void*) (void * data, void * user_data)
{
  register struct Exit * D.59205;
  void * D.60203;
  void * D.60204;

  try
    {
      {
        struct SlotList * const slot_list;
        struct slot slot;

        try
          {
            slot_list = user_data;
            slot = Glib::ThreadPool::SlotList::pop (slot_list, data); [return slot optimization]
            try
              {
                sigc::slot0<void>::operator() (&slot.D.59073);
              }
            finally
              {
                sigc::slot<void>::~slot (&slot);
              }
          }
        finally
          {
            slot = {CLOBBER};
          }
      }
    }
  catch
    {
      catch (struct Exit)
        {
          {
            struct Exit & D.59203;

            try
              {
                D.60203 = __builtin_eh_pointer (0);
                D.59205 = __cxa_begin_catch (D.60203);
                D.59203 = D.59205;
              }
            finally
              {
                __cxa_end_catch ();
              }
          }
        }
      catch (NULL)
        {
          try
            {
              D.60204 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.60204);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.7;
  bool iftmp.8;
  const struct slot_base * D.60215;
  bool D.60216;
  bool D.60217;
  bool D.60219;
  bool D.60220;
  struct rep_type * D.60224;
  void * (*<Tfcd>) (void *) D.60225;

  D.60215 = &this->D.59031;
  D.60216 = sigc::slot_base::empty (D.60215);
  D.60217 = ~D.60216;
  if (D.60217 != 0) goto <D.60218>; else goto <D.60213>;
  <D.60218>:
  D.60215 = &this->D.59031;
  D.60219 = sigc::slot_base::blocked (D.60215);
  D.60220 = ~D.60219;
  if (D.60220 != 0) goto <D.60221>; else goto <D.60213>;
  <D.60221>:
  iftmp.8 = 1;
  goto <D.60214>;
  <D.60213>:
  iftmp.8 = 0;
  <D.60214>:
  retval.7 = iftmp.8;
  if (retval.7 != 0) goto <D.60222>; else goto <D.60223>;
  <D.60222>:
  D.60224 = this->D.59031.rep_;
  D.60225 = D.60224->call_;
  D.60224 = this->D.59031.rep_;
  D.60225 (D.60224);
  return;
  <D.60223>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.60227;
  bool iftmp.9;
  struct rep_type * D.60232;
  void * (*<Tfcd>) (void *) D.60234;

  D.60232 = this->rep_;
  if (D.60232 == 0B) goto <D.60229>; else goto <D.60233>;
  <D.60233>:
  D.60232 = this->rep_;
  D.60234 = D.60232->call_;
  if (D.60234 == 0B) goto <D.60229>; else goto <D.60230>;
  <D.60229>:
  iftmp.9 = 1;
  goto <D.60231>;
  <D.60230>:
  iftmp.9 = 0;
  <D.60231>:
  D.60227 = iftmp.9;
  return D.60227;
}


bool sigc::slot_base::blocked() const (const struct slot_base * const this)
{
  bool D.60236;

  D.60236 = this->blocked_;
  return D.60236;
}


Glib::ThreadPool::~ThreadPool() (struct ThreadPool * const this)
{
  struct GThreadPool * D.60238;
  struct SlotList * D.60242;
  struct SlotList * D.60245;
  int D.60250;

  {
    this->_vptr.ThreadPool = &MEM[(void *)&_ZTVN4Glib10ThreadPoolE + 16B];
    try
      {
        D.60238 = this->gobject_;
        if (D.60238 != 0B) goto <D.60239>; else goto <D.60240>;
        <D.60239>:
        D.60238 = this->gobject_;
        g_thread_pool_free (D.60238, 1, 1);
        goto <D.60241>;
        <D.60240>:
        <D.60241>:
        D.60242 = this->slot_list_;
        if (D.60242 != 0B) goto <D.60243>; else goto <D.60244>;
        <D.60243>:
        D.60242 = this->slot_list_;
        Glib::ThreadPool::SlotList::lock_and_unlock (D.60242);
        D.60245 = this->slot_list_;
        if (D.60245 != 0B) goto <D.60246>; else goto <D.60247>;
        <D.60246>:
        Glib::ThreadPool::SlotList::~SlotList (D.60245);
        operator delete (D.60245);
        goto <D.60248>;
        <D.60247>:
        <D.60248>:
        goto <D.60249>;
        <D.60244>:
        <D.60249>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59226>:
  D.60250 = 0;
  if (D.60250 != 0) goto <D.60251>; else goto <D.60252>;
  <D.60251>:
  operator delete (this);
  goto <D.60253>;
  <D.60252>:
  <D.60253>:
}


virtual Glib::ThreadPool::~ThreadPool() (struct ThreadPool * const this)
{
  Glib::ThreadPool::~ThreadPool (this);
  <D.59230>:
  operator delete (this);
}


void Glib::ThreadPool::push(const sigc::slot<void>&) (struct ThreadPool * const this, const struct slot & slot)
{
  struct SlotList * D.60255;
  struct GThreadPool * D.60256;
  struct GError * error.10;
  struct slot D.59237;
  struct slot * const slot_ptr;
  struct GError * error;

  try
    {
      D.60255 = this->slot_list_;
      slot_ptr = Glib::ThreadPool::SlotList::push (D.60255, slot);
      error = 0B;
      D.60256 = this->gobject_;
      g_thread_pool_push (D.60256, slot_ptr, &error);
      error.10 = error;
      if (error.10 != 0B) goto <D.60258>; else goto <D.60259>;
      <D.60258>:
      D.60255 = this->slot_list_;
      D.59237 = Glib::ThreadPool::SlotList::pop (D.60255, slot_ptr); [return slot optimization]
      sigc::slot<void>::~slot (&D.59237);
      D.59237 = {CLOBBER};
      error.10 = error;
      Glib::Error::throw_exception (error.10);
      <D.60259>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


void Glib::ThreadPool::set_max_threads(int) (struct ThreadPool * const this, int max_threads)
{
  struct GThreadPool * D.60262;
  struct GError * error.11;
  struct GError * error;

  try
    {
      error = 0B;
      D.60262 = this->gobject_;
      g_thread_pool_set_max_threads (D.60262, max_threads, &error);
      error.11 = error;
      if (error.11 != 0B) goto <D.60264>; else goto <D.60265>;
      <D.60264>:
      error.11 = error;
      Glib::Error::throw_exception (error.11);
      <D.60265>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


int Glib::ThreadPool::get_max_threads() const (const struct ThreadPool * const this)
{
  int D.60267;
  struct GThreadPool * D.60268;

  D.60268 = this->gobject_;
  D.60267 = g_thread_pool_get_max_threads (D.60268);
  return D.60267;
}


unsigned int Glib::ThreadPool::get_num_threads() const (const struct ThreadPool * const this)
{
  unsigned int D.60271;
  struct GThreadPool * D.60272;

  D.60272 = this->gobject_;
  D.60271 = g_thread_pool_get_num_threads (D.60272);
  return D.60271;
}


unsigned int Glib::ThreadPool::unprocessed() const (const struct ThreadPool * const this)
{
  unsigned int D.60275;
  struct GThreadPool * D.60276;

  D.60276 = this->gobject_;
  D.60275 = g_thread_pool_unprocessed (D.60276);
  return D.60275;
}


bool Glib::ThreadPool::get_exclusive() const (const struct ThreadPool * const this)
{
  bool retval.12;
  int retval.13;
  struct GThreadPool * D.60281;
  long int D.60285;
  long int D.60286;
  bool D.60290;
  int D.60291;
  static const char __PRETTY_FUNCTION__[45] = "bool Glib::ThreadPool::get_exclusive() const";

  {
    {
      {
        int _g_boolean_var_;

        D.60281 = this->gobject_;
        if (D.60281 != 0B) goto <D.60282>; else goto <D.60283>;
        <D.60282>:
        _g_boolean_var_ = 1;
        goto <D.60284>;
        <D.60283>:
        _g_boolean_var_ = 0;
        <D.60284>:
        retval.13 = _g_boolean_var_;
      }
      D.60285 = (long int) retval.13;
      D.60286 = __builtin_expect (D.60285, 1);
      retval.12 = D.60286 != 0;
      if (retval.12 != 0) goto <D.60287>; else goto <D.60288>;
      <D.60287>:
      goto <D.60289>;
      <D.60288>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "gobject_ != 0");
      D.60290 = 0;
      return D.60290;
      <D.60289>:
    }
  }
  D.60281 = this->gobject_;
  D.60291 = D.60281->exclusive;
  D.60290 = D.60291 != 0;
  return D.60290;
}


void Glib::ThreadPool::shutdown(bool) (struct ThreadPool * const this, bool immediately)
{
  struct GThreadPool * D.60293;
  int D.60296;
  struct SlotList * D.60298;
  struct SlotList * D.60301;

  D.60293 = this->gobject_;
  if (D.60293 != 0B) goto <D.60294>; else goto <D.60295>;
  <D.60294>:
  D.60296 = (int) immediately;
  D.60293 = this->gobject_;
  g_thread_pool_free (D.60293, D.60296, 1);
  this->gobject_ = 0B;
  goto <D.60297>;
  <D.60295>:
  <D.60297>:
  D.60298 = this->slot_list_;
  if (D.60298 != 0B) goto <D.60299>; else goto <D.60300>;
  <D.60299>:
  D.60298 = this->slot_list_;
  Glib::ThreadPool::SlotList::lock_and_unlock (D.60298);
  D.60301 = this->slot_list_;
  if (D.60301 != 0B) goto <D.60302>; else goto <D.60303>;
  <D.60302>:
  Glib::ThreadPool::SlotList::~SlotList (D.60301);
  operator delete (D.60301);
  goto <D.60304>;
  <D.60303>:
  <D.60304>:
  this->slot_list_ = 0B;
  goto <D.60305>;
  <D.60300>:
  <D.60305>:
}


static void Glib::ThreadPool::set_max_unused_threads(int) (int max_threads)
{
  g_thread_pool_set_max_unused_threads (max_threads);
}


static int Glib::ThreadPool::get_max_unused_threads() ()
{
  int D.60306;

  D.60306 = g_thread_pool_get_max_unused_threads ();
  return D.60306;
}


static unsigned int Glib::ThreadPool::get_num_unused_threads() ()
{
  unsigned int D.60309;

  D.60309 = g_thread_pool_get_num_unused_threads ();
  return D.60309;
}


static void Glib::ThreadPool::stop_unused_threads() ()
{
  g_thread_pool_stop_unused_threads ();
}