Something::Something() (struct Something * const this)
{
  struct trackable * D.48973;
  struct type_signal_print * D.48974;
  const struct slot_type D.47407;
  struct bound_mem_functor1 D.47408;
  struct 
{
  void Something::<T8567> (struct Something *, int) * __pfn;
  long int __delta;
} D.48975;
  struct signal1 * D.48976;
  const int D.47409;
  struct slot * D.48977;
  struct slot_base * D.48978;
  const int D.47410;

  D.48973 = &this->D.47135;
  sigc::trackable::trackable (D.48973);
  try
    {
      this->_vptr.Something = &MEM[(void *)&_ZTV9Something + 16B];
      D.48974 = &this->signal_print;
      sigc::signal<void, int>::signal (D.48974);
      try
        {
          {
            struct iterator iter;

            try
              {
                D.48975.__pfn = 1B;
                D.48975.__delta = 0;
                D.47408 = sigc::mem_fun<int, void, Something, Something> (this, D.48975); [return slot optimization]
                try
                  {
                    sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_mem_functor1<void, Something, int> > (&D.47407, &D.47408);
                    try
                      {
                        D.48976 = &this->signal_print.D.47127;
                        iter = sigc::signal1<void, int, sigc::nil>::connect (D.48976, &D.47407);
                      }
                    finally
                      {
                        sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.47407);
                        D.47407 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.47408 = {CLOBBER};
                  }
                D.47409 = 2;
                try
                  {
                    D.48976 = &this->signal_print.D.47127;
                    sigc::signal1<void, int, sigc::nil>::emit (D.48976, &D.47409);
                  }
                finally
                  {
                    D.47409 = {CLOBBER};
                  }
                D.48977 = sigc::slot_iterator<sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::operator-> (&iter);
                D.48978 = &D.48977->D.46978.D.46936;
                sigc::slot_base::disconnect (D.48978);
                D.47410 = 3;
                try
                  {
                    D.48976 = &this->signal_print.D.47127;
                    sigc::signal1<void, int, sigc::nil>::emit (D.48976, &D.47410);
                  }
                finally
                  {
                    D.47410 = {CLOBBER};
                  }
              }
            finally
              {
                iter = {CLOBBER};
              }
          }
        }
      catch
        {
          D.48974 = &this->signal_print;
          sigc::signal<void, int>::~signal (D.48974);
        }
    }
  catch
    {
      D.48973 = &this->D.47135;
      sigc::trackable::~trackable (D.48973);
    }
}


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::signal() [with T_return = void; T_arg1 = int] (struct signal * const this)
{
  struct signal1 * D.48988;

  D.48988 = &this->D.47127;
  sigc::signal1<void, int, sigc::nil>::signal1 (D.48988);
  try
    {

    }
  catch
    {
      D.48988 = &this->D.47127;
      sigc::signal1<void, int, sigc::nil>::~signal1 (D.48988);
    }
}


