int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.52390;
  int D.52393;
  int iftmp.1;
  bool D.52395;
  void * test.2;
  struct RefPtr * D.52399;
  struct Action * D.52400;
  struct Test * test.3;
  const struct string D.50584;
  struct allocator D.50583;
  int iftmp.4;
  bool D.52406;

  {
    struct TestUtilities * util;
    struct Test * test;

    util = TestUtilities::get_instance ();
    D.52390 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.52390;
    if (retval.0 != 0) goto <D.52391>; else goto <D.52392>;
    <D.52391>:
    D.52395 = TestUtilities::get_result_and_delete_instance ();
    if (D.52395 != 0) goto <D.52396>; else goto <D.52397>;
    <D.52396>:
    iftmp.1 = 0;
    goto <D.52398>;
    <D.52397>:
    iftmp.1 = 1;
    <D.52398>:
    D.52393 = iftmp.1;
    return D.52393;
    <D.52392>:
    test.2 = operator new (16);
    try
      {
        {anonymous}::Test::Test (test.2);
      }
    catch
      {
        operator delete (test.2);
      }
    test = test.2;
    D.52399 = &test->action;
    D.52400 = Glib::RefPtr<{anonymous}::Action>::operator-> (D.52399);
    {anonymous}::Action::emit_sig1 (D.52400, 23);
    test.3 = test;
    if (test.3 != 0B) goto <D.52402>; else goto <D.52403>;
    <D.52402>:
    {anonymous}::Test::~Test (test.3);
    operator delete (test.3);
    goto <D.52404>;
    <D.52403>:
    <D.52404>:
    std::allocator<char>::allocator (&D.50583);
    try
      {
        std::basic_string<char>::basic_string (&D.50584, "new Test; Test::on_sig1, n=23; delete Test; ", &D.50583);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.50584);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.50584);
            D.50584 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.50583);
        D.50583 = {CLOBBER};
      }
    D.52406 = TestUtilities::get_result_and_delete_instance ();
    if (D.52406 != 0) goto <D.52407>; else goto <D.52408>;
    <D.52407>:
    iftmp.4 = 0;
    goto <D.52409>;
    <D.52408>:
    iftmp.4 = 1;
    <D.52409>:
    D.52393 = iftmp.4;
    return D.52393;
  }
  D.52393 = 0;
  return D.52393;
}


{anonymous}::Test::Test() (struct Test * const this)
{
  struct trackable * D.52420;
  void * D.50551;
  struct RefPtr * D.52421;
  struct iterator D.50552;
  const struct slot_type D.50553;
  struct bind_functor D.50554;
  struct RefPtr D.50556;
  struct bound_mem_functor2 D.50555;
  struct 
{
  void Test::<T8cc7> (struct Test *, int, struct RefPtr) * __pfn;
  long int __delta;
} D.52422;
  struct Action * D.52423;
  struct signal & D.52424;
  struct signal1 * D.52425;

  D.52420 = &this->D.49422;
  sigc::trackable::trackable (D.52420);
  try
    {
      D.50551 = operator new (32);
      try
        {
          {anonymous}::Action::Action (D.50551);
        }
      catch
        {
          operator delete (D.50551);
        }
      D.52421 = &this->action;
      Glib::RefPtr<{anonymous}::Action>::RefPtr (D.52421, D.50551);
      try
        {
          std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "new Test; ");
          D.52421 = &this->action;
          Glib::RefPtr<{anonymous}::Action>::RefPtr (&D.50556, D.52421);
          try
            {
              D.52422.__pfn = on_sig1;
              D.52422.__delta = 0;
              D.50555 = sigc::mem_fun<int, Glib::RefPtr<{anonymous}::Action>, void, {anonymous}::Test, {anonymous}::Test> (this, D.52422); [return slot optimization]
              try
                {
                  D.50554 = sigc::bind<Glib::RefPtr<{anonymous}::Action>, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > (&D.50555, &D.50556); [return slot optimization]
                  try
                    {
                      sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.50553, &D.50554);
                      try
                        {
                          D.52421 = &this->action;
                          D.52423 = Glib::RefPtr<{anonymous}::Action>::operator-> (D.52421);
                          D.52424 = {anonymous}::Action::signal_sig1 (D.52423);
                          D.52425 = &D.52424->D.49208;
                          D.50552 = sigc::signal1<void, int, sigc::nil>::connect (D.52425, &D.50553);
                        }
                      finally
                        {
                          sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.50553);
                          D.50553 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (&D.50554);
                      D.50554 = {CLOBBER};
                    }
                }
              finally
                {
                  D.50555 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<{anonymous}::Action>::~RefPtr (&D.50556);
              D.50556 = {CLOBBER};
            }
        }
      catch
        {
          D.52421 = &this->action;
          Glib::RefPtr<{anonymous}::Action>::~RefPtr (D.52421);
        }
    }
  catch
    {
      D.52420 = &this->D.49422;
      sigc::trackable::~trackable (D.52420);
    }
}


void {anonymous}::Test::on_sig1(int, Glib::RefPtr<{anonymous}::Action>) (struct Test * const this, int n, struct RefPtr & restrict D.49284)
{
  struct basic_ostream & D.52434;
  struct basic_ostream & D.52435;

  D.52434 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Test::on_sig1, n=");
  D.52435 = std::basic_ostream<char>::operator<< (D.52434, n);
  std::operator<< <std::char_traits<char> > (D.52435, "; ");
}


{anonymous}::Action::Action() (struct Action * const this)
{
  struct trackable * D.52438;
  struct signal * D.52439;

  D.52438 = &this->D.49216;
  sigc::trackable::trackable (D.52438);
  try
    {
      D.52439 = &this->sig1;
      sigc::signal<void, int>::signal (D.52439);
      try
        {
          this->ref_count = 1;
        }
      catch
        {
          D.52439 = &this->sig1;
          sigc::signal<void, int>::~signal (D.52439);
        }
    }
  catch
    {
      D.52438 = &this->D.49216;
      sigc::trackable::~trackable (D.52438);
    }
}


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

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

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


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

  D.52442 = &this->D.49183;
  sigc::signal_base::signal_base (D.52442);
  try
    {

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


Glib::RefPtr<T_CppObject>::RefPtr(T_CppObject*) [with T_CppObject = {anonymous}::Action] (struct RefPtr * const this, struct Action * pCppObject)
{
  this->pCppObject_ = pCppObject;
}


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.52445;
  int (*__vtbl_ptr_type) () * D.52446;
  long int D.52447;
  sizetype D.52448;
  struct basic_ios * D.52449;
  long unsigned int D.52451;
  long int D.52452;
  struct basic_ostream & D.52453;

  if (__s == 0B) goto <D.52443>; else goto <D.52444>;
  <D.52443>:
  D.52445 = __out->_vptr.basic_ostream;
  D.52446 = D.52445 + 18446744073709551592;
  D.52447 = MEM[(long int *)D.52446];
  D.52448 = (sizetype) D.52447;
  D.52449 = __out + D.52448;
  std::basic_ios<char>::setstate (D.52449, 1);
  goto <D.52450>;
  <D.52444>:
  D.52451 = std::char_traits<char>::length (__s);
  D.52452 = (long int) D.52451;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.52452);
  <D.52450>:
  D.52453 = __out;
  return D.52453;
}


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.52455;
  _Ios_Iostate D.52456;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.52460;
  int __a.5;
  int __b.6;
  int D.52463;

  __a.5 = (int) __a;
  __b.6 = (int) __b;
  D.52463 = __a.5 | __b.6;
  D.52460 = (_Ios_Iostate) D.52463;
  return D.52460;
}


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

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


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = {anonymous}::Action] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Action * D.52467;
  struct Action * D.52468;

  D.52467 = src->pCppObject_;
  this->pCppObject_ = D.52467;
  D.52468 = this->pCppObject_;
  if (D.52468 != 0B) goto <D.52469>; else goto <D.52470>;
  <D.52469>:
  D.52468 = this->pCppObject_;
  {anonymous}::Action::reference (D.52468);
  goto <D.52471>;
  <D.52470>:
  <D.52471>:
}


