sigc::trackable::trackable() (struct trackable * const this)
{
  this->callback_list_ = 0B;
}


sigc::trackable::trackable(const sigc::trackable&) (struct trackable * const this, const struct trackable & D.7206)
{
  this->callback_list_ = 0B;
}


sigc::trackable& sigc::trackable::operator=(const sigc::trackable&) (struct trackable * const this, const struct trackable & src)
{
  struct trackable & D.23863;

  if (this != src) goto <D.23860>; else goto <D.23861>;
  <D.23860>:
  sigc::trackable::notify_callbacks (this);
  goto <D.23862>;
  <D.23861>:
  <D.23862>:
  D.23863 = this;
  return D.23863;
}


sigc::trackable::~trackable() (struct trackable * const this)
{
  {
    try
      {
        sigc::trackable::notify_callbacks (this);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.23459>:
}


void sigc::trackable::add_destroy_notify_callback(void*, sigc::trackable::func_destroy_notify) const (const struct trackable * const this, void * data, void * (*func_destroy_notify) (void *) func)
{
  struct trackable_callback_list * D.23867;

  D.23867 = sigc::trackable::callback_list (this);
  sigc::internal::trackable_callback_list::add_callback (D.23867, data, func);
}


void sigc::trackable::remove_destroy_notify_callback(void*) const (const struct trackable * const this, void * data)
{
  struct trackable_callback_list * D.23869;

  D.23869 = sigc::trackable::callback_list (this);
  sigc::internal::trackable_callback_list::remove_callback (D.23869, data);
}


void sigc::trackable::notify_callbacks() (struct trackable * const this)
{
  struct trackable_callback_list * D.23871;
  struct trackable_callback_list * D.23874;

  D.23871 = this->callback_list_;
  if (D.23871 != 0B) goto <D.23872>; else goto <D.23873>;
  <D.23872>:
  D.23874 = this->callback_list_;
  if (D.23874 != 0B) goto <D.23875>; else goto <D.23876>;
  <D.23875>:
  sigc::internal::trackable_callback_list::~trackable_callback_list (D.23874);
  operator delete (D.23874);
  goto <D.23877>;
  <D.23876>:
  <D.23877>:
  goto <D.23878>;
  <D.23873>:
  <D.23878>:
  this->callback_list_ = 0B;
}


sigc::internal::trackable_callback_list* sigc::trackable::callback_list() const (const struct trackable * const this)
{
  struct trackable_callback_list * D.23879;
  void * D.23477;
  struct trackable_callback_list * D.23883;

  D.23879 = this->callback_list_;
  if (D.23879 == 0B) goto <D.23880>; else goto <D.23881>;
  <D.23880>:
  D.23477 = operator new (24);
  try
    {
      sigc::internal::trackable_callback_list::trackable_callback_list (D.23477);
    }
  catch
    {
      operator delete (D.23477);
    }
  this->callback_list_ = D.23477;
  goto <D.23882>;
  <D.23881>:
  <D.23882>:
  D.23883 = this->callback_list_;
  return D.23883;
}


sigc::internal::trackable_callback_list::trackable_callback_list() (struct trackable_callback_list * const this)
{
  struct callback_list * D.23887;

  D.23887 = &this->callbacks_;
  std::list<sigc::internal::trackable_callback>::list (D.23887);
  try
    {
      this->clearing_ = 0;
    }
  catch
    {
      D.23887 = &this->callbacks_;
      std::list<sigc::internal::trackable_callback>::~list (D.23887);
    }
}


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

  D.23888 = &this->D.7140;
  std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_List_base (D.23888);
  try
    {

    }
  catch
    {
      D.23888 = &this->D.7140;
      std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::~_List_base (D.23888);
    }
}


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

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


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


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

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

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


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

  try
    {
      {

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


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

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


sigc::internal::trackable_callback_list::~trackable_callback_list() (struct trackable_callback_list * const this)
{
  struct callback_list * D.23893;
  bool retval.0;
  struct trackable_callback & D.23895;
  void * (*<Tf7f>) (void *) D.23896;
  struct trackable_callback & D.23899;
  void * (*<Tf7f>) (void *) D.23900;
  struct trackable_callback & D.23901;
  void * D.23902;
  bool retval.1;
  struct iterator D.23561;

  {
    try
      {
        try
          {
            {
              this->clearing_ = 1;
              {
                struct iterator i;

                try
                  {
                    D.23893 = &this->callbacks_;
                    i = std::list<sigc::internal::trackable_callback>::begin (D.23893);
                    goto <D.23559>;
                    <D.23560>:
                    D.23895 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
                    D.23896 = D.23895->func_;
                    retval.0 = D.23896 != 0B;
                    if (retval.0 != 0) goto <D.23897>; else goto <D.23898>;
                    <D.23897>:
                    D.23899 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
                    D.23900 = D.23899->func_;
                    D.23901 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
                    D.23902 = D.23901->data_;
                    D.23900 (D.23902);
                    goto <D.23903>;
                    <D.23898>:
                    <D.23903>:
                    std::_List_iterator<sigc::internal::trackable_callback>::operator++ (&i);
                    <D.23559>:
                    D.23893 = &this->callbacks_;
                    D.23561 = std::list<sigc::internal::trackable_callback>::end (D.23893);
                    try
                      {
                        retval.1 = std::_List_iterator<sigc::internal::trackable_callback>::operator!= (&i, &D.23561);
                      }
                    finally
                      {
                        D.23561 = {CLOBBER};
                      }
                    if (retval.1 != 0) goto <D.23560>; else goto <D.23562>;
                    <D.23562>:
                  }
                finally
                  {
                    i = {CLOBBER};
                  }
              }
            }
          }
        finally
          {
            D.23893 = &this->callbacks_;
            std::list<sigc::internal::trackable_callback>::~list (D.23893);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.23563>:
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::begin() [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::internal::trackable_callback>] (struct list * const this)
{
  struct iterator D.23908;
  struct iterator D.23683;
  struct _List_node_base * D.23909;

  D.23909 = this->D.7140._M_impl._M_node._M_next;
  std::_List_iterator<sigc::internal::trackable_callback>::_List_iterator (&D.23683, D.23909);
  try
    {
      D.23908 = D.23683;
      return D.23908;
    }
  finally
    {
      D.23683 = {CLOBBER};
    }
}


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


_Tp& std::_List_iterator<_Tp>::operator*() const [with _Tp = sigc::internal::trackable_callback; std::_List_iterator<_Tp>::reference = sigc::internal::trackable_callback&] (const struct _List_iterator * const this)
{
  struct trackable_callback & D.23912;
  struct _List_node_base * D.23913;

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


std::_List_iterator<_Tp>::_Self& std::_List_iterator<_Tp>::operator++() [with _Tp = sigc::internal::trackable_callback; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::internal::trackable_callback>] (struct _List_iterator * const this)
{
  struct _List_node_base * D.23915;
  struct _List_node_base * D.23916;
  struct _Self & D.23917;

  D.23915 = this->_M_node;
  D.23916 = D.23915->_M_next;
  this->_M_node = D.23916;
  D.23917 = this;
  return D.23917;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::end() [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::internal::trackable_callback>] (struct list * const this)
{
  struct iterator D.23919;
  struct iterator D.23685;
  struct _List_node_base * D.23920;

  D.23920 = &this->D.7140._M_impl._M_node;
  std::_List_iterator<sigc::internal::trackable_callback>::_List_iterator (&D.23685, D.23920);
  try
    {
      D.23919 = D.23685;
      return D.23919;
    }
  finally
    {
      D.23685 = {CLOBBER};
    }
}


bool std::_List_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = sigc::internal::trackable_callback; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::internal::trackable_callback>] (const struct _List_iterator * const this, const struct _Self & __x)
{
  bool D.23923;
  struct _List_node_base * D.23924;
  struct _List_node_base * D.23925;

  D.23924 = this->_M_node;
  D.23925 = __x->_M_node;
  D.23923 = D.23924 != D.23925;
  return D.23923;
}


std::list<sigc::internal::trackable_callback>::~list() (struct list * const this)
{
  struct _List_base * D.23927;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.23927 = &this->D.7140;
            std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::~_List_base (D.23927);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.7170>:
}


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

  {
    try
      {
        try
          {
            std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_clear (this);
          }
        finally
          {
            D.23929 = &this->_M_impl;
            std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_List_impl::~_List_impl (D.23929);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.23679>:
}


void std::_List_base<_Tp, _Alloc>::_M_clear() [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>] (struct _List_base * const this)
{
  struct trackable_callback * D.23932;
  struct trackable_callback * D.23933;
  struct _Tp_alloc_type D.23718;
  struct _List_node_base * D.23934;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.23691._M_next;
    D.23932 = &__tmp->_M_data;
    D.23933 = std::__addressof<sigc::internal::trackable_callback> (D.23932);
    D.23718 = std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::internal::trackable_callback>::destroy (&D.23718, D.23933);
      }
    finally
      {
        std::allocator<sigc::internal::trackable_callback>::~allocator (&D.23718);
        D.23718 = {CLOBBER};
      }
    std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_put_node (this, __tmp);
  }
  <D.23722>:
  D.23934 = &this->_M_impl._M_node;
  if (D.23934 != __cur) goto <D.23723>; else goto <D.23721>;
  <D.23721>:
}


_Tp* std::__addressof(_Tp&) [with _Tp = sigc::internal::trackable_callback] (struct trackable_callback & __r)
{
  struct trackable_callback * D.23935;

  D.23935 = __r;
  return D.23935;
}


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

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


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

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


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

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

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


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

  try
    {
      {

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


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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<sigc::internal::trackable_callback>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.23769>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.23944 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.23944);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


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

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


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

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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_List_node<sigc::internal::trackable_callback> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.23711>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.23947 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.23947);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


void sigc::internal::trackable_callback_list::add_callback(void*, sigc::internal::func_destroy_notify) (struct trackable_callback_list * const this, void * data, void * (*func_destroy_notify) (void *) func)
{
  bool D.23949;
  bool D.23950;
  struct trackable_callback D.23580;
  struct callback_list * D.23953;

  D.23949 = this->clearing_;
  D.23950 = ~D.23949;
  if (D.23950 != 0) goto <D.23951>; else goto <D.23952>;
  <D.23951>:
  sigc::internal::trackable_callback::trackable_callback (&D.23580, data, func);
  try
    {
      D.23953 = &this->callbacks_;
      std::list<sigc::internal::trackable_callback>::push_back (D.23953, &D.23580);
    }
  finally
    {
      D.23580 = {CLOBBER};
    }
  goto <D.23954>;
  <D.23952>:
  <D.23954>:
}


sigc::internal::trackable_callback::trackable_callback(void*, sigc::internal::func_destroy_notify) (struct trackable_callback * const this, void * data, void * (*func_destroy_notify) (void *) func)
{
  this->data_ = data;
  this->func_ = func;
}


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

  D.23956 = std::list<sigc::internal::trackable_callback>::end (this);
  std::list<sigc::internal::trackable_callback>::_M_insert (this, D.23956, __x);
}


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

  __tmp = std::list<sigc::internal::trackable_callback>::_M_create_node (this, __x);
  D.23957 = __position._M_node;
  D.23958 = &__tmp->D.23691;
  std::__detail::_List_node_base::_M_hook (D.23958, D.23957);
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::value_type = sigc::internal::trackable_callback] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.23960;
  struct trackable_callback * D.23961;
  struct trackable_callback * D.23962;
  struct _Tp_alloc_type D.23786;
  void * D.23963;
  struct _Node * D.23964;
  struct _Node * __p;

  D.23960 = &this->D.7140;
  __p = std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_get_node (D.23960);
  try
    {
      D.23961 = &__p->_M_data;
      D.23962 = std::__addressof<sigc::internal::trackable_callback> (D.23961);
      D.23960 = &this->D.7140;
      D.23786 = std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_get_Tp_allocator (D.23960); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::internal::trackable_callback>::construct (&D.23786, D.23962, __x);
        }
      finally
        {
          std::allocator<sigc::internal::trackable_callback>::~allocator (&D.23786);
          D.23786 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.23963 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.23963);
              D.23960 = &this->D.7140;
              std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_put_node (D.23960, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.23964 = __p;
  return D.23964;
}


std::_List_node<_Tp>* std::_List_base<_Tp, _Alloc>::_M_get_node() [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>] (struct _List_base * const this)
{
  struct _List_node * D.23970;
  struct _List_impl * D.23971;

  D.23971 = &this->_M_impl;
  D.23970 = __gnu_cxx::new_allocator<std::_List_node<sigc::internal::trackable_callback> >::allocate (D.23971, 1, 0B);
  return D.23970;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::internal::trackable_callback>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::internal::trackable_callback>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.6633)
{
  bool retval.2;
  long unsigned int D.23975;
  struct _List_node * D.23978;
  long unsigned int D.23979;

  D.23975 = __gnu_cxx::new_allocator<std::_List_node<sigc::internal::trackable_callback> >::max_size (this);
  retval.2 = D.23975 < __n;
  if (retval.2 != 0) goto <D.23976>; else goto <D.23977>;
  <D.23976>:
  std::__throw_bad_alloc ();
  <D.23977>:
  D.23979 = __n * 32;
  D.23978 = operator new (D.23979);
  return D.23978;
}


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

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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = sigc::internal::trackable_callback; __gnu_cxx::new_allocator<_Tp>::pointer = sigc::internal::trackable_callback*] (struct new_allocator * const this, struct trackable_callback * __p, const struct trackable_callback & __val)
{
  void * D.23839;
  void * D.23840;
  struct trackable_callback * iftmp.3;

  D.23839 = __p;
  D.23840 = operator new (16, D.23839);
  if (D.23840 != 0B) goto <D.23986>; else goto <D.23987>;
  <D.23986>:
  try
    {
      MEM[(struct trackable_callback *)D.23840] = *__val;
    }
  catch
    {
      operator delete (D.23840, D.23839);
    }
  iftmp.3 = D.23840;
  goto <D.23988>;
  <D.23987>:
  iftmp.3 = D.23840;
  <D.23988>:
}


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

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


void sigc::internal::trackable_callback_list::clear() (struct trackable_callback_list * const this)
{
  struct callback_list * D.23992;
  bool retval.4;
  struct trackable_callback & D.23994;
  void * (*<Tf7f>) (void *) D.23995;
  struct trackable_callback & D.23998;
  void * (*<Tf7f>) (void *) D.23999;
  struct trackable_callback & D.24000;
  void * D.24001;
  bool retval.5;
  struct iterator D.23586;

  this->clearing_ = 1;
  {
    struct iterator i;

    try
      {
        D.23992 = &this->callbacks_;
        i = std::list<sigc::internal::trackable_callback>::begin (D.23992);
        goto <D.23590>;
        <D.23589>:
        D.23994 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.23995 = D.23994->func_;
        retval.4 = D.23995 != 0B;
        if (retval.4 != 0) goto <D.23996>; else goto <D.23997>;
        <D.23996>:
        D.23998 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.23999 = D.23998->func_;
        D.24000 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.24001 = D.24000->data_;
        D.23999 (D.24001);
        goto <D.24002>;
        <D.23997>:
        <D.24002>:
        std::_List_iterator<sigc::internal::trackable_callback>::operator++ (&i);
        <D.23590>:
        D.23992 = &this->callbacks_;
        D.23586 = std::list<sigc::internal::trackable_callback>::end (D.23992);
        try
          {
            retval.5 = std::_List_iterator<sigc::internal::trackable_callback>::operator!= (&i, &D.23586);
          }
        finally
          {
            D.23586 = {CLOBBER};
          }
        if (retval.5 != 0) goto <D.23589>; else goto <D.23587>;
        <D.23587>:
      }
    finally
      {
        i = {CLOBBER};
      }
  }
  D.23992 = &this->callbacks_;
  std::list<sigc::internal::trackable_callback>::clear (D.23992);
  this->clearing_ = 0;
}


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

  D.24005 = &this->D.7140;
  std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_clear (D.24005);
  D.24005 = &this->D.7140;
  std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_init (D.24005);
}


void sigc::internal::trackable_callback_list::remove_callback(void*) (struct trackable_callback_list * const this, void * data)
{
  struct callback_list * D.24006;
  bool retval.6;
  bool iftmp.7;
  struct trackable_callback & D.24011;
  void * D.24012;
  struct trackable_callback & D.24014;
  void * (*<Tf7f>) (void *) D.24015;
  bool D.24019;
  struct trackable_callback & D.24022;
  struct iterator D.23599;
  bool retval.8;
  struct iterator D.23597;

  {
    struct iterator i;

    try
      {
        D.24006 = &this->callbacks_;
        i = std::list<sigc::internal::trackable_callback>::begin (D.24006);
        goto <D.23603>;
        <D.23602>:
        D.24011 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.24012 = D.24011->data_;
        if (D.24012 == data) goto <D.24013>; else goto <D.24009>;
        <D.24013>:
        D.24014 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.24015 = D.24014->func_;
        if (D.24015 != 0B) goto <D.24016>; else goto <D.24009>;
        <D.24016>:
        iftmp.7 = 1;
        goto <D.24010>;
        <D.24009>:
        iftmp.7 = 0;
        <D.24010>:
        retval.6 = iftmp.7;
        if (retval.6 != 0) goto <D.24017>; else goto <D.24018>;
        <D.24017>:
        D.24019 = this->clearing_;
        if (D.24019 != 0) goto <D.24020>; else goto <D.24021>;
        <D.24020>:
        D.24022 = std::_List_iterator<sigc::internal::trackable_callback>::operator* (&i);
        D.24022->func_ = 0B;
        goto <D.24023>;
        <D.24021>:
        D.24006 = &this->callbacks_;
        D.23599 = std::list<sigc::internal::trackable_callback>::erase (D.24006, i);
        <D.24023>:
        return;
        <D.24018>:
        std::_List_iterator<sigc::internal::trackable_callback>::operator++ (&i);
        <D.23603>:
        D.24006 = &this->callbacks_;
        D.23597 = std::list<sigc::internal::trackable_callback>::end (D.24006);
        try
          {
            retval.8 = std::_List_iterator<sigc::internal::trackable_callback>::operator!= (&i, &D.23597);
          }
        finally
          {
            D.23597 = {CLOBBER};
          }
        if (retval.8 != 0) goto <D.23602>; else goto <D.23600>;
        <D.23600>:
      }
    finally
      {
        i = {CLOBBER};
      }
  }
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::internal::trackable_callback>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.24029;
  struct _List_node_base * D.24030;
  struct _List_iterator D.24031;
  struct iterator D.24032;
  struct iterator __ret;

  try
    {
      D.24029 = __position._M_node;
      D.24030 = D.24029->_M_next;
      std::_List_iterator<sigc::internal::trackable_callback>::_List_iterator (&__ret, D.24030);
      D.24031 = std::_List_iterator<sigc::internal::trackable_callback>::_M_const_cast (&__position);
      std::list<sigc::internal::trackable_callback>::_M_erase (this, D.24031);
      D.24032 = __ret;
      return D.24032;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


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

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


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::internal::trackable_callback; _Alloc = std::allocator<sigc::internal::trackable_callback>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::internal::trackable_callback>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.24038;
  struct trackable_callback * D.24039;
  struct trackable_callback * D.24040;
  struct _Tp_alloc_type D.23732;
  struct _List_base * D.24041;
  struct _Node * __n;

  D.24038 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.24038);
  __n = __position._M_node;
  D.24039 = &__n->_M_data;
  D.24040 = std::__addressof<sigc::internal::trackable_callback> (D.24039);
  D.24041 = &this->D.7140;
  D.23732 = std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_get_Tp_allocator (D.24041); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::internal::trackable_callback>::destroy (&D.23732, D.24040);
    }
  finally
    {
      std::allocator<sigc::internal::trackable_callback>::~allocator (&D.23732);
      D.23732 = {CLOBBER};
    }
  D.24041 = &this->D.7140;
  std::_List_base<sigc::internal::trackable_callback, std::allocator<sigc::internal::trackable_callback> >::_M_put_node (D.24041, __n);
}


(static initializers for trackable.cc) ()
{
  __static_initialization_and_destruction_0 (1, 65535);
}


void __static_initialization_and_destruction_0(int, int) (int __initialize_p, int __priority)
{
  if (__initialize_p == 1) goto <D.24042>; else goto <D.24043>;
  <D.24042>:
  if (__priority == 65535) goto <D.24044>; else goto <D.24045>;
  <D.24044>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  goto <D.24046>;
  <D.24045>:
  <D.24046>:
  goto <D.24047>;
  <D.24043>:
  <D.24047>:
}