sigc::signal1<T_return, T_arg1, T_accumulator>::signal1() [with T_return = void; T_arg1 = int; T_accumulator = sigc::nil] (struct signal1 * const this)
{
  struct signal_base * D.48989;

  D.48989 = &this->D.47102;
  sigc::signal_base::signal_base (D.48989);
  try
    {

    }
  catch
    {
      D.48989 = &this->D.47102;
      sigc::signal_base::~signal_base (D.48989);
    }
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = int; T_return = void; T_obj = Something; T_obj2 = Something] (struct Something * _A_obj, struct 
{
  void Something::<T8567> (struct Something *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<void, Something, int>::bound_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = Something; T_arg1 = int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void (Something::*)(int)] (struct bound_mem_functor1 * const this, struct Something * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.48992;
  struct limit_reference * D.48993;

  D.48992 = &this->D.47346;
  sigc::mem_functor1<void, Something, int>::mem_functor1 (D.48992, _A_func);
  D.48993 = &this->obj_;
  sigc::limit_reference<Something, true>::limit_reference (D.48993, _A_obj);
}


sigc::mem_functor1<T_arg1, T_return, T_obj>::mem_functor1(sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type) [with T_return = void; T_obj = Something; T_arg1 = int; sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type = void (Something::*)(int)] (struct mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::functor_base::functor_base() (struct functor_base * const this)
{

}


sigc::limit_reference<T_type, true>::limit_reference(T_type&) [with T_type = Something] (struct limit_reference * const this, struct Something & _A_target)
{
  struct trackable * D.48994;

  D.48994 = &_A_target->D.47135;
  this->visited = D.48994;
  this->invoked = _A_target;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, Something, int>; T_return = void; T_arg1 = int] (struct slot * const this, const struct bound_mem_functor1 & _A_func)
{
  struct slot1 * D.48995;

  D.48995 = &this->D.46978;
  sigc::slot1<void, int>::slot1<sigc::bound_mem_functor1<void, Something, int> > (D.48995, _A_func);
  try
    {

    }
  catch
    {
      D.48995 = &this->D.46978;
      sigc::slot1<void, int>::~slot1 (D.48995);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, Something, int>; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct bound_mem_functor1 & _A_func)
{
  void * D.48227;
  struct slot_base * D.48996;
  struct rep_type * D.48997;
  void * (*<T1192>) (void *) D.48998;

  D.48227 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, Something, int> >::typed_slot_rep (D.48227, _A_func);
    }
  catch
    {
      operator delete (D.48227);
    }
  D.48996 = &this->D.46936;
  sigc::slot_base::slot_base (D.48996, D.48227);
  try
    {
      D.48997 = this->D.46936.rep_;
      D.48998 = sigc::internal::slot_call1<sigc::bound_mem_functor1<void, Something, int>, void, int>::address ();
      D.48997->call_ = D.48998;
    }
  catch
    {
      D.48996 = &this->D.46936;
      sigc::slot_base::~slot_base (D.48996);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, Something, int>] (struct typed_slot_rep * const this, const struct bound_mem_functor1 & functor)
{
  struct slot_rep * D.49001;
  struct adaptor_type * D.49002;
  struct slot_do_bind D.48426;

  D.49001 = &this->D.48209;
  sigc::internal::slot_rep::slot_rep (D.49001, 0B, destroy, dup);
  try
    {
      D.49002 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >::adaptor_functor (D.49002, functor);
      D.49002 = &this->functor_;
      D.49001 = &this->D.48209;
      sigc::internal::slot_do_bind::slot_do_bind (&D.48426, D.49001);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > > (&D.48426, D.49002);
        }
      finally
        {
          D.48426 = {CLOBBER};
        }
    }
  catch
    {
      D.49001 = &this->D.48209;
      sigc::internal::slot_rep::~slot_rep (D.49001);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor1<void, Something, int>] (void * data)
{
  void * D.49005;
  void * D.48522;
  struct slot_rep * a_rep;

  a_rep = data;
  D.48522 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, Something, int> >::typed_slot_rep (D.48522, a_rep);
    }
  catch
    {
      operator delete (D.48522);
    }
  D.49005 = D.48522;
  return D.49005;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor1<void, Something, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1192>) (void *) D.49009;
  struct slot_rep * D.49010;
  struct adaptor_type * D.49011;
  struct slot_do_bind D.48772;

  D.49009 = cl->D.48209.call_;
  D.49010 = &this->D.48209;
  sigc::internal::slot_rep::slot_rep (D.49010, D.49009, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.49011 = &this->functor_;
      D.49010 = &this->D.48209;
      sigc::internal::slot_do_bind::slot_do_bind (&D.48772, D.49010);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > > (&D.48772, D.49011);
        }
      finally
        {
          D.48772 = {CLOBBER};
        }
    }
  catch
    {
      D.49010 = &this->D.48209;
      sigc::internal::slot_rep::~slot_rep (D.49010);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor1<void, Something, int>] (void * data)
{
  struct adaptor_type * D.49014;
  struct slot_do_unbind D.48507;
  void * D.49015;
  struct self * self_;

  self_ = data;
  self_->D.48209.call_ = 0B;
  self_->D.48209.destroy_ = 0B;
  D.49014 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.48507, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > > (&D.48507, D.49014);
    }
  finally
    {
      D.48507 = {CLOBBER};
    }
  D.49015 = 0B;
  return D.49015;
}


sigc::internal::slot_do_unbind::slot_do_unbind(sigc::internal::slot_rep*) (struct slot_do_unbind * const this, struct slot_rep * rep)
{
  this->rep_ = rep;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


sigc::internal::limit_derived_target<T_target*, T_action>::limit_derived_target(const T_action&) [with T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (struct limit_derived_target * const this, const struct slot_do_unbind & _A_action)
{
  this->action_ = *_A_action;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<void, Something, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.49019;

  D.49019 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor1<void, Something, int> > (_A_action, D.49019);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<void, Something, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<void, Something, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_obj = Something; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.49020;

  D.49020 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<Something, true> > (_A_action, D.49020);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::limit_reference<Something, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<Something, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = Something; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.49021;

  D.49021 = sigc::limit_reference<Something, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::trackable> (_A_action, D.49021);
}


const sigc::trackable& sigc::limit_reference<T_type, true>::visit() const [with T_type = Something] (const struct limit_reference * const this)
{
  const struct trackable & D.49022;

  D.49022 = this->visited;
  return D.49022;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::visitor<sigc::trackable>::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::trackable> (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::trackable; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct trackable & _A_type)
{
  sigc::internal::with_type_pointer<true, sigc::trackable, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_unbind * D.49024;

  D.49024 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.49024, _A_type);
}


void sigc::internal::slot_do_unbind::operator()(const sigc::trackable*) const (const struct slot_do_unbind * const this, const struct trackable * t)
{
  struct slot_rep * D.49025;

  D.49025 = this->rep_;
  sigc::trackable::remove_destroy_notify_callback (t, D.49025);
}


sigc::internal::slot_rep::slot_rep(sigc::internal::hook, sigc::internal::hook, sigc::internal::hook) (struct slot_rep * const this, void * (*hook) (void *) call__, void * (*hook) (void *) destroy__, void * (*hook) (void *) dup__)
{
  struct trackable * D.49026;

  D.49026 = &this->D.32352;
  sigc::trackable::trackable (D.49026);
  try
    {
      this->call_ = call__;
      this->destroy_ = destroy__;
      this->dup_ = dup__;
      this->cleanup_ = 0B;
      this->parent_ = 0B;
    }
  catch
    {
      D.49026 = &this->D.32352;
      sigc::trackable::~trackable (D.49026);
    }
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, Something, int>] (struct adaptor_functor * const this, const struct bound_mem_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


sigc::adaptor_base::adaptor_base() (struct adaptor_base * const this)
{
  sigc::functor_base::functor_base (this);
}


sigc::internal::slot_do_bind::slot_do_bind(sigc::internal::slot_rep*) (struct slot_do_bind * const this, struct slot_rep * rep)
{
  this->rep_ = rep;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


sigc::internal::limit_derived_target<T_target*, T_action>::limit_derived_target(const T_action&) [with T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (struct limit_derived_target * const this, const struct slot_do_bind & _A_action)
{
  this->action_ = *_A_action;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<void, Something, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.49028;

  D.49028 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor1<void, Something, int> > (_A_action, D.49028);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<void, Something, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<void, Something, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_obj = Something; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.49029;

  D.49029 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<Something, true> > (_A_action, D.49029);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::limit_reference<Something, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<Something, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = Something; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.49030;

  D.49030 = sigc::limit_reference<Something, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::trackable> (_A_action, D.49030);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::visitor<sigc::trackable>::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::trackable> (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::trackable; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct trackable & _A_type)
{
  sigc::internal::with_type_pointer<true, sigc::trackable, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_bind * D.49031;

  D.49031 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.49031, _A_type);
}


void sigc::internal::slot_do_bind::operator()(const sigc::trackable*) const (const struct slot_do_bind * const this, const struct trackable * t)
{
  struct slot_rep * D.49032;

  D.49032 = this->rep_;
  sigc::trackable::add_destroy_notify_callback (t, D.49032, notify);
}


sigc::internal::slot_rep::~slot_rep() (struct slot_rep * const this)
{
  struct trackable * D.49033;

  {
    try
      {
        try
          {
            sigc::internal::slot_rep::destroy (this);
          }
        finally
          {
            D.49033 = &this->D.32352;
            sigc::trackable::~trackable (D.49033);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.32366>:
}


void sigc::internal::slot_rep::destroy() (struct slot_rep * const this)
{
  void * (*<T1192>) (void *) D.49036;

  D.49036 = this->destroy_;
  if (D.49036 != 0B) goto <D.49037>; else goto <D.49038>;
  <D.49037>:
  D.49036 = this->destroy_;
  D.49036 (this);
  goto <D.49039>;
  <D.49038>:
  <D.49039>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::bound_mem_functor1<void, Something, int>; T_return = void; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.49040;

  D.49040 = call_it;
  return D.49040;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::bound_mem_functor1<void, Something, int>; T_return = void; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  struct adaptor_type * D.49042;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.49042 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<void, Something, int> >::operator()<const int&> (D.49042, a_1);
  return;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::bound_mem_functor1<void, Something, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  struct bound_mem_functor1 * D.49044;

  D.49044 = &this->functor_;
  sigc::bound_mem_functor1<void, Something, int>::operator() (D.49044, _A_arg1);
  return;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = Something; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  const struct limit_reference * D.49046;
  struct Something & D.49047;
  void Something::<T8567> (struct Something *, int) * iftmp.0;
  void Something::<T8567> (struct Something *, int) * D.49049;
  long int D.49050;
  long int D.49051;
  long int D.49055;
  sizetype D.49056;
  struct Something * D.49057;
  int (*__vtbl_ptr_type) () * D.49058;
  long int D.49059;
  sizetype D.49060;
  int (*__vtbl_ptr_type) () * D.49061;
  int D.49062;

  D.49046 = &this->obj_;
  D.49047 = sigc::limit_reference<Something, true>::invoke (D.49046);
  D.49049 = this->D.47346.func_ptr_.__pfn;
  D.49050 = (long int) D.49049;
  D.49051 = D.49050 & 1;
  if (D.49051 == 0) goto <D.49052>; else goto <D.49053>;
  <D.49052>:
  iftmp.0 = this->D.47346.func_ptr_.__pfn;
  goto <D.49054>;
  <D.49053>:
  D.49055 = this->D.47346.func_ptr_.__delta;
  D.49056 = (sizetype) D.49055;
  D.49057 = D.49047 + D.49056;
  D.49058 = MEM[(int (*__vtbl_ptr_type) () * *)D.49057];
  D.49049 = this->D.47346.func_ptr_.__pfn;
  D.49050 = (long int) D.49049;
  D.49059 = D.49050 + -1;
  D.49060 = (sizetype) D.49059;
  D.49061 = D.49058 + D.49060;
  iftmp.0 = *D.49061;
  <D.49054>:
  D.49062 = *_A_a1;
  D.49055 = this->D.47346.func_ptr_.__delta;
  D.49056 = (sizetype) D.49055;
  D.49057 = D.49047 + D.49056;
  iftmp.0 (D.49057, D.49062);
  return;
}


T_type& sigc::limit_reference<T_type, true>::invoke() const [with T_type = Something] (const struct limit_reference * const this)
{
  struct Something & D.49064;

  D.49064 = this->invoked;
  return D.49064;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = void; T_arg1 = int; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.49066;
  struct iterator D.47627;
  struct iterator_type D.47626;
  const struct slot_base * D.49067;
  struct signal_base * D.49068;

  D.49067 = &slot_->D.46978.D.46936;
  D.49068 = &this->D.47102;
  D.47626 = sigc::signal_base::connect (D.49068, D.49067);
  try
    {
      sigc::slot_iterator<sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.47627, &D.47626);
      try
        {
          D.49066 = D.47627;
          return D.49066;
        }
      finally
        {
          D.47627 = {CLOBBER};
        }
    }
  finally
    {
      D.47626 = {CLOBBER};
    }
}


sigc::slot_iterator<T_slot>::slot_iterator(const iterator_type&) [with T_slot = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; sigc::slot_iterator<T_slot>::iterator_type = std::_List_iterator<sigc::slot_base>] (struct slot_iterator * const this, const struct iterator_type & i)
{
  this->i_ = MEM[(const struct _List_iterator &)i];
}


T_slot* sigc::slot_iterator<T_slot>::operator->() const [with T_slot = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; sigc::slot_iterator<T_slot>::pointer = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>*] (const struct slot_iterator * const this)
{
  struct slot * D.49072;

  D.49072 = sigc::slot_iterator<sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::operator* (this);
  return D.49072;
}


T_slot& sigc::slot_iterator<T_slot>::operator*() const [with T_slot = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; sigc::slot_iterator<T_slot>::reference = sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&] (const struct slot_iterator * const this)
{
  struct slot & D.49075;
  const struct iterator_type * D.49076;

  D.49076 = &this->i_;
  D.49075 = std::_List_iterator<sigc::slot_base>::operator* (D.49076);
  return D.49075;
}


_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.49078;
  struct _List_node_base * D.49079;

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


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::emit(typename sigc::type_trait<T_derived>::take) const [with T_return = void; T_arg1 = int; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = void; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  struct signal_impl * D.49081;

  D.49081 = this->D.47102.impl_;
  sigc::internal::signal_emit1<void, int, sigc::nil>::emit (D.49081, _A_a1);
  return;
}


static sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_base>::take) [with T_arg1 = int; sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type = void; typename sigc::type_trait<T_base>::take = const int&] (struct signal_impl * impl, const int & _A_a1)
{
  bool retval.1;
  bool iftmp.2;
  struct list * D.49089;
  bool D.49090;
  struct iterator D.48236;
  bool retval.3;
  bool iftmp.4;
  const struct slot_base * D.49098;
  bool D.49099;
  const struct slot_base * D.49101;
  bool D.49102;
  const struct slot_base * D.49105;
  struct rep_type * D.49106;
  void * (*<T1192>) (void *) D.49107;
  const struct slot_base * D.49108;
  struct rep_type * D.49109;
  bool retval.5;
  const struct _Self D.48239;
  struct iterator D.48238;
  struct signal_exec exec;
  struct temp_slot_list slots;

  try
    {
      if (impl == 0B) goto <D.49085>; else goto <D.49088>;
      <D.49088>:
      D.49089 = &impl->slots_;
      D.49090 = std::list<sigc::slot_base>::empty (D.49089);
      if (D.49090 != 0) goto <D.49085>; else goto <D.49086>;
      <D.49085>:
      iftmp.2 = 1;
      goto <D.49087>;
      <D.49086>:
      iftmp.2 = 0;
      <D.49087>:
      retval.1 = iftmp.2;
      if (retval.1 != 0) goto <D.49091>; else goto <D.49092>;
      <D.49091>:
      return;
      <D.49092>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.49089 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.49089);
          try
            {
              {
                struct iterator_type it;

                try
                  {
                    D.48236 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.48236);
                      }
                    finally
                      {
                        D.48236 = {CLOBBER};
                      }
                    goto <D.48243>;
                    <D.48242>:
                    D.49098 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.49099 = sigc::slot_base::empty (D.49098);
                    if (D.49099 != 0) goto <D.49095>; else goto <D.49100>;
                    <D.49100>:
                    D.49101 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.49102 = sigc::slot_base::blocked (D.49101);
                    if (D.49102 != 0) goto <D.49095>; else goto <D.49096>;
                    <D.49095>:
                    iftmp.4 = 1;
                    goto <D.49097>;
                    <D.49096>:
                    iftmp.4 = 0;
                    <D.49097>:
                    retval.3 = iftmp.4;
                    if (retval.3 != 0) goto <D.49103>; else goto <D.49104>;
                    <D.49103>:
                    goto <D.48241>;
                    <D.49104>:
                    D.49105 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.49106 = D.49105->rep_;
                    D.49107 = D.49106->call_;
                    D.49108 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.49109 = D.49108->rep_;
                    D.49107 (D.49109, _A_a1);
                    <D.48241>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.48243>:
                    D.48238 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.48239, &D.48238);
                        try
                          {
                            retval.5 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.48239);
                          }
                        finally
                          {
                            D.48239 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.48238 = {CLOBBER};
                      }
                    if (retval.5 != 0) goto <D.48242>; else goto <D.48240>;
                    <D.48240>:
                  }
                finally
                  {
                    it = {CLOBBER};
                  }
              }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
      slots = {CLOBBER};
    }
}


bool std::list<_Tp, _Alloc>::empty() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (const struct list * const this)
{
  bool D.49122;
  struct _List_node_base * D.49123;
  const struct _List_node_base * D.49124;

  D.49123 = this->D.34095._M_impl._M_node._M_next;
  D.49124 = &this->D.34095._M_impl._M_node;
  D.49122 = D.49123 == D.49124;
  return D.49122;
}


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.49126;

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.49127;
  unsigned short D.49128;
  unsigned short D.49129;
  short int D.49130;
  short int D.49131;
  unsigned short D.49132;
  unsigned short D.49133;
  short int D.49134;

  D.49127 = this->ref_count_;
  D.49128 = (unsigned short) D.49127;
  D.49129 = D.49128 + 1;
  D.49130 = (short int) D.49129;
  this->ref_count_ = D.49130;
  D.49131 = this->exec_count_;
  D.49132 = (unsigned short) D.49131;
  D.49133 = D.49132 + 1;
  D.49134 = (short int) D.49133;
  this->exec_count_ = D.49134;
}


sigc::internal::temp_slot_list::temp_slot_list(sigc::internal::temp_slot_list::slot_list&) (struct temp_slot_list * const this, struct slot_list & slots)
{
  struct iterator * D.49135;
  struct slot_base D.34316;
  struct slot_list & D.49136;
  struct _List_iterator D.49137;

  this->slots_ = slots;
  D.49135 = &this->placeholder;
  std::_List_iterator<sigc::slot_base>::_List_iterator (D.49135);
  sigc::slot_base::slot_base (&D.34316);
  try
    {
      D.49136 = this->slots_;
      D.49137 = std::list<sigc::slot_base>::end (D.49136);
      D.49136 = this->slots_;
      this->placeholder = std::list<sigc::slot_base>::insert (D.49136, D.49137, &D.34316);
    }
  finally
    {
      sigc::slot_base::~slot_base (&D.34316);
      D.34316 = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_List_iterator() [with _Tp = sigc::slot_base] (struct _List_iterator * const this)
{
  this->_M_node = 0B;
}


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.49139;
  struct iterator D.47541;
  struct _List_node_base * D.49140;

  D.49140 = &this->D.34095._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.47541, D.49140);
  try
    {
      D.49139 = D.47541;
      return D.49139;
    }
  finally
    {
      D.47541 = {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;
}


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.47549;
  struct _List_node_base * D.49143;
  struct _List_node_base * D.49144;
  struct iterator D.49145;
  struct iterator D.47550;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.47549 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.49143 = D.47549._M_node;
  D.49144 = &__tmp->D.47546;
  std::__detail::_List_node_base::_M_hook (D.49144, D.49143);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.47550, __tmp);
  try
    {
      D.49145 = D.47550;
      return D.49145;
    }
  finally
    {
      D.47550 = {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.49149;
  struct slot_base * D.49150;
  struct slot_base * D.49151;
  struct _Tp_alloc_type D.47682;
  void * D.49152;
  struct _Node * D.49153;
  struct _Node * __p;

  D.49149 = &this->D.34095;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.49149);
  try
    {
      D.49150 = &__p->_M_data;
      D.49151 = std::__addressof<sigc::slot_base> (D.49150);
      D.49149 = &this->D.34095;
      D.47682 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.49149); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.47682, D.49151, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.47682);
          D.47682 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.49152 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.49152);
              D.49149 = &this->D.34095;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.49149, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.49153 = __p;
  return D.49153;
}


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.49160;
  struct _List_impl * D.49161;

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


_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.33588)
{
  bool retval.6;
  long unsigned int D.49165;
  struct _List_node * D.49168;
  long unsigned int D.49169;

  D.49165 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.6 = D.49165 < __n;
  if (retval.6 != 0) goto <D.49166>; else goto <D.49167>;
  <D.49166>:
  std::__throw_bad_alloc ();
  <D.49167>:
  D.49169 = __n * 32;
  D.49168 = operator new (D.49169);
  return D.49168;
}