void {anonymous}::Action::reference() (struct Action * const this)
{
  int D.52472;
  int D.52473;

  D.52472 = this->ref_count;
  D.52473 = D.52472 + 1;
  this->ref_count = D.52473;
}


sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1, T_arg2)) [with T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>; T_return = void; T_obj = {anonymous}::Test; T_obj2 = {anonymous}::Test] (struct Test * _A_obj, struct 
{
  void Test::<T8cc7> (struct Test *, int, struct RefPtr) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >::bound_mem_functor2 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>::bound_mem_functor2(T_obj*, sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>::function_type) [with T_return = void; T_obj = {anonymous}::Test; T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>; sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>::function_type = void ({anonymous}::Test::*)(int, Glib::RefPtr<{anonymous}::Action>)] (struct bound_mem_functor2 * const this, struct Test * _A_obj, struct function_type _A_func)
{
  struct mem_functor2 * D.52476;
  struct limit_reference * D.52477;

  D.52476 = &this->D.49560;
  sigc::mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >::mem_functor2 (D.52476, _A_func);
  D.52477 = &this->obj_;
  sigc::limit_reference<{anonymous}::Test, true>::limit_reference (D.52477, _A_obj);
}


sigc::mem_functor2<T_arg1, T_arg2, T_return, T_obj>::mem_functor2(sigc::mem_functor2<T_arg1, T_arg2, T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::Test; T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>; sigc::mem_functor2<T_arg1, T_arg2, T_return, T_obj>::function_type = void ({anonymous}::Test::*)(int, Glib::RefPtr<{anonymous}::Action>)] (struct mem_functor2 * 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 = {anonymous}::Test] (struct limit_reference * const this, struct Test & _A_target)
{
  struct trackable * D.52478;

  D.52478 = &_A_target->D.49422;
  this->visited = D.52478;
  this->invoked = _A_target;
}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = Glib::RefPtr<{anonymous}::Action>; T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (const struct bound_mem_functor2 & _A_func, struct RefPtr & restrict _A_b1)
{
  sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (<retval>, _A_func, _A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >; T_type1 = Glib::RefPtr<{anonymous}::Action>; typename sigc::type_trait<T_base>::take = const sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >&; typename sigc::type_trait<T_derived>::take = const Glib::RefPtr<{anonymous}::Action>&] (struct bind_functor * const this, const struct bound_mem_functor2 & _A_func, const struct RefPtr & _A_bound1)
{
  struct adapts * D.52481;
  struct bound_argument * D.52482;

  D.52481 = &this->D.50416;
  sigc::adapts<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >::adapts (D.52481, _A_func);
  D.52482 = &this->bound1_;
  sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::bound_argument (D.52482, _A_bound1);
  try
    {

    }
  catch
    {
      D.52482 = &this->bound1_;
      sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::~bound_argument (D.52482);
    }
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (struct adapts * const this, const struct bound_mem_functor2 & _A_functor)
{
  struct adaptor_type * D.52483;

  sigc::adaptor_base::adaptor_base (this);
  D.52483 = &this->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >::adaptor_functor (D.52483, _A_functor);
}


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


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (struct adaptor_functor * const this, const struct bound_mem_functor2 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


sigc::bound_argument<T_type>::bound_argument(const T_type&) [with T_type = Glib::RefPtr<{anonymous}::Action>] (struct bound_argument * const this, const struct RefPtr & _A_argument)
{
  struct RefPtr * D.52484;

  D.52484 = &this->visited_;
  Glib::RefPtr<{anonymous}::Action>::RefPtr (D.52484, _A_argument);
  try
    {

    }
  catch
    {
      D.52484 = &this->visited_;
      Glib::RefPtr<{anonymous}::Action>::~RefPtr (D.52484);
    }
}


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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = int] (struct slot * const this, const struct bind_functor & _A_func)
{
  struct slot1 * D.52485;

  D.52485 = &this->D.49059;
  sigc::slot1<void, int>::slot1<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.52485, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct bind_functor & _A_func)
{
  void * D.51094;
  struct slot_base * D.52486;
  struct rep_type * D.52487;
  void * (*<T1711>) (void *) D.52488;

  D.51094 = operator new (104);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.51094, _A_func);
    }
  catch
    {
      operator delete (D.51094);
    }
  D.52486 = &this->D.49017;
  sigc::slot_base::slot_base (D.52486, D.51094);
  try
    {
      D.52487 = this->D.49017.rep_;
      D.52488 = sigc::internal::slot_call1<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void, int>::address ();
      D.52487->call_ = D.52488;
    }
  catch
    {
      D.52486 = &this->D.49017;
      sigc::slot_base::~slot_base (D.52486);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct bind_functor & functor)
{
  struct slot_rep * D.52491;
  struct adaptor_type * D.52492;
  struct slot_do_bind D.51342;

  D.52491 = &this->D.51082;
  sigc::internal::slot_rep::slot_rep (D.52491, 0B, destroy, dup);
  try
    {
      D.52492 = &this->functor_;
      sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (D.52492, functor);
      try
        {
          D.52492 = &this->functor_;
          D.52491 = &this->D.51082;
          sigc::internal::slot_do_bind::slot_do_bind (&D.51342, D.52491);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51342, D.52492);
            }
          finally
            {
              D.51342 = {CLOBBER};
            }
        }
      catch
        {
          D.52492 = &this->functor_;
          sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.52492);
        }
    }
  catch
    {
      D.52491 = &this->D.51082;
      sigc::internal::slot_rep::~slot_rep (D.52491);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.52496;
  void * D.51450;
  struct slot_rep * a_rep;

  a_rep = data;
  D.51450 = operator new (104);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.51450, a_rep);
    }
  catch
    {
      operator delete (D.51450);
    }
  D.52496 = D.51450;
  return D.52496;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.52500;
  struct slot_rep * D.52501;
  const struct adaptor_type * D.52502;
  struct adaptor_type * D.52503;
  struct slot_do_bind D.51928;

  D.52500 = cl->D.51082.call_;
  D.52501 = &this->D.51082;
  sigc::internal::slot_rep::slot_rep (D.52501, D.52500, destroy, dup);
  try
    {
      D.52502 = &cl->functor_;
      D.52503 = &this->functor_;
      sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (D.52503, D.52502);
      try
        {
          D.52503 = &this->functor_;
          D.52501 = &this->D.51082;
          sigc::internal::slot_do_bind::slot_do_bind (&D.51928, D.52501);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51928, D.52503);
            }
          finally
            {
              D.51928 = {CLOBBER};
            }
        }
      catch
        {
          D.52503 = &this->functor_;
          sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.52503);
        }
    }
  catch
    {
      D.52501 = &this->D.51082;
      sigc::internal::slot_rep::~slot_rep (D.52501);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.52507;
  struct slot_do_unbind D.51444;
  void * D.52508;
  struct self * self_;

  self_ = data;
  self_->D.51082.call_ = 0B;
  self_->D.51082.destroy_ = 0B;
  D.52507 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.51444, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51444, D.52507);
    }
  finally
    {
      D.51444 = {CLOBBER};
    }
  D.52507 = &self_->functor_;
  sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.52507);
  D.52508 = 0B;
  return D.52508;
}


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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct bind_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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_functor)
{
  sigc::visitor<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >; T_type1 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52512;
  const struct bound_argument * D.52513;

  D.52512 = &_A_target->D.50416.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > > (_A_action, D.52512);
  D.52513 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> > > (_A_action, D.52513);
}


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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > >::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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor2 * D.52514;

  D.52514 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > (_A_action, D.52514);
}


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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct bound_mem_functor2 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >::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_functor2<T_return, T_obj, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_obj = {anonymous}::Test; T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor2 & _A_target)
{
  const struct limit_reference * D.52515;

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


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<{anonymous}::Test, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::Test, 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 = {anonymous}::Test; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.52516;

  D.52516 = sigc::limit_reference<{anonymous}::Test, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::trackable> (_A_action, D.52516);
}


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

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


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

  D.52519 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.52519, _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.52520;

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


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_argument<Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> > >::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_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct RefPtr & D.52521;

  D.52521 = sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, Glib::RefPtr<{anonymous}::Action> > (_A_action, D.52521);
}


