sigc::internal::signal_impl::signal_impl() (struct signal_impl * const this)
{
  struct list * D.19797;

  this->ref_count_ = 0;
  this->exec_count_ = 0;
  this->deferred_ = 0;
  D.19797 = &this->slots_;
  std::list<sigc::slot_base>::list (D.19797);
  try
    {

    }
  catch
    {
      D.19797 = &this->slots_;
      std::list<sigc::slot_base>::~list (D.19797);
    }
}


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

  D.19798 = &this->D.17901;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_List_base (D.19798);
  try
    {

    }
  catch
    {
      D.19798 = &this->D.17901;
      std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::~_List_base (D.19798);
    }
}


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

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


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


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

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

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


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

  try
    {
      {

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


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

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


void sigc::internal::signal_impl::clear() (struct signal_impl * const this)
{
  struct list * D.19804;
  struct slot_base * D.19805;
  bool retval.0;
  struct iterator D.19001;
  const bool saved_deferred;
  struct signal_exec exec;

  try
    {
      saved_deferred = this->deferred_;
      sigc::internal::signal_exec::signal_exec (&exec, this);
      try
        {
          {
            struct iterator_type i;

            try
              {
                D.19804 = &this->slots_;
                i = std::list<sigc::slot_base>::begin (D.19804);
                goto <D.19005>;
                <D.19004>:
                D.19805 = std::_List_iterator<sigc::slot_base>::operator-> (&i);
                sigc::slot_base::disconnect (D.19805);
                std::_List_iterator<sigc::slot_base>::operator++ (&i);
                <D.19005>:
                D.19804 = &this->slots_;
                D.19001 = std::list<sigc::slot_base>::end (D.19804);
                try
                  {
                    retval.0 = std::_List_iterator<sigc::slot_base>::operator!= (&i, &D.19001);
                  }
                finally
                  {
                    D.19001 = {CLOBBER};
                  }
                if (retval.0 != 0) goto <D.19004>; else goto <D.19002>;
                <D.19002>:
              }
            finally
              {
                i = {CLOBBER};
              }
          }
          this->deferred_ = saved_deferred;
          D.19804 = &this->slots_;
          std::list<sigc::slot_base>::clear (D.19804);
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
    }
}


sigc::internal::signal_exec::signal_exec(const sigc::internal::signal_impl*) (struct signal_exec * const this, const struct signal_impl * sig)
{
  struct signal_impl * D.19811;

  this->sig_ = sig;
  D.19811 = this->sig_;
  sigc::internal::signal_impl::reference_exec (D.19811);
}


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.19812;
  unsigned short D.19813;
  unsigned short D.19814;
  short int D.19815;
  short int D.19816;
  unsigned short D.19817;
  unsigned short D.19818;
  short int D.19819;

  D.19812 = this->ref_count_;
  D.19813 = (unsigned short) D.19812;
  D.19814 = D.19813 + 1;
  D.19815 = (short int) D.19814;
  this->ref_count_ = D.19815;
  D.19816 = this->exec_count_;
  D.19817 = (unsigned short) D.19816;
  D.19818 = D.19817 + 1;
  D.19819 = (short int) D.19818;
  this->exec_count_ = D.19819;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::begin() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this)
{
  struct iterator D.19820;
  struct iterator D.19397;
  struct _List_node_base * D.19821;

  D.19821 = this->D.17901._M_impl._M_node._M_next;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.19397, D.19821);
  try
    {
      D.19820 = D.19397;
      return D.19820;
    }
  finally
    {
      D.19397 = {CLOBBER};
    }
}


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


_Tp* std::_List_iterator<_Tp>::operator->() const [with _Tp = sigc::slot_base; std::_List_iterator<_Tp>::pointer = sigc::slot_base*] (const struct _List_iterator * const this)
{
  struct slot_base * D.19824;
  struct _List_node_base * D.19825;
  struct slot_base * D.19826;

  D.19825 = this->_M_node;
  D.19826 = &MEM[(struct _Node *)D.19825]._M_data;
  D.19824 = std::__addressof<sigc::slot_base> (D.19826);
  return D.19824;
}


_Tp* std::__addressof(_Tp&) [with _Tp = sigc::slot_base] (struct slot_base & __r)
{
  struct slot_base * D.19828;

  D.19828 = __r;
  return D.19828;
}


std::_List_iterator<_Tp>::_Self& std::_List_iterator<_Tp>::operator++() [with _Tp = sigc::slot_base; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot_base>] (struct _List_iterator * const this)
{
  struct _List_node_base * D.19830;
  struct _List_node_base * D.19831;
  struct _Self & D.19832;

  D.19830 = this->_M_node;
  D.19831 = D.19830->_M_next;
  this->_M_node = D.19831;
  D.19832 = this;
  return D.19832;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::end() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this)
{
  struct iterator D.19834;
  struct iterator D.19381;
  struct _List_node_base * D.19835;

  D.19835 = &this->D.17901._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.19381, D.19835);
  try
    {
      D.19834 = D.19381;
      return D.19834;
    }
  finally
    {
      D.19381 = {CLOBBER};
    }
}