__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.49172;
  void * D.49173;

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


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

  D.49175 = __r;
  return D.49175;
}


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.49178;

  D.49178 = 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.49178);
  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.49180;

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


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.48316)
{
  void * D.49182;

  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.49182 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.49182);
          
        }
    }
}


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

  try
    {
      {

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


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.48354;
  void * D.48355;
  struct slot_base * iftmp.7;

  D.48354 = __p;
  D.48355 = operator new (16, D.48354);
  if (D.48355 != 0B) goto <D.49185>; else goto <D.49186>;
  <D.49185>:
  try
    {
      sigc::slot_base::slot_base (D.48355, __val);
    }
  catch
    {
      operator delete (D.48355, D.48354);
    }
  iftmp.7 = D.48355;
  goto <D.49187>;
  <D.49186>:
  iftmp.7 = D.48355;
  <D.49187>:
}


void* operator new(std::size_t, void*) (size_t D.7606, void * __p)
{
  void * D.49189;
  void * D.49190;

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


void operator delete(void*, void*) (void * D.7614, void * D.7615)
{
  void * D.49192;

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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.49195;

  D.49195 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.49195, __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.33592)
{
  operator delete (__p);
}


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.49196;

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


sigc::internal::temp_slot_list::iterator sigc::internal::temp_slot_list::begin() (struct temp_slot_list * const this)
{
  struct iterator D.49198;
  struct slot_list & D.49199;

  D.49199 = this->slots_;
  D.49198 = std::list<sigc::slot_base>::begin (D.49199);
  return D.49198;
}


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.49201;
  struct iterator D.47557;
  struct _List_node_base * D.49202;

  D.49202 = this->D.34095._M_impl._M_node._M_next;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.47557, D.49202);
  try
    {
      D.49201 = D.47557;
      return D.49201;
    }
  finally
    {
      D.47557 = {CLOBBER};
    }
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.49205;
  bool iftmp.8;
  struct rep_type * D.49210;
  void * (*<T1192>) (void *) D.49212;

  D.49210 = this->rep_;
  if (D.49210 == 0B) goto <D.49207>; else goto <D.49211>;
  <D.49211>:
  D.49210 = this->rep_;
  D.49212 = D.49210->call_;
  if (D.49212 == 0B) goto <D.49207>; else goto <D.49208>;
  <D.49207>:
  iftmp.8 = 1;
  goto <D.49209>;
  <D.49208>:
  iftmp.8 = 0;
  <D.49209>:
  D.49205 = iftmp.8;
  return D.49205;
}


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

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


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.49216;
  const struct _List_node_base * D.49217;
  const struct slot_base * D.49218;

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


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

  D.49220 = __r;
  return D.49220;
}


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.49222;
  struct _List_node_base * D.49223;
  struct _Self & D.49224;

  D.49222 = this->_M_node;
  D.49223 = D.49222->_M_next;
  this->_M_node = D.49223;
  D.49224 = this;
  return D.49224;
}