const T_type& sigc::bound_argument<T_type>::visit() const [with T_type = Glib::RefPtr<{anonymous}::Action>] (const struct bound_argument * const this)
{
  const struct RefPtr & D.52522;

  D.52522 = &this->visited_;
  return D.52522;
}


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 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct RefPtr & _A_functor)
{
  sigc::visitor<Glib::RefPtr<{anonymous}::Action> >::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 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct RefPtr & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<Glib::RefPtr<{anonymous}::Action> > (_A_action, _A_functor);
}


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = Glib::RefPtr<{anonymous}::Action>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct RefPtr & D.52220, const struct limit_derived_target & D.52221)
{
  GIMPLE_NOP
}


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

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


sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(const sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) (struct bind_functor * const this, const struct bind_functor & D.50812)
{
  const struct bound_argument * D.52525;
  struct bound_argument * D.52526;

  this->D.50416 = D.50812->D.50416;
  D.52525 = &D.50812->bound1_;
  D.52526 = &this->bound1_;
  sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::bound_argument (D.52526, D.52525);
  try
    {

    }
  catch
    {
      D.52526 = &this->bound1_;
      sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::~bound_argument (D.52526);
    }
}


sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::bound_argument(const sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >&) (struct bound_argument * const this, const struct bound_argument & D.50803)
{
  const struct RefPtr * D.52527;
  struct RefPtr * D.52528;

  D.52527 = &D.50803->visited_;
  D.52528 = &this->visited_;
  Glib::RefPtr<{anonymous}::Action>::RefPtr (D.52528, D.52527);
  try
    {

    }
  catch
    {
      D.52528 = &this->visited_;
      Glib::RefPtr<{anonymous}::Action>::~RefPtr (D.52528);
    }
}


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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct bind_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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_functor)
{
  sigc::visitor<sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >; T_type1 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52530;
  const struct bound_argument * D.52531;

  D.52530 = &_A_target->D.50416.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > > (_A_action, D.52530);
  D.52531 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> > > (_A_action, D.52531);
}


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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > >::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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor2 * D.52532;

  D.52532 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > > (_A_action, D.52532);
}


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_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct bound_mem_functor2 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >::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_functor2<T_return, T_obj, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_obj = {anonymous}::Test; T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor2 & _A_target)
{
  const struct limit_reference * D.52533;

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


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<{anonymous}::Test, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::Test, 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 = {anonymous}::Test; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.52534;

  D.52534 = sigc::limit_reference<{anonymous}::Test, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::trackable> (_A_action, D.52534);
}


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

  D.52535 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.52535, _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.52536;

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


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_argument<Glib::RefPtr<{anonymous}::Action> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> > >::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_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct RefPtr & D.52537;

  D.52537 = sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, Glib::RefPtr<{anonymous}::Action> > (_A_action, D.52537);
}


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 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct RefPtr & _A_functor)
{
  sigc::visitor<Glib::RefPtr<{anonymous}::Action> >::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 = Glib::RefPtr<{anonymous}::Action>] (const struct limit_derived_target & _A_action, const struct RefPtr & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<Glib::RefPtr<{anonymous}::Action> > (_A_action, _A_functor);
}


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = Glib::RefPtr<{anonymous}::Action>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct RefPtr & D.52209, const struct limit_derived_target & D.52210)
{
  GIMPLE_NOP
}


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

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


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

  D.52541 = this->destroy_;
  if (D.52541 != 0B) goto <D.52542>; else goto <D.52543>;
  <D.52542>:
  D.52541 = this->destroy_;
  D.52541 (this);
  goto <D.52544>;
  <D.52543>:
  <D.52544>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.52545;

  D.52545 = call_it;
  return D.52545;
}


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::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; 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.52547;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.52547 = &typed_rep->functor_;
  sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<const int&> (D.52547, a_1);
  return;
}


typename sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = const int&; T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >; T_type1 = Glib::RefPtr<{anonymous}::Action>; typename sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = void] (struct bind_functor * const this, const int & _A_arg1)
{
  struct bound_argument * D.52549;
  struct RefPtr & D.52550;
  struct adaptor_type * D.52551;

  D.52549 = &this->bound1_;
  D.52550 = sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::invoke (D.52549);
  D.52551 = &this->D.50416.functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> > >::operator()<const int&, Glib::RefPtr<{anonymous}::Action>&> (D.52551, _A_arg1, D.52550);
  return;
}


T_type& sigc::bound_argument<T_type>::invoke() [with T_type = Glib::RefPtr<{anonymous}::Action>] (struct bound_argument * const this)
{
  struct RefPtr & D.52553;

  D.52553 = &this->visited_;
  return D.52553;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = const int&; T_arg2 = Glib::RefPtr<{anonymous}::Action>&; T_functor = sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = void] (const struct adaptor_functor * const this, const int & _A_arg1, struct RefPtr & _A_arg2)
{
  struct bound_mem_functor2 * D.52555;

  D.52555 = &this->functor_;
  sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >::operator() (D.52555, _A_arg1, _A_arg2);
  return;
}


T_return sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>::operator()(typename sigc::type_trait<T_arg3>::take, typename sigc::type_trait<T_arg4>::take) const [with T_return = void; T_obj = {anonymous}::Test; T_arg1 = int; T_arg2 = Glib::RefPtr<{anonymous}::Action>; typename sigc::type_trait<T_arg3>::take = const int&; typename sigc::type_trait<T_arg4>::take = const Glib::RefPtr<{anonymous}::Action>&] (const struct bound_mem_functor2 * const this, const int & _A_a1, const struct RefPtr & _A_a2)
{
  const struct limit_reference * D.52557;
  struct Test & D.52558;
  void Test::<T8cc7> (struct Test *, int, struct RefPtr) * iftmp.7;
  void Test::<T8cc7> (struct Test *, int, struct RefPtr) * D.52560;
  long int D.52561;
  long int D.52562;
  long int D.52566;
  sizetype D.52567;
  struct Test * D.52568;
  int (*__vtbl_ptr_type) () * D.52569;
  long int D.52570;
  sizetype D.52571;
  int (*__vtbl_ptr_type) () * D.52572;
  struct RefPtr D.52093;
  int D.52573;

  D.52557 = &this->obj_;
  D.52558 = sigc::limit_reference<{anonymous}::Test, true>::invoke (D.52557);
  D.52560 = this->D.49560.func_ptr_.__pfn;
  D.52561 = (long int) D.52560;
  D.52562 = D.52561 & 1;
  if (D.52562 == 0) goto <D.52563>; else goto <D.52564>;
  <D.52563>:
  iftmp.7 = this->D.49560.func_ptr_.__pfn;
  goto <D.52565>;
  <D.52564>:
  D.52566 = this->D.49560.func_ptr_.__delta;
  D.52567 = (sizetype) D.52566;
  D.52568 = D.52558 + D.52567;
  D.52569 = MEM[(int (*__vtbl_ptr_type) () * *)D.52568];
  D.52560 = this->D.49560.func_ptr_.__pfn;
  D.52561 = (long int) D.52560;
  D.52570 = D.52561 + -1;
  D.52571 = (sizetype) D.52570;
  D.52572 = D.52569 + D.52571;
  iftmp.7 = *D.52572;
  <D.52565>:
  Glib::RefPtr<{anonymous}::Action>::RefPtr (&D.52093, _A_a2);
  try
    {
      D.52573 = *_A_a1;
      D.52566 = this->D.49560.func_ptr_.__delta;
      D.52567 = (sizetype) D.52566;
      D.52568 = D.52558 + D.52567;
      iftmp.7 (D.52568, D.52573, &D.52093);
    }
  finally
    {
      Glib::RefPtr<{anonymous}::Action>::~RefPtr (&D.52093);
      D.52093 = {CLOBBER};
    }
  return;
}


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

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