bool std::_List_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = sigc::slot_base; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot_base>] (const struct _List_iterator * const this, const struct _Self & __x)
{
  bool D.19838;
  struct _List_node_base * D.19839;
  struct _List_node_base * D.19840;

  D.19839 = this->_M_node;
  D.19840 = __x->_M_node;
  D.19838 = D.19839 != D.19840;
  return D.19838;
}


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

  D.19842 = &this->D.17901;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_clear (D.19842);
  D.19842 = &this->D.17901;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_init (D.19842);
}


void std::_List_base<_Tp, _Alloc>::_M_clear() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this)
{
  struct slot_base * D.19843;
  struct slot_base * D.19844;
  struct _Tp_alloc_type D.19510;
  struct _List_node_base * D.19845;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.19386._M_next;
    D.19843 = &__tmp->_M_data;
    D.19844 = std::__addressof<sigc::slot_base> (D.19843);
    D.19510 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.19510, D.19844);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.19510);
        D.19510 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.19512>:
  D.19845 = &this->_M_impl._M_node;
  if (D.19845 != __cur) goto <D.19513>; else goto <D.19511>;
  <D.19511>:
}


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

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


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

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


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

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

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


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

  try
    {
      {

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


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


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

  D.19854 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.19854, __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_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _List_node * __p, size_type D.17398)
{
  operator delete (__p);
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<sigc::slot_base>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.19661>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.19855 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.19855);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


sigc::internal::signal_exec::~signal_exec() (struct signal_exec * const this)
{
  struct signal_impl * D.19857;

  {
    try
      {
        D.19857 = this->sig_;
        sigc::internal::signal_impl::unreference_exec (D.19857);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.18018>:
}


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.1;
  short int D.19860;
  unsigned short D.19861;
  unsigned short D.19862;
  short int D.19863;
  bool retval.2;
  bool iftmp.3;
  short int D.19874;
  unsigned short D.19875;
  unsigned short D.19876;
  short int D.19877;
  bool D.19879;

  D.19860 = this->ref_count_;
  D.19861 = (unsigned short) D.19860;
  D.19862 = D.19861 + 65535;
  D.19863 = (short int) D.19862;
  this->ref_count_ = D.19863;
  D.19860 = this->ref_count_;
  retval.1 = D.19860 == 0;
  if (retval.1 != 0) goto <D.19864>; else goto <D.19865>;
  <D.19864>:
  if (this != 0B) goto <D.19866>; else goto <D.19867>;
  <D.19866>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.19868>;
  <D.19867>:
  <D.19868>:
  goto <D.19869>;
  <D.19865>:
  D.19874 = this->exec_count_;
  D.19875 = (unsigned short) D.19874;
  D.19876 = D.19875 + 65535;
  D.19877 = (short int) D.19876;
  this->exec_count_ = D.19877;
  D.19874 = this->exec_count_;
  if (D.19874 == 0) goto <D.19878>; else goto <D.19872>;
  <D.19878>:
  D.19879 = this->deferred_;
  if (D.19879 != 0) goto <D.19880>; else goto <D.19872>;
  <D.19880>:
  iftmp.3 = 1;
  goto <D.19873>;
  <D.19872>:
  iftmp.3 = 0;
  <D.19873>:
  retval.2 = iftmp.3;
  if (retval.2 != 0) goto <D.19881>; else goto <D.19882>;
  <D.19881>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.19883>;
  <D.19882>:
  <D.19883>:
  <D.19869>:
}


sigc::internal::signal_impl::~signal_impl() (struct signal_impl * const this)
{
  struct list * D.19884;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.19884 = &this->slots_;
            std::list<sigc::slot_base>::~list (D.19884);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.17984>:
}


std::list<sigc::slot_base>::~list() (struct list * const this)
{
  struct _List_base * D.19886;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.19886 = &this->D.17901;
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::~_List_base (D.19886);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.17979>:
}


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

  {
    try
      {
        try
          {
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_clear (this);
          }
        finally
          {
            D.19888 = &this->_M_impl;
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_List_impl::~_List_impl (D.19888);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.19373>:
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.19503>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.19891 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.19891);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


sigc::internal::signal_impl::size_type sigc::internal::signal_impl::size() const (const struct signal_impl * const this)
{
  size_type D.19893;
  const struct list * D.19894;

  D.19894 = &this->slots_;
  D.19893 = std::list<sigc::slot_base>::size (D.19894);
  return D.19893;
}


std::list<_Tp, _Alloc>::size_type std::list<_Tp, _Alloc>::size() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::size_type = long unsigned int] (const struct list * const this)
{
  size_type D.19897;
  struct _List_const_iterator D.19898;
  struct _List_const_iterator D.19899;
  long int D.19900;

  D.19898 = std::list<sigc::slot_base>::end (this);
  D.19899 = std::list<sigc::slot_base>::begin (this);
  D.19900 = std::distance<std::_List_const_iterator<sigc::slot_base> > (D.19899, D.19898);
  D.19897 = (size_type) D.19900;
  return D.19897;
}


std::list<_Tp, _Alloc>::const_iterator std::list<_Tp, _Alloc>::end() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::const_iterator = std::_List_const_iterator<sigc::slot_base>] (const struct list * const this)
{
  struct const_iterator D.19903;
  struct const_iterator D.19454;
  const struct _List_node_base * D.19904;

  D.19904 = &this->D.17901._M_impl._M_node;
  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.19454, D.19904);
  try
    {
      D.19903 = D.19454;
      return D.19903;
    }
  finally
    {
      D.19454 = {CLOBBER};
    }
}


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


std::list<_Tp, _Alloc>::const_iterator std::list<_Tp, _Alloc>::begin() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::const_iterator = std::_List_const_iterator<sigc::slot_base>] (const struct list * const this)
{
  struct const_iterator D.19907;
  struct const_iterator D.19452;
  struct _List_node_base * D.19908;

  D.19908 = this->D.17901._M_impl._M_node._M_next;
  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.19452, D.19908);
  try
    {
      D.19907 = D.19452;
      return D.19907;
    }
  finally
    {
      D.19452 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = std::_List_const_iterator<sigc::slot_base>; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct _List_const_iterator __first, struct _List_const_iterator __last)
{
  difference_type D.19911;
  struct input_iterator_tag D.19575;
  struct iterator_category D.19538;
  struct iterator_category * D.19912;
  struct input_iterator_tag D.19913;

  std::__iterator_category<std::_List_const_iterator<sigc::slot_base> > (&__first);
  try
    {
      D.19912 = &D.19538;
      D.19911 = std::__distance<std::_List_const_iterator<sigc::slot_base> > (__first, __last, D.19913);
      return D.19911;
    }
  finally
    {
      D.19538 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = std::_List_const_iterator<sigc::slot_base>; typename std::iterator_traits<_Iterator>::iterator_category = std::bidirectional_iterator_tag] (const struct _List_const_iterator & D.19537)
{
  struct iterator_category D.19916;

  return D.19916;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_InputIterator, _InputIterator, std::input_iterator_tag) [with _InputIterator = std::_List_const_iterator<sigc::slot_base>; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct _List_const_iterator __first, struct _List_const_iterator __last, struct input_iterator_tag D.19557)
{
  bool retval.4;
  difference_type D.19919;
  difference_type __n;

  __n = 0;
  goto <D.19708>;
  <D.19709>:
  std::_List_const_iterator<sigc::slot_base>::operator++ (&__first);
  __n = __n + 1;
  <D.19708>:
  retval.4 = std::_List_const_iterator<sigc::slot_base>::operator!= (&__first, &__last);
  if (retval.4 != 0) goto <D.19709>; else goto <D.19707>;
  <D.19707>:
  D.19919 = __n;
  return D.19919;
}


std::_List_const_iterator<_Tp>::_Self& std::_List_const_iterator<_Tp>::operator++() [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::_Self = std::_List_const_iterator<sigc::slot_base>] (struct _List_const_iterator * const this)
{
  const struct _List_node_base * D.19921;
  struct _List_node_base * D.19922;
  struct _Self & D.19923;

  D.19921 = this->_M_node;
  D.19922 = D.19921->_M_next;
  this->_M_node = D.19922;
  D.19923 = this;
  return D.19923;
}


bool std::_List_const_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::_Self = std::_List_const_iterator<sigc::slot_base>] (const struct _List_const_iterator * const this, const struct _Self & __x)
{
  bool D.19925;
  const struct _List_node_base * D.19926;
  const struct _List_node_base * D.19927;

  D.19926 = this->_M_node;
  D.19927 = __x->_M_node;
  D.19925 = D.19926 != D.19927;
  return D.19925;
}