sigc::internal::temp_slot_list::iterator sigc::internal::temp_slot_list::end() (struct temp_slot_list * const this)
{
  struct iterator D.49226;

  D.49226 = this->placeholder;
  return D.49226;
}


std::_List_const_iterator<_Tp>::_List_const_iterator(const iterator&) [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::iterator = std::_List_iterator<sigc::slot_base>] (struct _List_const_iterator * const this, const struct iterator & __x)
{
  struct _List_node_base * D.49228;

  D.49228 = __x->_M_node;
  this->_M_node = D.49228;
}


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.49229;
  const struct _List_node_base * D.49230;
  const struct _List_node_base * D.49231;

  D.49230 = this->_M_node;
  D.49231 = __x->_M_node;
  D.49229 = D.49230 != D.49231;
  return D.49229;
}


sigc::internal::temp_slot_list::~temp_slot_list() (struct temp_slot_list * const this)
{
  struct iterator D.34324;
  struct slot_list & D.49233;

  {
    try
      {
        D.49233 = this->slots_;
        D.34324 = std::list<sigc::slot_base>::erase (D.49233, this->placeholder);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.34326>:
}


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.49235;
  struct _List_node_base * D.49236;
  struct _List_iterator D.49237;
  struct iterator D.49238;
  struct iterator __ret;

  try
    {
      D.49235 = __position._M_node;
      D.49236 = D.49235->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.49236);
      D.49237 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.49237);
      D.49238 = __ret;
      return D.49238;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


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.49242;
  struct slot_base * D.49243;
  struct slot_base * D.49244;
  struct _Tp_alloc_type D.47688;
  struct _List_base * D.49245;
  struct _Node * __n;

  D.49242 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.49242);
  __n = __position._M_node;
  D.49243 = &__n->_M_data;
  D.49244 = std::__addressof<sigc::slot_base> (D.49243);
  D.49245 = &this->D.34095;
  D.47688 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.49245); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.47688, D.49244);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.47688);
      D.47688 = {CLOBBER};
    }
  D.49245 = &this->D.34095;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.49245, __n);
}


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);
}


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

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.9;
  short int D.49250;
  unsigned short D.49251;
  unsigned short D.49252;
  short int D.49253;
  bool retval.10;
  bool iftmp.11;
  short int D.49264;
  unsigned short D.49265;
  unsigned short D.49266;
  short int D.49267;
  bool D.49269;

  D.49250 = this->ref_count_;
  D.49251 = (unsigned short) D.49250;
  D.49252 = D.49251 + 65535;
  D.49253 = (short int) D.49252;
  this->ref_count_ = D.49253;
  D.49250 = this->ref_count_;
  retval.9 = D.49250 == 0;
  if (retval.9 != 0) goto <D.49254>; else goto <D.49255>;
  <D.49254>:
  if (this != 0B) goto <D.49256>; else goto <D.49257>;
  <D.49256>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.49258>;
  <D.49257>:
  <D.49258>:
  goto <D.49259>;
  <D.49255>:
  D.49264 = this->exec_count_;
  D.49265 = (unsigned short) D.49264;
  D.49266 = D.49265 + 65535;
  D.49267 = (short int) D.49266;
  this->exec_count_ = D.49267;
  D.49264 = this->exec_count_;
  if (D.49264 == 0) goto <D.49268>; else goto <D.49262>;
  <D.49268>:
  D.49269 = this->deferred_;
  if (D.49269 != 0) goto <D.49270>; else goto <D.49262>;
  <D.49270>:
  iftmp.11 = 1;
  goto <D.49263>;
  <D.49262>:
  iftmp.11 = 0;
  <D.49263>:
  retval.10 = iftmp.11;
  if (retval.10 != 0) goto <D.49271>; else goto <D.49272>;
  <D.49271>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.49273>;
  <D.49272>:
  <D.49273>:
  <D.49259>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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.49278;

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


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.49281;
  struct slot_base * D.49282;
  struct _Tp_alloc_type D.47671;
  struct _List_node_base * D.49283;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.47546._M_next;
    D.49281 = &__tmp->_M_data;
    D.49282 = std::__addressof<sigc::slot_base> (D.49281);
    D.47671 = 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.47671, D.49282);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.47671);
        D.47671 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.47675>:
  D.49283 = &this->_M_impl._M_node;
  if (D.49283 != __cur) goto <D.47676>; else goto <D.47674>;
  <D.47674>:
}


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.47528>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot() (struct slot * const this)
{
  struct slot1 * D.49287;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49287 = &this->D.46978;
            sigc::slot1<void, int>::~slot1 (D.49287);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47389>:
}