sigc::signal<void, int>& {anonymous}::Action::signal_sig1() (struct Action * const this)
{
  struct signal & D.52578;

  D.52578 = &this->sig1;
  return D.52578;
}


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.52580;
  struct iterator D.50843;
  struct iterator_type D.50833;
  const struct slot_base * D.52581;
  struct signal_base * D.52582;

  D.52581 = &slot_->D.49059.D.49017;
  D.52582 = &this->D.49183;
  D.50833 = sigc::signal_base::connect (D.52582, D.52581);
  try
    {
      sigc::slot_iterator<sigc::slot<void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.50843, &D.50833);
      try
        {
          D.52580 = D.50843;
          return D.52580;
        }
      finally
        {
          D.50843 = {CLOBBER};
        }
    }
  finally
    {
      D.50833 = {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];
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52586 = &this->D.49059;
            sigc::slot1<void, int>::~slot1 (D.52586);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50500>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52588 = &this->D.49017;
            sigc::slot_base::~slot_base (D.52588);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50495>:
}


sigc::bind_functor<-1, sigc::bound_mem_functor2<void, {anonymous}::Test, int, Glib::RefPtr<{anonymous}::Action> >, Glib::RefPtr<{anonymous}::Action>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor() (struct bind_functor * const this)
{
  struct bound_argument * D.52590;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52590 = &this->bound1_;
            sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::~bound_argument (D.52590);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50458>:
}


sigc::bound_argument<Glib::RefPtr<{anonymous}::Action> >::~bound_argument() (struct bound_argument * const this)
{
  struct RefPtr * D.52592;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52592 = &this->visited_;
            Glib::RefPtr<{anonymous}::Action>::~RefPtr (D.52592);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50453>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = {anonymous}::Action] (struct RefPtr * const this)
{
  struct Action * D.52594;

  {
    try
      {
        D.52594 = this->pCppObject_;
        if (D.52594 != 0B) goto <D.52595>; else goto <D.52596>;
        <D.52595>:
        D.52594 = this->pCppObject_;
        {anonymous}::Action::unreference (D.52594);
        goto <D.52597>;
        <D.52596>:
        <D.52597>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50766>:
}


void {anonymous}::Action::unreference() (struct Action * const this)
{
  bool retval.8;
  int D.52600;
  int D.52601;

  D.52600 = this->ref_count;
  D.52601 = D.52600 + -1;
  this->ref_count = D.52601;
  D.52600 = this->ref_count;
  retval.8 = D.52600 <= 0;
  if (retval.8 != 0) goto <D.52602>; else goto <D.52603>;
  <D.52602>:
  if (this != 0B) goto <D.52604>; else goto <D.52605>;
  <D.52604>:
  {anonymous}::Action::~Action (this);
  operator delete (this);
  goto <D.52606>;
  <D.52605>:
  <D.52606>:
  goto <D.52607>;
  <D.52603>:
  <D.52607>:
}


{anonymous}::Action::~Action() (struct Action * const this)
{
  struct signal * D.52608;
  struct trackable * D.52609;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.52608 = &this->sig1;
                sigc::signal<void, int>::~signal (D.52608);
              }
          }
        finally
          {
            D.52609 = &this->D.49216;
            sigc::trackable::~trackable (D.52609);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49270>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52614 = &this->D.49183;
            sigc::signal_base::~signal_base (D.52614);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49245>:
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = {anonymous}::Action] (const struct RefPtr * const this)
{
  struct Action * D.52616;

  D.52616 = this->pCppObject_;
  return D.52616;
}


void {anonymous}::Action::emit_sig1(int) (struct Action * const this, int n)
{
  struct signal1 * D.52618;

  D.52618 = &this->sig1.D.49208;
  sigc::signal1<void, int, sigc::nil>::emit (D.52618, &n);
}


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

  D.52619 = this->D.49183.impl_;
  sigc::internal::signal_emit1<void, int, sigc::nil>::emit (D.52619, _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.9;
  bool iftmp.10;
  struct list * D.52627;
  bool D.52628;
  struct iterator D.50989;
  bool retval.11;
  bool iftmp.12;
  const struct slot_base * D.52636;
  bool D.52637;
  const struct slot_base * D.52639;
  bool D.52640;
  const struct slot_base * D.52643;
  struct rep_type * D.52644;
  void * (*<T1711>) (void *) D.52645;
  const struct slot_base * D.52646;
  struct rep_type * D.52647;
  bool retval.13;
  const struct _Self D.50992;
  struct iterator D.50991;
  struct signal_exec exec;
  struct temp_slot_list slots;

  try
    {
      if (impl == 0B) goto <D.52623>; else goto <D.52626>;
      <D.52626>:
      D.52627 = &impl->slots_;
      D.52628 = std::list<sigc::slot_base>::empty (D.52627);
      if (D.52628 != 0) goto <D.52623>; else goto <D.52624>;
      <D.52623>:
      iftmp.10 = 1;
      goto <D.52625>;
      <D.52624>:
      iftmp.10 = 0;
      <D.52625>:
      retval.9 = iftmp.10;
      if (retval.9 != 0) goto <D.52629>; else goto <D.52630>;
      <D.52629>:
      return;
      <D.52630>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.52627 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.52627);
          try
            {
              {
                struct iterator_type it;

                try
                  {
                    D.50989 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.50989);
                      }
                    finally
                      {
                        D.50989 = {CLOBBER};
                      }
                    goto <D.50996>;
                    <D.50995>:
                    D.52636 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.52637 = sigc::slot_base::empty (D.52636);
                    if (D.52637 != 0) goto <D.52633>; else goto <D.52638>;
                    <D.52638>:
                    D.52639 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.52640 = sigc::slot_base::blocked (D.52639);
                    if (D.52640 != 0) goto <D.52633>; else goto <D.52634>;
                    <D.52633>:
                    iftmp.12 = 1;
                    goto <D.52635>;
                    <D.52634>:
                    iftmp.12 = 0;
                    <D.52635>:
                    retval.11 = iftmp.12;
                    if (retval.11 != 0) goto <D.52641>; else goto <D.52642>;
                    <D.52641>:
                    goto <D.50994>;
                    <D.52642>:
                    D.52643 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.52644 = D.52643->rep_;
                    D.52645 = D.52644->call_;
                    D.52646 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.52647 = D.52646->rep_;
                    D.52645 (D.52647, _A_a1);
                    <D.50994>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.50996>:
                    D.50991 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.50992, &D.50991);
                        try
                          {
                            retval.13 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.50992);
                          }
                        finally
                          {
                            D.50992 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.50991 = {CLOBBER};
                      }
                    if (retval.13 != 0) goto <D.50995>; else goto <D.50993>;
                    <D.50993>:
                  }
                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.52660;
  struct _List_node_base * D.52661;
  const struct _List_node_base * D.52662;

  D.52661 = this->D.35179._M_impl._M_node._M_next;
  D.52662 = &this->D.35179._M_impl._M_node;
  D.52660 = D.52661 == D.52662;
  return D.52660;
}


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

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.52665;
  unsigned short D.52666;
  unsigned short D.52667;
  short int D.52668;
  short int D.52669;
  unsigned short D.52670;
  unsigned short D.52671;
  short int D.52672;

  D.52665 = this->ref_count_;
  D.52666 = (unsigned short) D.52665;
  D.52667 = D.52666 + 1;
  D.52668 = (short int) D.52667;
  this->ref_count_ = D.52668;
  D.52669 = this->exec_count_;
  D.52670 = (unsigned short) D.52669;
  D.52671 = D.52670 + 1;
  D.52672 = (short int) D.52671;
  this->exec_count_ = D.52672;
}


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.52673;
  struct slot_base D.35400;
  struct slot_list & D.52674;
  struct _List_iterator D.52675;

  this->slots_ = slots;
  D.52673 = &this->placeholder;
  std::_List_iterator<sigc::slot_base>::_List_iterator (D.52673);
  sigc::slot_base::slot_base (&D.35400);
  try
    {
      D.52674 = this->slots_;
      D.52675 = std::list<sigc::slot_base>::end (D.52674);
      D.52674 = this->slots_;
      this->placeholder = std::list<sigc::slot_base>::insert (D.52674, D.52675, &D.35400);
    }
  finally
    {
      sigc::slot_base::~slot_base (&D.35400);
      D.35400 = {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.52677;
  struct iterator D.50691;
  struct _List_node_base * D.52678;

  D.52678 = &this->D.35179._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.50691, D.52678);
  try
    {
      D.52677 = D.50691;
      return D.52677;
    }
  finally
    {
      D.50691 = {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.50699;
  struct _List_node_base * D.52681;
  struct _List_node_base * D.52682;
  struct iterator D.52683;
  struct iterator D.50700;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.50699 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.52681 = D.50699._M_node;
  D.52682 = &__tmp->D.50696;
  std::__detail::_List_node_base::_M_hook (D.52682, D.52681);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.50700, __tmp);
  try
    {
      D.52683 = D.50700;
      return D.52683;
    }
  finally
    {
      D.50700 = {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.52687;
  struct slot_base * D.52688;
  struct slot_base * D.52689;
  struct _Tp_alloc_type D.50928;
  void * D.52690;
  struct _Node * D.52691;
  struct _Node * __p;

  D.52687 = &this->D.35179;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.52687);
  try
    {
      D.52688 = &__p->_M_data;
      D.52689 = std::__addressof<sigc::slot_base> (D.52688);
      D.52687 = &this->D.35179;
      D.50928 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.52687); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.50928, D.52689, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.50928);
          D.50928 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.52690 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.52690);
              D.52687 = &this->D.35179;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.52687, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.52691 = __p;
  return D.52691;
}


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.52698;
  struct _List_impl * D.52699;

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