bool sigc::internal::signal_impl::blocked() const (const struct signal_impl * const this)
{
  const struct list * D.19929;
  bool retval.5;
  const struct slot_base * D.19931;
  bool D.19932;
  bool D.19935;
  bool retval.6;
  struct const_iterator D.19014;

  {
    struct const_iterator_type iter;

    try
      {
        D.19929 = &this->slots_;
        iter = std::list<sigc::slot_base>::begin (D.19929);
        goto <D.19018>;
        <D.19017>:
        D.19931 = std::_List_const_iterator<sigc::slot_base>::operator-> (&iter);
        D.19932 = sigc::slot_base::blocked (D.19931);
        retval.5 = ~D.19932;
        if (retval.5 != 0) goto <D.19933>; else goto <D.19934>;
        <D.19933>:
        D.19935 = 0;
        return D.19935;
        <D.19934>:
        std::_List_const_iterator<sigc::slot_base>::operator++ (&iter);
        <D.19018>:
        D.19929 = &this->slots_;
        D.19014 = std::list<sigc::slot_base>::end (D.19929);
        try
          {
            retval.6 = std::_List_const_iterator<sigc::slot_base>::operator!= (&iter, &D.19014);
          }
        finally
          {
            D.19014 = {CLOBBER};
          }
        if (retval.6 != 0) goto <D.19017>; else goto <D.19015>;
        <D.19015>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  D.19935 = 1;
  return D.19935;
}


const _Tp* std::_List_const_iterator<_Tp>::operator->() const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::pointer = const sigc::slot_base*] (const struct _List_const_iterator * const this)
{
  const struct slot_base * D.19942;
  const struct _List_node_base * D.19943;
  const struct slot_base * D.19944;

  D.19943 = this->_M_node;
  D.19944 = &MEM[(const struct _Node *)D.19943]._M_data;
  D.19942 = std::__addressof<const sigc::slot_base> (D.19944);
  return D.19942;
}


_Tp* std::__addressof(_Tp&) [with _Tp = const sigc::slot_base] (const struct slot_base & __r)
{
  const struct slot_base * D.19946;

  D.19946 = __r;
  return D.19946;
}


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

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


void sigc::internal::signal_impl::block(bool) (struct signal_impl * const this, bool should_block)
{
  struct list * D.19950;
  int D.19951;
  struct slot_base * D.19952;
  bool retval.7;
  struct iterator D.19025;

  {
    struct iterator_type iter;

    try
      {
        D.19950 = &this->slots_;
        iter = std::list<sigc::slot_base>::begin (D.19950);
        goto <D.19029>;
        <D.19028>:
        D.19951 = (int) should_block;
        D.19952 = std::_List_iterator<sigc::slot_base>::operator-> (&iter);
        sigc::slot_base::block (D.19952, D.19951);
        std::_List_iterator<sigc::slot_base>::operator++ (&iter);
        <D.19029>:
        D.19950 = &this->slots_;
        D.19025 = std::list<sigc::slot_base>::end (D.19950);
        try
          {
            retval.7 = std::_List_iterator<sigc::slot_base>::operator!= (&iter, &D.19025);
          }
        finally
          {
            D.19025 = {CLOBBER};
          }
        if (retval.7 != 0) goto <D.19028>; else goto <D.19026>;
        <D.19026>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
}


sigc::internal::signal_impl::iterator_type sigc::internal::signal_impl::connect(const sigc::slot_base&) (struct signal_impl * const this, const struct slot_base & slot_)
{
  struct iterator_type D.19956;
  struct list * D.19957;
  struct _List_iterator D.19958;

  D.19957 = &this->slots_;
  D.19958 = std::list<sigc::slot_base>::end (D.19957);
  D.19956 = sigc::internal::signal_impl::insert (this, D.19958, slot_);
  return D.19956;
}


sigc::internal::signal_impl::iterator_type sigc::internal::signal_impl::erase(sigc::internal::signal_impl::iterator_type) (struct signal_impl * const this, struct iterator_type i)
{
  struct slot_base * D.19960;
  struct iterator_type D.19961;
  struct list * D.19962;
  const bool saved_deferred;
  struct signal_exec exec;

  try
    {
      saved_deferred = this->deferred_;
      sigc::internal::signal_exec::signal_exec (&exec, this);
      try
        {
          D.19960 = std::_List_iterator<sigc::slot_base>::operator-> (&i);
          sigc::slot_base::disconnect (D.19960);
          this->deferred_ = saved_deferred;
          D.19962 = &this->slots_;
          D.19961 = std::list<sigc::slot_base>::erase (D.19962, i);
          return D.19961;
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.19969;
  struct _List_node_base * D.19970;
  struct _List_iterator D.19971;
  struct iterator D.19972;
  struct iterator __ret;

  try
    {
      D.19969 = __position._M_node;
      D.19970 = D.19969->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.19970);
      D.19971 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.19971);
      D.19972 = __ret;
      return D.19972;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


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

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


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.19978;
  struct slot_base * D.19979;
  struct slot_base * D.19980;
  struct _Tp_alloc_type D.19527;
  struct _List_base * D.19981;
  struct _Node * __n;

  D.19978 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.19978);
  __n = __position._M_node;
  D.19979 = &__n->_M_data;
  D.19980 = std::__addressof<sigc::slot_base> (D.19979);
  D.19981 = &this->D.17901;
  D.19527 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.19981); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.19527, D.19980);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.19527);
      D.19527 = {CLOBBER};
    }
  D.19981 = &this->D.17901;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.19981, __n);
}