sigc::slot1<void, int>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.49289;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49289 = &this->D.46936;
            sigc::slot_base::~slot_base (D.49289);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47384>:
}


sigc::signal<void, int>::~signal() (struct signal * const this)
{
  struct signal1 * D.49291;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49291 = &this->D.47127;
            sigc::signal1<void, int, sigc::nil>::~signal1 (D.49291);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47182>:
}


sigc::signal1<void, int, sigc::nil>::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.49293;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49293 = &this->D.47102;
            sigc::signal_base::~signal_base (D.49293);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47177>:
}


virtual void Something::on_print(int) (struct Something * const this, int a)
{
  struct basic_ostream & D.49295;
  struct basic_ostream & D.49296;

  D.49295 = std::operator<< <std::char_traits<char> > (&cout, "on_print recieved: ");
  D.49296 = std::basic_ostream<char>::operator<< (D.49295, a);
  std::basic_ostream<char>::operator<< (D.49296, endl);
}


std::basic_ostream<_CharT, _Traits>& std::endl(std::basic_ostream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os)
{
  struct basic_ostream & D.49299;
  int (*__vtbl_ptr_type) () * D.49300;
  int (*__vtbl_ptr_type) () * D.49301;
  long int D.49302;
  sizetype D.49303;
  struct basic_ios * D.49304;
  char D.49305;
  int D.49306;
  struct basic_ostream & D.49307;

  D.49300 = __os->_vptr.basic_ostream;
  D.49301 = D.49300 + 18446744073709551592;
  D.49302 = MEM[(long int *)D.49301];
  D.49303 = (sizetype) D.49302;
  D.49304 = __os + D.49303;
  D.49305 = std::basic_ios<char>::widen (D.49304, 10);
  D.49306 = (int) D.49305;
  D.49307 = std::basic_ostream<char>::put (__os, D.49306);
  D.49299 = std::flush<char, std::char_traits<char> > (D.49307);
  return D.49299;
}