_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.34672)
{
  bool retval.14;
  long unsigned int D.52703;
  struct _List_node * D.52706;
  long unsigned int D.52707;

  D.52703 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.14 = D.52703 < __n;
  if (retval.14 != 0) goto <D.52704>; else goto <D.52705>;
  <D.52704>:
  std::__throw_bad_alloc ();
  <D.52705>:
  D.52707 = __n * 32;
  D.52706 = operator new (D.52707);
  return D.52706;
}


__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.52710;
  void * D.52711;

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


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

  D.52713 = __r;
  return D.52713;
}


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

  D.52716 = 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.52716);
  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.52718;

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


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.51188)
{
  void * D.52720;

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


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

  try
    {
      {

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


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.51226;
  void * D.51227;
  struct slot_base * iftmp.15;

  D.51226 = __p;
  D.51227 = operator new (16, D.51226);
  if (D.51227 != 0B) goto <D.52723>; else goto <D.52724>;
  <D.52723>:
  try
    {
      sigc::slot_base::slot_base (D.51227, __val);
    }
  catch
    {
      operator delete (D.51227, D.51226);
    }
  iftmp.15 = D.51227;
  goto <D.52725>;
  <D.52724>:
  iftmp.15 = D.51227;
  <D.52725>:
}


void* operator new(std::size_t, void*) (size_t D.6125, void * __p)
{
  void * D.52727;
  void * D.52728;

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


void operator delete(void*, void*) (void * D.6133, void * D.6134)
{
  void * D.52730;

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.52733 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.52733, __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.34676)
{
  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.52734;

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


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

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


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.52739;
  struct iterator D.50707;
  struct _List_node_base * D.52740;

  D.52740 = this->D.35179._M_impl._M_node._M_next;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.50707, D.52740);
  try
    {
      D.52739 = D.50707;
      return D.52739;
    }
  finally
    {
      D.50707 = {CLOBBER};
    }
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.52743;
  bool iftmp.16;
  struct rep_type * D.52748;
  void * (*<T1711>) (void *) D.52750;

  D.52748 = this->rep_;
  if (D.52748 == 0B) goto <D.52745>; else goto <D.52749>;
  <D.52749>:
  D.52748 = this->rep_;
  D.52750 = D.52748->call_;
  if (D.52750 == 0B) goto <D.52745>; else goto <D.52746>;
  <D.52745>:
  iftmp.16 = 1;
  goto <D.52747>;
  <D.52746>:
  iftmp.16 = 0;
  <D.52747>:
  D.52743 = iftmp.16;
  return D.52743;
}


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

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


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.52754;
  const struct _List_node_base * D.52755;
  const struct slot_base * D.52756;

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


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

  D.52758 = __r;
  return D.52758;
}


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.52760;
  struct _List_node_base * D.52761;
  struct _Self & D.52762;

  D.52760 = this->_M_node;
  D.52761 = D.52760->_M_next;
  this->_M_node = D.52761;
  D.52762 = this;
  return D.52762;
}


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

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


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

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


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.52767;
  const struct _List_node_base * D.52768;
  const struct _List_node_base * D.52769;

  D.52768 = this->_M_node;
  D.52769 = __x->_M_node;
  D.52767 = D.52768 != D.52769;
  return D.52767;
}


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

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


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.52773;
  struct _List_node_base * D.52774;
  struct _List_iterator D.52775;
  struct iterator D.52776;
  struct iterator __ret;

  try
    {
      D.52773 = __position._M_node;
      D.52774 = D.52773->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.52774);
      D.52775 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.52775);
      D.52776 = __ret;
      return D.52776;
    }
  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.52780;
  struct slot_base * D.52781;
  struct slot_base * D.52782;
  struct _Tp_alloc_type D.50934;
  struct _List_base * D.52783;
  struct _Node * __n;

  D.52780 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.52780);
  __n = __position._M_node;
  D.52781 = &__n->_M_data;
  D.52782 = std::__addressof<sigc::slot_base> (D.52781);
  D.52783 = &this->D.35179;
  D.50934 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.52783); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.50934, D.52782);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.50934);
      D.50934 = {CLOBBER};
    }
  D.52783 = &this->D.35179;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.52783, __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.52785;

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.17;
  short int D.52788;
  unsigned short D.52789;
  unsigned short D.52790;
  short int D.52791;
  bool retval.18;
  bool iftmp.19;
  short int D.52802;
  unsigned short D.52803;
  unsigned short D.52804;
  short int D.52805;
  bool D.52807;

  D.52788 = this->ref_count_;
  D.52789 = (unsigned short) D.52788;
  D.52790 = D.52789 + 65535;
  D.52791 = (short int) D.52790;
  this->ref_count_ = D.52791;
  D.52788 = this->ref_count_;
  retval.17 = D.52788 == 0;
  if (retval.17 != 0) goto <D.52792>; else goto <D.52793>;
  <D.52792>:
  if (this != 0B) goto <D.52794>; else goto <D.52795>;
  <D.52794>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.52796>;
  <D.52795>:
  <D.52796>:
  goto <D.52797>;
  <D.52793>:
  D.52802 = this->exec_count_;
  D.52803 = (unsigned short) D.52802;
  D.52804 = D.52803 + 65535;
  D.52805 = (short int) D.52804;
  this->exec_count_ = D.52805;
  D.52802 = this->exec_count_;
  if (D.52802 == 0) goto <D.52806>; else goto <D.52800>;
  <D.52806>:
  D.52807 = this->deferred_;
  if (D.52807 != 0) goto <D.52808>; else goto <D.52800>;
  <D.52808>:
  iftmp.19 = 1;
  goto <D.52801>;
  <D.52800>:
  iftmp.19 = 0;
  <D.52801>:
  retval.18 = iftmp.19;
  if (retval.18 != 0) goto <D.52809>; else goto <D.52810>;
  <D.52809>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.52811>;
  <D.52810>:
  <D.52811>:
  <D.52797>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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

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


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.52819;
  struct slot_base * D.52820;
  struct _Tp_alloc_type D.50917;
  struct _List_node_base * D.52821;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.50696._M_next;
    D.52819 = &__tmp->_M_data;
    D.52820 = std::__addressof<sigc::slot_base> (D.52819);
    D.50917 = 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.50917, D.52820);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.50917);
        D.50917 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.50921>:
  D.52821 = &this->_M_impl._M_node;
  if (D.52821 != __cur) goto <D.50922>; else goto <D.50920>;
  <D.50920>:
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