sigc::internal::signal_impl::iterator_type sigc::internal::signal_impl::insert(sigc::internal::signal_impl::iterator_type, const sigc::slot_base&) (struct signal_impl * const this, struct iterator_type i, const struct slot_base & slot_)
{
  struct list * D.19983;
  struct _List_iterator D.19063;
  void * si.8;
  struct slot_base * D.19984;
  struct iterator_type D.19985;
  struct iterator_type temp;
  struct self_and_iter * si;

  try
    {
      D.19983 = &this->slots_;
      temp = std::list<sigc::slot_base>::insert (D.19983, i, slot_);
      D.19063 = temp;
      try
        {
          si.8 = operator new (16);
          try
            {
              sigc::internal::self_and_iter::self_and_iter (si.8, this, D.19063);
            }
          catch
            {
              operator delete (si.8);
            }
          si = si.8;
        }
      finally
        {
          D.19063 = {CLOBBER};
        }
      D.19984 = std::_List_iterator<sigc::slot_base>::operator-> (&temp);
      sigc::slot_base::set_parent (D.19984, si, notify);
      D.19985 = temp;
      return D.19985;
    }
  finally
    {
      temp = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, struct iterator __position, const struct value_type & __x)
{
  struct _Self D.19389;
  struct _List_node_base * D.19992;
  struct _List_node_base * D.19993;
  struct iterator D.19994;
  struct iterator D.19390;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.19389 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.19992 = D.19389._M_node;
  D.19993 = &__tmp->D.19386;
  std::__detail::_List_node_base::_M_hook (D.19993, D.19992);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.19390, __tmp);
  try
    {
      D.19994 = D.19390;
      return D.19994;
    }
  finally
    {
      D.19390 = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.19998;
  struct slot_base * D.19999;
  struct slot_base * D.20000;
  struct _Tp_alloc_type D.19519;
  void * D.20001;
  struct _Node * D.20002;
  struct _Node * __p;

  D.19998 = &this->D.17901;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.19998);
  try
    {
      D.19999 = &__p->_M_data;
      D.20000 = std::__addressof<sigc::slot_base> (D.19999);
      D.19998 = &this->D.17901;
      D.19519 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.19998); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.19519, D.20000, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.19519);
          D.19519 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.20001 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.20001);
              D.19998 = &this->D.17901;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.19998, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.20002 = __p;
  return D.20002;
}