std::basic_ios<_CharT, _Traits>::char_type std::basic_ios<_CharT, _Traits>::widen(char) const [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ios<_CharT, _Traits>::char_type = char] (const struct basic_ios * const this, char __c)
{
  char_type D.49312;
  int D.49313;
  const struct __ctype_type * D.49314;
  const struct ctype & D.49315;

  D.49313 = (int) __c;
  D.49314 = this->_M_ctype;
  D.49315 = std::__check_facet<std::ctype<char> > (D.49314);
  D.49312 = std::ctype<char>::widen (D.49315, D.49313);
  return D.49312;
}


const _Facet& std::__check_facet(const _Facet*) [with _Facet = std::ctype<char>] (const struct ctype * __f)
{
  const struct ctype & D.49321;

  if (__f == 0B) goto <D.49319>; else goto <D.49320>;
  <D.49319>:
  std::__throw_bad_cast ();
  <D.49320>:
  D.49321 = __f;
  return D.49321;
}


std::ctype<char>::char_type std::ctype<char>::widen(char) const (const struct ctype * const this, char __c)
{
  char D.49323;
  char_type D.49326;
  unsigned char __c.12;
  int D.49328;
  int (*__vtbl_ptr_type) () * D.49329;
  int (*__vtbl_ptr_type) () * D.49330;
  int (*__vtbl_ptr_type) () D.49331;
  int D.49332;

  D.49323 = this->_M_widen_ok;
  if (D.49323 != 0) goto <D.49324>; else goto <D.49325>;
  <D.49324>:
  __c.12 = (unsigned char) __c;
  D.49328 = (int) __c.12;
  D.49326 = this->_M_widen[D.49328];
  return D.49326;
  <D.49325>:
  std::ctype<char>::_M_widen_init (this);
  D.49329 = this->D.15977._vptr.facet;
  D.49330 = D.49329 + 48;
  D.49331 = *D.49330;
  D.49332 = (int) __c;
  D.49326 = OBJ_TYPE_REF(D.49331;(const struct ctype)this->6) (this, D.49332);
  return D.49326;
}