{anonymous}::Test::~Test() (struct Test * const this)
{
  struct RefPtr * D.52825;
  struct trackable * D.52826;

  {
    try
      {
        try
          {
            try
              {
                std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "delete Test; ");
              }
            finally
              {
                D.52825 = &this->action;
                Glib::RefPtr<{anonymous}::Action>::~RefPtr (D.52825);
              }
          }
        finally
          {
            D.52826 = &this->D.49422;
            sigc::trackable::~trackable (D.52826);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50562>:
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this);
        try
          {

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


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

  try
    {
      {

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


std::basic_string<_CharT, _Traits, _Alloc>::~basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator_type D.50875;
  struct _Rep * D.52832;
  struct _Alloc_hider * D.52833;

  {
    try
      {
        try
          {
            D.50875 = std::basic_string<char>::get_allocator (this); [return slot optimization]
            try
              {
                D.52832 = std::basic_string<char>::_M_rep (this);
                std::basic_string<char>::_Rep::_M_dispose (D.52832, &D.50875);
              }
            finally
              {
                std::allocator<char>::~allocator (&D.50875);
                D.50875 = {CLOBBER};
              }
          }
        finally
          {
            D.52833 = &this->_M_dataplus;
            std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.52833);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50876>:
}


std::basic_string<_CharT, _Traits, _Alloc>::allocator_type std::basic_string<_CharT, _Traits, _Alloc>::get_allocator() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::allocator_type = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Alloc_hider * D.52839;

  D.52839 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.52839);
  return <retval>;
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator< <template-parameter-1-1> >&) [with _Tp = char] (struct allocator * const this, const struct allocator & __a)
{
  void * D.52841;

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this, __a);
        try
          {

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


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = char] (struct new_allocator * const this, const struct new_allocator & D.6401)
{
  void * D.52842;

  try
    {
      {

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


std::basic_string<_CharT, _Traits, _Alloc>::_Rep* std::basic_string<_CharT, _Traits, _Alloc>::_M_rep() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Rep * D.52843;
  char * D.52844;

  D.52844 = std::basic_string<char>::_M_data (this);
  D.52843 = D.52844 + 18446744073709551592;
  return D.52843;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_M_data() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  char * D.52847;

  D.52847 = this->_M_dataplus._M_p;
  return D.52847;
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.20;
  struct _Rep & D.52850;
  bool D.52851;
  long int D.52852;
  long int D.52853;
  bool retval.21;
  _Atomic_word * D.52857;
  int D.52858;

  D.52850 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.52851 = D.52850 != this;
  D.52852 = (long int) D.52851;
  D.52853 = __builtin_expect (D.52852, 0);
  retval.20 = D.52853 != 0;
  if (retval.20 != 0) goto <D.52854>; else goto <D.52855>;
  <D.52854>:
  D.52857 = &this->D.11865._M_refcount;
  D.52858 = __gnu_cxx::__exchange_and_add_dispatch (D.52857, -1);
  retval.21 = D.52858 <= 0;
  if (retval.21 != 0) goto <D.52859>; else goto <D.52860>;
  <D.52859>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.52861>;
  <D.52860>:
  <D.52861>:
  goto <D.52862>;
  <D.52855>:
  <D.52862>:
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.52864;
  void * __p;

  __p = &_S_empty_rep_storage;
  D.52864 = __p;
  return D.52864;
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.22;
  int D.52867;
  _Atomic_word D.52870;

  D.52867 = __gthread_active_p ();
  retval.22 = D.52867 != 0;
  if (retval.22 != 0) goto <D.52868>; else goto <D.52869>;
  <D.52868>:
  D.52870 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.52870;
  <D.52869>:
  D.52870 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.52870;
}


int __gthread_active_p() ()
{
  int D.52872;
  bool D.52873;
  static void * const __gthread_active_ptr = (void *) __gthrw___pthread_key_create;

  D.52873 = __gthrw___pthread_key_create != 0B;
  D.52872 = (int) D.52873;
  return D.52872;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.52875;
  unsigned int __val.23;
  unsigned int D.52877;

  __val.23 = (unsigned int) __val;
  D.52877 = __atomic_fetch_add_4 (__mem, __val.23, 4);
  D.52875 = (_Atomic_word) D.52877;
  return D.52875;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.52879;
  int D.52880;
  _Atomic_word D.52881;
  _Atomic_word __result;

  __result = *__mem;
  D.52879 = *__mem;
  D.52880 = D.52879 + __val;
  *__mem = D.52880;
  D.52881 = __result;
  return D.52881;
}


std::basic_string<char>::_Alloc_hider::~_Alloc_hider() (struct _Alloc_hider * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<char>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50869>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<char>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.50851>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.52883 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.52883);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


(static initializers for test_bind_refptr.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.52885>; else goto <D.52886>;
  <D.52885>:
  if (__priority == 65535) goto <D.52887>; else goto <D.52888>;
  <D.52887>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.52889>;
  <D.52888>:
  <D.52889>:
  goto <D.52890>;
  <D.52886>:
  <D.52890>:
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostringstream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.24;
  const void * * D.52894;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.52899;
  int (*__vtbl_ptr_type) () * D.52900;
  long int D.52901;
  struct basic_ios * D.52903;
  int (*__vtbl_ptr_type) () * iftmp.26;
  struct __stringbuf_type * D.52908;
  const void * * iftmp.27;
  struct basic_ostream * D.52913;
  int D.52914;
  struct basic_ios * D.52917;
  int D.52919;

  {
    if (2 == 0) goto <D.52892>; else goto <D.52893>;
    <D.52892>:
    D.52894 = 0B;
    iftmp.24 = *D.52894;
    goto <D.52895>;
    <D.52893>:
    iftmp.24 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.52895>:
    this->D.22312._vptr.basic_ostream = iftmp.24;
    if (2 == 0) goto <D.52897>; else goto <D.52898>;
    <D.52897>:
    D.52899 = this->D.22312._vptr.basic_ostream;
    D.52900 = D.52899 + 18446744073709551592;
    D.52901 = MEM[(long int *)D.52900];
    iftmp.25 = (sizetype) D.52901;
    goto <D.52902>;
    <D.52898>:
    iftmp.25 = 88;
    <D.52902>:
    D.52903 = this + iftmp.25;
    if (2 == 0) goto <D.52905>; else goto <D.52906>;
    <D.52905>:
    iftmp.26 = MEM[(const void * *)0B + 24B];
    goto <D.52907>;
    <D.52906>:
    iftmp.26 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.52907>:
    D.52903->D.19008._vptr.ios_base = iftmp.26;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.52908 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.52908);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.52910>; else goto <D.52911>;
                <D.52910>:
                iftmp.27 = 8B;
                goto <D.52912>;
                <D.52911>:
                iftmp.27 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.52912>:
                D.52913 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.52913, iftmp.27);
              }
          }
        finally
          {
            D.52914 = 2;
            if (D.52914 != 0) goto <D.52915>; else goto <D.52916>;
            <D.52915>:
            D.52917 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.52917);
            goto <D.52918>;
            <D.52916>:
            <D.52918>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.52303>:
  D.52919 = 0;
  if (D.52919 != 0) goto <D.52920>; else goto <D.52921>;
  <D.52920>:
  operator delete (this);
  goto <D.52922>;
  <D.52921>:
  <D.52922>:
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostringstream * const this)
{
  std::basic_ostringstream<char>::~basic_ostringstream (this);
  <D.52305>:
  operator delete (this);
}


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.52932;
  struct basic_streambuf * D.52933;
  int D.52934;

  {
    this->D.22162._vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_stringbufIcSt11char_traitsIcESaIcEE + 16B];
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.52932 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.52932);
              }
          }
        finally
          {
            D.52933 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.52933);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50748>:
  D.52934 = 0;
  if (D.52934 != 0) goto <D.52935>; else goto <D.52936>;
  <D.52935>:
  operator delete (this);
  goto <D.52937>;
  <D.52936>:
  <D.52937>:
}