std::_List_node<_Tp>* std::_List_base<_Tp, _Alloc>::_M_get_node() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this)
{
  struct _List_node * D.20009;
  struct _List_impl * D.20010;

  D.20010 = &this->_M_impl;
  D.20009 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::allocate (D.20010, 1, 0B);
  return D.20009;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.17394)
{
  bool retval.9;
  long unsigned int D.20014;
  struct _List_node * D.20017;
  long unsigned int D.20018;

  D.20014 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.9 = D.20014 < __n;
  if (retval.9 != 0) goto <D.20015>; else goto <D.20016>;
  <D.20015>:
  std::__throw_bad_alloc ();
  <D.20016>:
  D.20018 = __n * 32;
  D.20017 = operator new (D.20018);
  return D.20017;
}


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

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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = sigc::slot_base; __gnu_cxx::new_allocator<_Tp>::pointer = sigc::slot_base*] (struct new_allocator * const this, struct slot_base * __p, const struct slot_base & __val)
{
  void * D.19683;
  void * D.19684;
  struct slot_base * iftmp.10;

  D.19683 = __p;
  D.19684 = operator new (16, D.19683);
  if (D.19684 != 0B) goto <D.20025>; else goto <D.20026>;
  <D.20025>:
  try
    {
      sigc::slot_base::slot_base (D.19684, __val);
    }
  catch
    {
      operator delete (D.19684, D.19683);
    }
  iftmp.10 = D.19684;
  goto <D.20027>;
  <D.20026>:
  iftmp.10 = D.19684;
  <D.20027>:
}