virtual std::ctype<char>::char_type std::ctype<char>::do_widen(char) const (const struct ctype * const this, char __c)
{
  char_type D.49335;

  D.49335 = __c;
  return D.49335;
}


std::basic_ostream<_CharT, _Traits>& std::flush(std::basic_ostream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os)
{
  struct basic_ostream & D.49337;

  D.49337 = std::basic_ostream<char>::flush (__os);
  return D.49337;
}


std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with _Traits = std::char_traits<char>] (struct basic_ostream & __out, const char * __s)
{
  int (*__vtbl_ptr_type) () * D.49342;
  int (*__vtbl_ptr_type) () * D.49343;
  long int D.49344;
  sizetype D.49345;
  struct basic_ios * D.49346;
  long unsigned int D.49348;
  long int D.49349;
  struct basic_ostream & D.49350;

  if (__s == 0B) goto <D.49340>; else goto <D.49341>;
  <D.49340>:
  D.49342 = __out->_vptr.basic_ostream;
  D.49343 = D.49342 + 18446744073709551592;
  D.49344 = MEM[(long int *)D.49343];
  D.49345 = (sizetype) D.49344;
  D.49346 = __out + D.49345;
  std::basic_ios<char>::setstate (D.49346, 1);
  goto <D.49347>;
  <D.49341>:
  D.49348 = std::char_traits<char>::length (__s);
  D.49349 = (long int) D.49348;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.49349);
  <D.49347>:
  D.49350 = __out;
  return D.49350;
}