std::basic_streambuf<_CharT, _Traits>::~basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  struct locale * D.52940;
  int D.52941;

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

          }
        finally
          {
            D.52940 = &this->_M_buf_locale;
            std::locale::~locale (D.52940);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50977>:
  D.52941 = 0;
  if (D.52941 != 0) goto <D.52942>; else goto <D.52943>;
  <D.52942>:
  operator delete (this);
  goto <D.52944>;
  <D.52943>:
  <D.52944>:
}


std::basic_streambuf<_CharT, _Traits>::~basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  std::basic_streambuf<char>::~basic_streambuf (this);
  <D.50981>:
  operator delete (this);
}


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.50752>:
  operator delete (this);
}


std::basic_ostream<_CharT, _Traits>::~basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.28;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.52952;
  int (*__vtbl_ptr_type) () * D.52953;
  long int D.52954;
  struct basic_ios * D.52956;
  int (*__vtbl_ptr_type) () * iftmp.30;
  int D.52961;
  struct basic_ios * D.52964;
  int D.52966;

  {
    if (0 == 0) goto <D.52946>; else goto <D.52947>;
    <D.52946>:
    iftmp.28 = *__vtt_parm;
    goto <D.52948>;
    <D.52947>:
    iftmp.28 = &MEM[(void *)&_ZTVSo + 24B];
    <D.52948>:
    this->_vptr.basic_ostream = iftmp.28;
    if (0 == 0) goto <D.52950>; else goto <D.52951>;
    <D.52950>:
    D.52952 = this->_vptr.basic_ostream;
    D.52953 = D.52952 + 18446744073709551592;
    D.52954 = MEM[(long int *)D.52953];
    iftmp.29 = (sizetype) D.52954;
    goto <D.52955>;
    <D.52951>:
    iftmp.29 = 8;
    <D.52955>:
    D.52956 = this + iftmp.29;
    if (0 == 0) goto <D.52958>; else goto <D.52959>;
    <D.52958>:
    iftmp.30 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.52960>;
    <D.52959>:
    iftmp.30 = &MEM[(void *)&_ZTVSo + 64B];
    <D.52960>:
    D.52956->D.19008._vptr.ios_base = iftmp.30;
    try
      {
        try
          {

          }
        finally
          {
            D.52961 = 0;
            if (D.52961 != 0) goto <D.52962>; else goto <D.52963>;
            <D.52962>:
            D.52964 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.52964);
            goto <D.52965>;
            <D.52963>:
            <D.52965>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50962>:
  D.52966 = 0;
  if (D.52966 != 0) goto <D.52967>; else goto <D.52968>;
  <D.52967>:
  operator delete (this);
  goto <D.52969>;
  <D.52968>:
  <D.52969>:
}


std::basic_ios<_CharT, _Traits>::~basic_ios() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ios * const this)
{
  struct ios_base * D.52971;
  int D.52972;

  {
    this->D.19008._vptr.ios_base = &MEM[(void *)&_ZTVSt9basic_iosIcSt11char_traitsIcEE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.52971 = &this->D.19008;
            std::ios_base::~ios_base (D.52971);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50950>:
  D.52972 = 0;
  if (D.52972 != 0) goto <D.52973>; else goto <D.52974>;
  <D.52973>:
  operator delete (this);
  goto <D.52975>;
  <D.52974>:
  <D.52975>:
}


std::basic_ios<_CharT, _Traits>::~basic_ios() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ios * const this)
{
  std::basic_ios<char>::~basic_ios (this);
  <D.50954>:
  operator delete (this);
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::basic_ostringstream(std::ios_base::openmode) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::ios_base::openmode = std::_Ios_Openmode] (struct basic_ostringstream * const this, openmode __mode)
{
  struct basic_ios * D.52979;
  const void * * iftmp.31;
  struct basic_ostream * D.52985;
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * D.52989;
  sizetype iftmp.33;
  int (*__vtbl_ptr_type) () * D.52994;
  int (*__vtbl_ptr_type) () * D.52995;
  long int D.52996;
  struct basic_ios * D.52998;
  int (*__vtbl_ptr_type) () * iftmp.34;
  _Ios_Openmode D.53003;
  struct __stringbuf_type * D.53004;
  struct basic_streambuf * D.53005;
  sizetype iftmp.35;
  struct basic_ios * D.53010;
  const void * * iftmp.36;

  if (1 != 0) goto <D.52977>; else goto <D.52978>;
  <D.52977>:
  D.52979 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.52979);
  goto <D.52980>;
  <D.52978>:
  <D.52980>:
  try
    {
      if (1 == 0) goto <D.52982>; else goto <D.52983>;
      <D.52982>:
      iftmp.31 = 8B;
      goto <D.52984>;
      <D.52983>:
      iftmp.31 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.52984>:
      D.52985 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.52985, iftmp.31);
      try
        {
          if (1 == 0) goto <D.52987>; else goto <D.52988>;
          <D.52987>:
          D.52989 = 0B;
          iftmp.32 = *D.52989;
          goto <D.52990>;
          <D.52988>:
          iftmp.32 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.52990>:
          this->D.22312._vptr.basic_ostream = iftmp.32;
          if (1 == 0) goto <D.52992>; else goto <D.52993>;
          <D.52992>:
          D.52994 = this->D.22312._vptr.basic_ostream;
          D.52995 = D.52994 + 18446744073709551592;
          D.52996 = MEM[(long int *)D.52995];
          iftmp.33 = (sizetype) D.52996;
          goto <D.52997>;
          <D.52993>:
          iftmp.33 = 88;
          <D.52997>:
          D.52998 = this + iftmp.33;
          if (1 == 0) goto <D.53000>; else goto <D.53001>;
          <D.53000>:
          iftmp.34 = MEM[(const void * *)0B + 24B];
          goto <D.53002>;
          <D.53001>:
          iftmp.34 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.53002>:
          D.52998->D.19008._vptr.ios_base = iftmp.34;
          D.53003 = std::operator| (__mode, 16);
          D.53004 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.53004, D.53003);
          try
            {
              D.53005 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.53007>; else goto <D.53008>;
              <D.53007>:
              D.52994 = this->D.22312._vptr.basic_ostream;
              D.52995 = D.52994 + 18446744073709551592;
              D.52996 = MEM[(long int *)D.52995];
              iftmp.35 = (sizetype) D.52996;
              goto <D.53009>;
              <D.53008>:
              iftmp.35 = 88;
              <D.53009>:
              D.53010 = this + iftmp.35;
              std::basic_ios<char>::init (D.53010, D.53005);
            }
          catch
            {
              D.53004 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.53004);
            }
        }
      catch
        {
          if (1 == 0) goto <D.53012>; else goto <D.53013>;
          <D.53012>:
          iftmp.36 = 8B;
          goto <D.53014>;
          <D.53013>:
          iftmp.36 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.53014>:
          D.52985 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.52985, iftmp.36);
        }
    }
  catch
    {
      if (1 != 0) goto <D.53015>; else goto <D.53016>;
      <D.53015>:
      D.52979 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.52979);
      goto <D.53017>;
      <D.53016>:
      <D.53017>:
    }
}


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

  D.53021 = &this->D.19008;
  std::ios_base::ios_base (D.53021);
  try
    {
      this->D.19008._vptr.ios_base = &MEM[(void *)&_ZTVSt9basic_iosIcSt11char_traitsIcEE + 16B];
      this->_M_tie = 0B;
      this->_M_fill = 0;
      this->_M_fill_init = 0;
      this->_M_streambuf = 0B;
      this->_M_ctype = 0B;
      this->_M_num_put = 0B;
      this->_M_num_get = 0B;
    }
  catch
    {
      D.53021 = &this->D.19008;
      std::ios_base::~ios_base (D.53021);
    }
}