void* operator new(std::size_t, void*) (size_t D.4918, void * __p)
{
  void * D.20029;
  void * D.20030;

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


void operator delete(void*, void*) (void * D.4926, void * D.4927)
{
  void * D.20032;

  try
    {

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


sigc::internal::self_and_iter::self_and_iter(sigc::internal::signal_impl*, sigc::internal::signal_impl::iterator_type) (struct self_and_iter * const this, struct signal_impl * self, struct iterator_type iter)
{
  this->self_ = self;
  this->iter_ = iter;
}


void sigc::internal::signal_impl::sweep() (struct signal_impl * const this)
{
  struct list * D.20033;
  bool retval.11;
  struct slot_base & D.20035;
  bool retval.12;
  struct iterator D.19071;
  struct signal_exec exec;
  struct iterator_type i;

  try
    {
      sigc::internal::signal_exec::signal_exec (&exec, this);
      try
        {
          this->deferred_ = 0;
          D.20033 = &this->slots_;
          i = std::list<sigc::slot_base>::begin (D.20033);
          goto <D.19075>;
          <D.19076>:
          D.20035 = std::_List_iterator<sigc::slot_base>::operator* (&i);
          retval.11 = sigc::slot_base::empty (D.20035);
          if (retval.11 != 0) goto <D.20036>; else goto <D.20037>;
          <D.20036>:
          D.20033 = &this->slots_;
          i = std::list<sigc::slot_base>::erase (D.20033, i);
          goto <D.20038>;
          <D.20037>:
          std::_List_iterator<sigc::slot_base>::operator++ (&i);
          <D.20038>:
          <D.19075>:
          D.20033 = &this->slots_;
          D.19071 = std::list<sigc::slot_base>::end (D.20033);
          try
            {
              retval.12 = std::_List_iterator<sigc::slot_base>::operator!= (&i, &D.19071);
            }
          finally
            {
              D.19071 = {CLOBBER};
            }
          if (retval.12 != 0) goto <D.19076>; else goto <D.19074>;
          <D.19074>:
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
      i = {CLOBBER};
    }
}


_Tp& std::_List_iterator<_Tp>::operator*() const [with _Tp = sigc::slot_base; std::_List_iterator<_Tp>::reference = sigc::slot_base&] (const struct _List_iterator * const this)
{
  struct slot_base & D.20042;
  struct _List_node_base * D.20043;

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


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.20045;
  bool iftmp.13;
  struct rep_type * D.20050;
  void * (*<Tfcd>) (void *) D.20052;

  D.20050 = this->rep_;
  if (D.20050 == 0B) goto <D.20047>; else goto <D.20051>;
  <D.20051>:
  D.20050 = this->rep_;
  D.20052 = D.20050->call_;
  if (D.20052 == 0B) goto <D.20047>; else goto <D.20048>;
  <D.20047>:
  iftmp.13 = 1;
  goto <D.20049>;
  <D.20048>:
  iftmp.13 = 0;
  <D.20049>:
  D.20045 = iftmp.13;
  return D.20045;
}


static void* sigc::internal::signal_impl::notify(void*) (void * d)
{
  bool retval.14;
  struct element_type * D.20055;
  struct signal_impl * D.20056;
  short int D.20057;
  struct element_type * D.20060;
  struct signal_impl * D.20061;
  struct iterator D.19211;
  struct element_type * D.20062;
  struct element_type * D.20063;
  struct signal_impl * D.20064;
  struct list * D.20065;
  struct element_type * D.20067;
  struct signal_impl * D.20068;
  void * D.20069;
  struct auto_ptr si;

  try
    {
      std::auto_ptr<sigc::internal::self_and_iter>::auto_ptr (&si, d);
      try
        {
          {
            D.20055 = std::auto_ptr<sigc::internal::self_and_iter>::operator-> (&si);
            D.20056 = D.20055->self_;
            D.20057 = D.20056->exec_count_;
            retval.14 = D.20057 == 0;
            if (retval.14 != 0) goto <D.20058>; else goto <D.20059>;
            <D.20058>:
            {
              struct signal_exec exec;

              try
                {
                  D.20060 = std::auto_ptr<sigc::internal::self_and_iter>::operator-> (&si);
                  D.20061 = D.20060->self_;
                  sigc::internal::signal_exec::signal_exec (&exec, D.20061);
                  try
                    {
                      D.20062 = std::auto_ptr<sigc::internal::self_and_iter>::operator-> (&si);
                      D.20063 = std::auto_ptr<sigc::internal::self_and_iter>::operator-> (&si);
                      D.20064 = D.20063->self_;
                      D.20065 = &D.20064->slots_;
                      D.19211 = std::list<sigc::slot_base>::erase (D.20065, D.20062->iter_);
                    }
                  finally
                    {
                      sigc::internal::signal_exec::~signal_exec (&exec);
                    }
                }
              finally
                {
                  exec = {CLOBBER};
                }
            }
            goto <D.20066>;
            <D.20059>:
            D.20067 = std::auto_ptr<sigc::internal::self_and_iter>::operator-> (&si);
            D.20068 = D.20067->self_;
            D.20068->deferred_ = 1;
            <D.20066>:
          }
          D.20069 = 0B;
          return D.20069;
        }
      finally
        {
          std::auto_ptr<sigc::internal::self_and_iter>::~auto_ptr (&si);
        }
    }
  finally
    {
      si = {CLOBBER};
    }
}


std::auto_ptr<_Tp>::auto_ptr(std::auto_ptr<_Tp>::element_type*) [with _Tp = sigc::internal::self_and_iter; std::auto_ptr<_Tp>::element_type = sigc::internal::self_and_iter] (struct auto_ptr * const this, struct element_type * __p)
{
  void * D.20077;

  try
    {
      {
        this->_M_ptr = __p;
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.20077 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.20077);
          
        }
    }
}


std::auto_ptr<_Tp>::element_type* std::auto_ptr<_Tp>::operator->() const [with _Tp = sigc::internal::self_and_iter; std::auto_ptr<_Tp>::element_type = sigc::internal::self_and_iter] (const struct auto_ptr * const this)
{
  struct element_type * D.20078;
  void * D.20079;

  try
    {
      D.20078 = this->_M_ptr;
      return D.20078;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.20079 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.20079);
          
        }
    }
}


std::auto_ptr<_Tp>::~auto_ptr() [with _Tp = sigc::internal::self_and_iter] (struct auto_ptr * const this)
{
  struct self_and_iter * D.20081;

  {
    try
      {
        D.20081 = this->_M_ptr;
        operator delete (D.20081);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.19468>:
}


sigc::signal_base::signal_base() (struct signal_base * const this)
{
  struct trackable * D.20082;

  D.20082 = &this->D.18267;
  sigc::trackable::trackable (D.20082);
  try
    {
      this->impl_ = 0B;
    }
  catch
    {
      D.20082 = &this->D.18267;
      sigc::trackable::~trackable (D.20082);
    }
}


sigc::signal_base::signal_base(const sigc::signal_base&) (struct signal_base * const this, const struct signal_base & src)
{
  struct trackable * D.20083;
  struct signal_impl * D.20084;
  struct signal_impl * D.20085;

  D.20083 = &this->D.18267;
  sigc::trackable::trackable (D.20083);
  try
    {
      D.20084 = sigc::signal_base::impl (src);
      this->impl_ = D.20084;
      D.20085 = this->impl_;
      sigc::internal::signal_impl::reference (D.20085);
    }
  catch
    {
      D.20083 = &this->D.18267;
      sigc::trackable::~trackable (D.20083);
    }
}


void sigc::internal::signal_impl::reference() (struct signal_impl * const this)
{
  short int D.20088;
  unsigned short D.20089;
  unsigned short D.20090;
  short int D.20091;

  D.20088 = this->ref_count_;
  D.20089 = (unsigned short) D.20088;
  D.20090 = D.20089 + 1;
  D.20091 = (short int) D.20090;
  this->ref_count_ = D.20091;
}


sigc::signal_base::~signal_base() (struct signal_base * const this)
{
  struct signal_impl * D.20092;
  short int D.20095;
  struct trackable * D.20100;

  {
    try
      {
        try
          {
            D.20092 = this->impl_;
            if (D.20092 != 0B) goto <D.20093>; else goto <D.20094>;
            <D.20093>:
            D.20092 = this->impl_;
            D.20095 = D.20092->ref_count_;
            if (D.20095 == 1) goto <D.20096>; else goto <D.20097>;
            <D.20096>:
            D.20092 = this->impl_;
            sigc::internal::signal_impl::clear (D.20092);
            goto <D.20098>;
            <D.20097>:
            <D.20098>:
            D.20092 = this->impl_;
            sigc::internal::signal_impl::unreference (D.20092);
            goto <D.20099>;
            <D.20094>:
            <D.20099>:
          }
        finally
          {
            D.20100 = &this->D.18267;
            sigc::trackable::~trackable (D.20100);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.19230>:
}


void sigc::internal::signal_impl::unreference() (struct signal_impl * const this)
{
  bool retval.15;
  short int D.20104;
  unsigned short D.20105;
  unsigned short D.20106;
  short int D.20107;

  D.20104 = this->ref_count_;
  D.20105 = (unsigned short) D.20104;
  D.20106 = D.20105 + 65535;
  D.20107 = (short int) D.20106;
  this->ref_count_ = D.20107;
  D.20104 = this->ref_count_;
  retval.15 = D.20104 == 0;
  if (retval.15 != 0) goto <D.20108>; else goto <D.20109>;
  <D.20108>:
  if (this != 0B) goto <D.20110>; else goto <D.20111>;
  <D.20110>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.20112>;
  <D.20111>:
  <D.20112>:
  goto <D.20113>;
  <D.20109>:
  <D.20113>:
}


void sigc::signal_base::clear() (struct signal_base * const this)
{
  struct signal_impl * D.20114;

  D.20114 = this->impl_;
  if (D.20114 != 0B) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  D.20114 = this->impl_;
  sigc::internal::signal_impl::clear (D.20114);
  goto <D.20117>;
  <D.20116>:
  <D.20117>:
}


sigc::signal_base::size_type sigc::signal_base::size() const (const struct signal_base * const this)
{
  size_type D.20118;
  long unsigned int iftmp.16;
  struct signal_impl * D.20120;

  D.20120 = this->impl_;
  if (D.20120 != 0B) goto <D.20121>; else goto <D.20122>;
  <D.20121>:
  D.20120 = this->impl_;
  iftmp.16 = sigc::internal::signal_impl::size (D.20120);
  goto <D.20123>;
  <D.20122>:
  iftmp.16 = 0;
  <D.20123>:
  D.20118 = iftmp.16;
  return D.20118;
}


bool sigc::signal_base::blocked() const (const struct signal_base * const this)
{
  bool D.20126;
  bool iftmp.17;
  struct signal_impl * D.20128;

  D.20128 = this->impl_;
  if (D.20128 != 0B) goto <D.20129>; else goto <D.20130>;
  <D.20129>:
  D.20128 = this->impl_;
  iftmp.17 = sigc::internal::signal_impl::blocked (D.20128);
  goto <D.20131>;
  <D.20130>:
  iftmp.17 = 1;
  <D.20131>:
  D.20126 = iftmp.17;
  return D.20126;
}


void sigc::signal_base::block(bool) (struct signal_base * const this, bool should_block)
{
  struct signal_impl * D.20134;
  int D.20137;

  D.20134 = this->impl_;
  if (D.20134 != 0B) goto <D.20135>; else goto <D.20136>;
  <D.20135>:
  D.20137 = (int) should_block;
  D.20134 = this->impl_;
  sigc::internal::signal_impl::block (D.20134, D.20137);
  goto <D.20138>;
  <D.20136>:
  <D.20138>:
}


void sigc::signal_base::unblock() (struct signal_base * const this)
{
  struct signal_impl * D.20139;

  D.20139 = this->impl_;
  if (D.20139 != 0B) goto <D.20140>; else goto <D.20141>;
  <D.20140>:
  D.20139 = this->impl_;
  sigc::internal::signal_impl::block (D.20139, 0);
  goto <D.20142>;
  <D.20141>:
  <D.20142>:
}


sigc::signal_base::iterator_type sigc::signal_base::connect(const sigc::slot_base&) (struct signal_base * const this, const struct slot_base & slot_)
{
  struct iterator_type D.20143;
  struct signal_impl * D.20144;

  D.20144 = sigc::signal_base::impl (this);
  D.20143 = sigc::internal::signal_impl::connect (D.20144, slot_);
  return D.20143;
}


sigc::signal_base::iterator_type sigc::signal_base::insert(sigc::signal_base::iterator_type, const sigc::slot_base&) (struct signal_base * const this, struct iterator_type i, const struct slot_base & slot_)
{
  struct iterator_type D.20147;
  struct signal_impl * D.20148;

  D.20148 = sigc::signal_base::impl (this);
  D.20147 = sigc::internal::signal_impl::insert (D.20148, i, slot_);
  return D.20147;
}


sigc::signal_base::iterator_type sigc::signal_base::erase(sigc::signal_base::iterator_type) (struct signal_base * const this, struct iterator_type i)
{
  struct iterator_type D.20151;
  struct signal_impl * D.20152;

  D.20152 = sigc::signal_base::impl (this);
  D.20151 = sigc::internal::signal_impl::erase (D.20152, i);
  return D.20151;
}


sigc::signal_base& sigc::signal_base::operator=(const sigc::signal_base&) (struct signal_base * const this, const struct signal_base & src)
{
  struct signal_impl * D.20155;
  struct signal_impl * D.20156;
  struct signal_base & D.20159;
  short int D.20162;
  struct signal_impl * D.20167;

  D.20155 = src->impl_;
  D.20156 = this->impl_;
  if (D.20155 == D.20156) goto <D.20157>; else goto <D.20158>;
  <D.20157>:
  D.20159 = this;
  return D.20159;
  <D.20158>:
  D.20156 = this->impl_;
  if (D.20156 != 0B) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  D.20156 = this->impl_;
  D.20162 = D.20156->ref_count_;
  if (D.20162 == 1) goto <D.20163>; else goto <D.20164>;
  <D.20163>:
  D.20156 = this->impl_;
  sigc::internal::signal_impl::clear (D.20156);
  goto <D.20165>;
  <D.20164>:
  <D.20165>:
  D.20156 = this->impl_;
  sigc::internal::signal_impl::unreference (D.20156);
  goto <D.20166>;
  <D.20161>:
  <D.20166>:
  D.20167 = sigc::signal_base::impl (src);
  this->impl_ = D.20167;
  D.20156 = this->impl_;
  sigc::internal::signal_impl::reference (D.20156);
  D.20159 = this;
  return D.20159;
}


sigc::internal::signal_impl* sigc::signal_base::impl() const (const struct signal_base * const this)
{
  struct signal_impl * D.20170;
  void * D.19274;
  struct signal_impl * D.20174;

  D.20170 = this->impl_;
  if (D.20170 == 0B) goto <D.20171>; else goto <D.20172>;
  <D.20171>:
  D.19274 = operator new (24);
  try
    {
      sigc::internal::signal_impl::signal_impl (D.19274);
    }
  catch
    {
      operator delete (D.19274);
    }
  this->impl_ = D.19274;
  D.20170 = this->impl_;
  sigc::internal::signal_impl::reference (D.20170);
  goto <D.20173>;
  <D.20172>:
  <D.20173>:
  D.20174 = this->impl_;
  return D.20174;
}