void std::basic_ios<_CharT, _Traits>::setstate(std::ios_base::iostate) [with _CharT = char; _Traits = std::char_traits<char>; std::ios_base::iostate = std::_Ios_Iostate] (struct basic_ios * const this, iostate __state)
{
  _Ios_Iostate D.49352;
  _Ios_Iostate D.49353;

  D.49352 = std::basic_ios<char>::rdstate (this);
  D.49353 = std::operator| (D.49352, __state);
  std::basic_ios<char>::clear (this, D.49353);
}


std::ios_base::iostate std::basic_ios<_CharT, _Traits>::rdstate() const [with _CharT = char; _Traits = std::char_traits<char>; std::ios_base::iostate = std::_Ios_Iostate] (const struct basic_ios * const this)
{
  iostate D.49355;

  D.49355 = this->D.19008._M_streambuf_state;
  return D.49355;
}


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.49357;
  int __a.13;
  int __b.14;
  int D.49360;

  __a.13 = (int) __a;
  __b.14 = (int) __b;
  D.49360 = __a.13 | __b.14;
  D.49357 = (_Ios_Iostate) D.49360;
  return D.49357;
}


static std::size_t std::char_traits<char>::length(const char_type*) (const char_type * __s)
{
  size_t D.49362;

  D.49362 = __builtin_strlen (__s);
  return D.49362;
}


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ostream_type& (*)(std::basic_ostream<_CharT, _Traits>::__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, struct __ostream_type & (*<T3460>) (struct __ostream_type &) __pf)
{
  struct __ostream_type & D.49364;

  D.49364 = __pf (this);
  return D.49364;
}


int main() ()
{
  int D.49367;

  {
    struct Something something;

    try
      {
        Something::Something (&something);
        try
          {
            D.49367 = 0;
            return D.49367;
          }
        finally
          {
            Something::~Something (&something);
          }
      }
    finally
      {
        something = {CLOBBER};
      }
  }
  D.49367 = 0;
  return D.49367;
}


Something::~Something() (struct Something * const this)
{
  struct type_signal_print * D.49372;
  struct trackable * D.49373;

  {
    this->_vptr.Something = &MEM[(void *)&_ZTV9Something + 16B];
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.49372 = &this->signal_print;
                sigc::signal<void, int>::~signal (D.49372);
              }
          }
        finally
          {
            D.49373 = &this->D.47135;
            sigc::trackable::~trackable (D.49373);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47432>:
}


(static initializers for member_method.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.49376>; else goto <D.49377>;
  <D.49376>:
  if (__priority == 65535) goto <D.49378>; else goto <D.49379>;
  <D.49378>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  goto <D.49380>;
  <D.49379>:
  <D.49380>:
  goto <D.49381>;
  <D.49377>:
  <D.49381>:
}