std::basic_ostream<_CharT, _Traits>::basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  struct basic_ios * D.53024;
  int (*__vtbl_ptr_type) () * iftmp.37;
  sizetype iftmp.38;
  int (*__vtbl_ptr_type) () * D.53033;
  int (*__vtbl_ptr_type) () * D.53034;
  long int D.53035;
  struct basic_ios * D.53037;
  int (*__vtbl_ptr_type) () * iftmp.39;
  sizetype iftmp.40;
  struct basic_ios * D.53046;

  if (0 != 0) goto <D.53022>; else goto <D.53023>;
  <D.53022>:
  D.53024 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.53024);
  goto <D.53025>;
  <D.53023>:
  <D.53025>:
  try
    {
      if (0 == 0) goto <D.53027>; else goto <D.53028>;
      <D.53027>:
      iftmp.37 = *__vtt_parm;
      goto <D.53029>;
      <D.53028>:
      iftmp.37 = &MEM[(void *)&_ZTVSo + 24B];
      <D.53029>:
      this->_vptr.basic_ostream = iftmp.37;
      if (0 == 0) goto <D.53031>; else goto <D.53032>;
      <D.53031>:
      D.53033 = this->_vptr.basic_ostream;
      D.53034 = D.53033 + 18446744073709551592;
      D.53035 = MEM[(long int *)D.53034];
      iftmp.38 = (sizetype) D.53035;
      goto <D.53036>;
      <D.53032>:
      iftmp.38 = 8;
      <D.53036>:
      D.53037 = this + iftmp.38;
      if (0 == 0) goto <D.53039>; else goto <D.53040>;
      <D.53039>:
      iftmp.39 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.53041>;
      <D.53040>:
      iftmp.39 = &MEM[(void *)&_ZTVSo + 64B];
      <D.53041>:
      D.53037->D.19008._vptr.ios_base = iftmp.39;
      if (0 == 0) goto <D.53043>; else goto <D.53044>;
      <D.53043>:
      D.53033 = this->_vptr.basic_ostream;
      D.53034 = D.53033 + 18446744073709551592;
      D.53035 = MEM[(long int *)D.53034];
      iftmp.40 = (sizetype) D.53035;
      goto <D.53045>;
      <D.53044>:
      iftmp.40 = 8;
      <D.53045>:
      D.53046 = this + iftmp.40;
      std::basic_ios<char>::init (D.53046, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.53047>; else goto <D.53048>;
      <D.53047>:
      D.53024 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.53024);
      goto <D.53049>;
      <D.53048>:
      <D.53049>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.53051;
  int __a.41;
  int __b.42;
  int D.53054;

  __a.41 = (int) __a;
  __b.42 = (int) __b;
  D.53054 = __a.41 | __b.42;
  D.53051 = (_Ios_Openmode) D.53054;
  return D.53051;
}


std::basic_stringbuf<_CharT, _Traits, _Alloc>::basic_stringbuf(std::ios_base::openmode) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::ios_base::openmode = std::_Ios_Openmode] (struct basic_stringbuf * const this, openmode __mode)
{
  struct basic_streambuf * D.53056;
  struct __string_type * D.53057;

  D.53056 = &this->D.22162;
  std::basic_streambuf<char>::basic_streambuf (D.53056);
  try
    {
      this->D.22162._vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_stringbufIcSt11char_traitsIcESaIcEE + 16B];
      this->_M_mode = __mode;
      D.53057 = &this->_M_string;
      std::basic_string<char>::basic_string (D.53057);
      try
        {

        }
      catch
        {
          D.53057 = &this->_M_string;
          std::basic_string<char>::~basic_string (D.53057);
        }
    }
  catch
    {
      D.53056 = &this->D.22162;
      std::basic_streambuf<char>::~basic_streambuf (D.53056);
    }
}


std::basic_streambuf<_CharT, _Traits>::basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  struct locale * D.53059;

  this->_vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_streambufIcSt11char_traitsIcEE + 16B];
  this->_M_in_beg = 0B;
  this->_M_in_cur = 0B;
  this->_M_in_end = 0B;
  this->_M_out_beg = 0B;
  this->_M_out_cur = 0B;
  this->_M_out_end = 0B;
  D.53059 = &this->_M_buf_locale;
  std::locale::locale (D.53059);
  try
    {

    }
  catch
    {
      D.53059 = &this->_M_buf_locale;
      std::locale::~locale (D.53059);
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator D.51249;
  struct _Rep & D.53060;
  char * D.53061;
  struct _Alloc_hider * D.53062;

  std::allocator<char>::allocator (&D.51249);
  try
    {
      D.53060 = std::basic_string<char>::_S_empty_rep ();
      D.53061 = std::basic_string<char>::_Rep::_M_refdata (D.53060);
      D.53062 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.53062, D.53061, &D.51249);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.51249);
      D.51249 = {CLOBBER};
    }
  try
    {

    }
  catch
    {
      D.53062 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.53062);
    }
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.53065;

  D.53065 = std::basic_string<char>::_Rep::_S_empty_rep ();
  return D.53065;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_refdata() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  char * D.53068;
  void * D.53069;

  try
    {
      D.53068 = this + 24;
      return D.53068;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.53069 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.53069);
          
        }
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::_Alloc_hider::_Alloc_hider(_CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Alloc_hider * const this, char * __dat, const struct allocator & __a)
{
  std::allocator<char>::allocator (this, __a);
  try
    {
      this->_M_p = __dat;
    }
  catch
    {
      std::allocator<char>::~allocator (this);
    }
}


