int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.53621;
  int D.53624;
  int iftmp.1;
  bool D.53626;
  void * instance.2;
  struct bound_mem_functor0 D.49097;
  struct 
{
  void Derived::<T8b2c> (struct Derived *) * __pfn;
  long int __delta;
} D.53630;
  const struct string D.49151;
  struct allocator D.49150;
  struct bind_functor D.50170;
  struct reference_wrapper D.53631;
  struct slot D.49255;
  const struct string D.50249;
  struct allocator D.50248;
  struct bind_return_functor D.51052;
  struct reference_wrapper D.53632;
  struct slot D.50344;
  struct Derived D.51152;
  const struct string D.51155;
  struct allocator D.51154;
  int (*__vtbl_ptr_type) () * D.53635;
  int (*__vtbl_ptr_type) () * D.53636;
  int (*__vtbl_ptr_type) () D.53637;
  struct Derived D.51156;
  const struct string D.51159;
  struct allocator D.51158;
  int iftmp.3;
  bool D.53640;

  {
    struct TestUtilities * util;
    struct Derived * instance;
    struct slot handler;
    struct slot param;
    struct slot ret;

    try
      {
        util = TestUtilities::get_instance ();
        D.53621 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.53621;
        if (retval.0 != 0) goto <D.53622>; else goto <D.53623>;
        <D.53622>:
        D.53626 = TestUtilities::get_result_and_delete_instance ();
        if (D.53626 != 0) goto <D.53627>; else goto <D.53628>;
        <D.53627>:
        iftmp.1 = 0;
        goto <D.53629>;
        <D.53628>:
        iftmp.1 = 1;
        <D.53629>:
        D.53624 = iftmp.1;
        return D.53624;
        <D.53623>:
        instance.2 = operator new (24);
        try
          {
            MEM[(struct Derived *)instance.2] = {};
            {anonymous}::Derived::Derived (instance.2);
          }
        catch
          {
            operator delete (instance.2);
          }
        instance = instance.2;
        D.53630.__pfn = method;
        D.53630.__delta = 0;
        D.49097 = sigc::mem_fun<void, {anonymous}::Derived, {anonymous}::Derived> (instance, D.53630); [return slot optimization]
        try
          {
            sigc::slot<void>::slot<sigc::bound_mem_functor0<void, {anonymous}::Derived> > (&handler, &D.49097);
          }
        finally
          {
            try
              {

              }
            catch
              {
                sigc::slot<void>::~slot (&handler);
              }
            D.49097 = {CLOBBER};
          }
        try
          {
            sigc::slot0<void>::operator() (&handler.D.48981);
            std::allocator<char>::allocator (&D.49150);
            try
              {
                std::basic_string<char>::basic_string (&D.49151, "method()", &D.49150);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.49151);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.49151);
                    D.49151 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.49150);
                D.49150 = {CLOBBER};
              }
            D.53631 = sigc::ref<{anonymous}::Derived> (instance);
            sigc::slot<void, {anonymous}::Derived&>::slot (&D.49255);
            try
              {
                D.50170 = sigc::bind<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void, {anonymous}::Derived&> > (&D.49255, D.53631); [return slot optimization]
                try
                  {
                    sigc::slot<void>::slot<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&param, &D.50170);
                  }
                finally
                  {
                    try
                      {
                        sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (&D.50170);
                      }
                    catch
                      {
                        sigc::slot<void>::~slot (&param);
                      }
                    D.50170 = {CLOBBER};
                  }
              }
            finally
              {
                try
                  {
                    sigc::slot<void, {anonymous}::Derived&>::~slot (&D.49255);
                  }
                catch
                  {
                    sigc::slot<void>::~slot (&param);
                  }
                D.49255 = {CLOBBER};
              }
            try
              {
                sigc::slot0<void>::operator() (&param.D.48981);
                std::allocator<char>::allocator (&D.50248);
                try
                  {
                    std::basic_string<char>::basic_string (&D.50249, "", &D.50248);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.50249);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.50249);
                        D.50249 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.50248);
                    D.50248 = {CLOBBER};
                  }
                D.53632 = sigc::ref<{anonymous}::Derived> (instance);
                sigc::slot<void>::slot (&D.50344);
                try
                  {
                    D.51052 = sigc::bind_return<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > (&D.50344, D.53632); [return slot optimization]
                    try
                      {
                        sigc::slot<{anonymous}::Derived>::slot<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&ret, &D.51052);
                      }
                    finally
                      {
                        try
                          {
                            sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::~bind_return_functor (&D.51052);
                          }
                        catch
                          {
                            sigc::slot<{anonymous}::Derived>::~slot (&ret);
                          }
                        D.51052 = {CLOBBER};
                      }
                  }
                finally
                  {
                    try
                      {
                        sigc::slot<void>::~slot (&D.50344);
                      }
                    catch
                      {
                        sigc::slot<{anonymous}::Derived>::~slot (&ret);
                      }
                    D.50344 = {CLOBBER};
                  }
                try
                  {
                    D.51152 = sigc::slot0<{anonymous}::Derived>::operator() (&ret.D.50342); [return slot optimization]
                    {anonymous}::Derived::~Derived (&D.51152);
                    D.51152 = {CLOBBER};
                    std::allocator<char>::allocator (&D.51154);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.51155, "", &D.51154);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.51155);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.51155);
                            D.51155 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.51154);
                        D.51154 = {CLOBBER};
                      }
                    if (instance != 0B) goto <D.53633>; else goto <D.53634>;
                    <D.53633>:
                    D.53635 = instance->D.48787._vptr.Base2;
                    D.53636 = D.53635 + 8;
                    D.53637 = *D.53636;
                    {anonymous}::Derived::~Derived (instance);
                    goto <D.53638>;
                    <D.53634>:
                    <D.53638>:
                    sigc::slot0<void>::operator() (&handler.D.48981);
                    sigc::slot0<void>::operator() (&param.D.48981);
                    D.51156 = sigc::slot0<{anonymous}::Derived>::operator() (&ret.D.50342); [return slot optimization]
                    {anonymous}::Derived::~Derived (&D.51156);
                    D.51156 = {CLOBBER};
                    std::allocator<char>::allocator (&D.51158);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.51159, "", &D.51158);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.51159);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.51159);
                            D.51159 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.51158);
                        D.51158 = {CLOBBER};
                      }
                    D.53640 = TestUtilities::get_result_and_delete_instance ();
                    if (D.53640 != 0) goto <D.53641>; else goto <D.53642>;
                    <D.53641>:
                    iftmp.3 = 0;
                    goto <D.53643>;
                    <D.53642>:
                    iftmp.3 = 1;
                    <D.53643>:
                    D.53624 = iftmp.3;
                    return D.53624;
                  }
                finally
                  {
                    sigc::slot<{anonymous}::Derived>::~slot (&ret);
                  }
              }
            finally
              {
                sigc::slot<void>::~slot (&param);
              }
          }
        finally
          {
            sigc::slot<void>::~slot (&handler);
          }
      }
    finally
      {
        handler = {CLOBBER};
        param = {CLOBBER};
        ret = {CLOBBER};
      }
  }
  D.53624 = 0;
  return D.53624;
}


void {anonymous}::Derived::method() (struct Derived * const this)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "method()");
}


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.53679;
  int (*__vtbl_ptr_type) () * D.53680;
  long int D.53681;
  sizetype D.53682;
  struct basic_ios * D.53683;
  long unsigned int D.53685;
  long int D.53686;
  struct basic_ostream & D.53687;

  if (__s == 0B) goto <D.53677>; else goto <D.53678>;
  <D.53677>:
  D.53679 = __out->_vptr.basic_ostream;
  D.53680 = D.53679 + 18446744073709551592;
  D.53681 = MEM[(long int *)D.53680];
  D.53682 = (sizetype) D.53681;
  D.53683 = __out + D.53682;
  std::basic_ios<char>::setstate (D.53683, 1);
  goto <D.53684>;
  <D.53678>:
  D.53685 = std::char_traits<char>::length (__s);
  D.53686 = (long int) D.53685;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.53686);
  <D.53684>:
  D.53687 = __out;
  return D.53687;
}


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.53689;
  _Ios_Iostate D.53690;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.53694;
  int __a.4;
  int __b.5;
  int D.53697;

  __a.4 = (int) __a;
  __b.5 = (int) __b;
  D.53697 = __a.4 | __b.5;
  D.53694 = (_Ios_Iostate) D.53697;
  return D.53694;
}


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

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


{anonymous}::Derived::Derived() (struct Derived * const this)
{
  struct trackable * D.53703;
  const void * * iftmp.6;
  struct Base * D.53711;
  struct Base2 * D.53713;
  int (*__vtbl_ptr_type) () * iftmp.7;
  const void * * D.53717;
  sizetype iftmp.8;
  int (*__vtbl_ptr_type) () * D.53722;
  int (*__vtbl_ptr_type) () * D.53723;
  long int D.53724;
  struct Base * D.53726;
  int (*__vtbl_ptr_type) () * iftmp.9;
  const void * * iftmp.10;

  if (1 != 0) goto <D.53701>; else goto <D.53702>;
  <D.53701>:
  D.53703 = &this->D.48790;
  sigc::trackable::trackable (D.53703);
  goto <D.53704>;
  <D.53702>:
  <D.53704>:
  try
    {
      if (1 != 0) goto <D.53705>; else goto <D.53706>;
      <D.53705>:
      if (1 == 0) goto <D.53708>; else goto <D.53709>;
      <D.53708>:
      iftmp.6 = 16B;
      goto <D.53710>;
      <D.53709>:
      iftmp.6 = &MEM[(void *)&_ZTTN12_GLOBAL__N_17DerivedE + 16B];
      <D.53710>:
      D.53711 = &this->D.48789;
      {anonymous}::Base::Base (D.53711, iftmp.6);
      goto <D.53712>;
      <D.53706>:
      <D.53712>:
      try
        {
          D.53713 = &this->D.48787;
          {anonymous}::Base2::Base2 (D.53713);
          try
            {
              if (1 == 0) goto <D.53715>; else goto <D.53716>;
              <D.53715>:
              D.53717 = 0B;
              iftmp.7 = *D.53717;
              goto <D.53718>;
              <D.53716>:
              iftmp.7 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 32B];
              <D.53718>:
              this->D.48787._vptr.Base2 = iftmp.7;
              if (1 == 0) goto <D.53720>; else goto <D.53721>;
              <D.53720>:
              D.53722 = this->D.48787._vptr.Base2;
              D.53723 = D.53722 + 18446744073709551592;
              D.53724 = MEM[(long int *)D.53723];
              iftmp.8 = (sizetype) D.53724;
              goto <D.53725>;
              <D.53721>:
              iftmp.8 = 8;
              <D.53725>:
              D.53726 = this + iftmp.8;
              if (1 == 0) goto <D.53728>; else goto <D.53729>;
              <D.53728>:
              iftmp.9 = MEM[(const void * *)0B + 8B];
              goto <D.53730>;
              <D.53729>:
              iftmp.9 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 72B];
              <D.53730>:
              D.53726->_vptr.Base = iftmp.9;
            }
          catch
            {
              D.53713 = &this->D.48787;
              {anonymous}::Base2::~Base2 (D.53713);
            }
        }
      catch
        {
          if (1 != 0) goto <D.53731>; else goto <D.53732>;
          <D.53731>:
          if (1 == 0) goto <D.53734>; else goto <D.53735>;
          <D.53734>:
          iftmp.10 = 16B;
          goto <D.53736>;
          <D.53735>:
          iftmp.10 = &MEM[(void *)&_ZTTN12_GLOBAL__N_17DerivedE + 16B];
          <D.53736>:
          D.53711 = &this->D.48789;
          {anonymous}::Base::~Base (D.53711, iftmp.10);
          goto <D.53737>;
          <D.53732>:
          <D.53737>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.53738>; else goto <D.53739>;
      <D.53738>:
      D.53703 = &this->D.48790;
      sigc::trackable::~trackable (D.53703);
      goto <D.53740>;
      <D.53739>:
      <D.53740>:
    }
}


{anonymous}::Base::Base() (struct Base * const this, const void * * __vtt_parm)
{
  struct trackable * D.53744;
  int (*__vtbl_ptr_type) () * iftmp.11;

  if (0 != 0) goto <D.53742>; else goto <D.53743>;
  <D.53742>:
  D.53744 = &this->D.48724;
  sigc::trackable::trackable (D.53744);
  goto <D.53745>;
  <D.53743>:
  <D.53745>:
  try
    {
      if (0 == 0) goto <D.53747>; else goto <D.53748>;
      <D.53747>:
      iftmp.11 = *__vtt_parm;
      goto <D.53749>;
      <D.53748>:
      iftmp.11 = &MEM[(void *)&_ZTVN12_GLOBAL__N_14BaseE + 24B];
      <D.53749>:
      this->_vptr.Base = iftmp.11;
    }
  catch
    {
      if (0 != 0) goto <D.53750>; else goto <D.53751>;
      <D.53750>:
      D.53744 = &this->D.48724;
      sigc::trackable::~trackable (D.53744);
      goto <D.53752>;
      <D.53751>:
      <D.53752>:
    }
}


{anonymous}::Base2::Base2() (struct Base2 * const this)
{
  this->_vptr.Base2 = &MEM[(void *)&_ZTVN12_GLOBAL__N_15Base2E + 16B];
}


virtual {anonymous}::Base2::~Base2() (struct Base2 * const this)
{
  {anonymous}::Base2::~Base2 (this);
  <D.48754>:
  operator delete (this);
}


{anonymous}::Base2::~Base2() (struct Base2 * const this)
{
  int D.53753;

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

      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48750>:
  D.53753 = 0;
  if (D.53753 != 0) goto <D.53754>; else goto <D.53755>;
  <D.53754>:
  operator delete (this);
  goto <D.53756>;
  <D.53755>:
  <D.53756>:
}


sigc::bound_mem_functor0<T_return, T_obj> sigc::mem_fun(T_obj*, T_return (T_obj2::*)()) [with T_return = void; T_obj = {anonymous}::Derived; T_obj2 = {anonymous}::Derived] (struct Derived * _A_obj, struct 
{
  void Derived::<T8b2c> (struct Derived *) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor0<void, {anonymous}::Derived>::bound_mem_functor0 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor0<T_return, T_obj>::bound_mem_functor0(T_obj*, sigc::bound_mem_functor0<T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::Derived; sigc::bound_mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::Derived::*)()] (struct bound_mem_functor0 * const this, struct Derived * _A_obj, struct function_type _A_func)
{
  struct mem_functor0 * D.53759;
  struct limit_reference * D.53760;

  D.53759 = &this->D.49094;
  sigc::mem_functor0<void, {anonymous}::Derived>::mem_functor0 (D.53759, _A_func);
  D.53760 = &this->obj_;
  sigc::limit_reference<{anonymous}::Derived, true>::limit_reference (D.53760, _A_obj);
}


sigc::mem_functor0<T_return, T_obj>::mem_functor0(sigc::mem_functor0<T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::Derived; sigc::mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::Derived::*)()] (struct mem_functor0 * 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}::Derived] (struct limit_reference * const this, struct Derived & _A_target)
{
  int (*__vtbl_ptr_type) () * D.53761;
  int (*__vtbl_ptr_type) () * D.53762;
  long int D.53763;
  sizetype D.53764;
  struct trackable * D.53765;

  D.53761 = _A_target->D.48787._vptr.Base2;
  D.53762 = D.53761 + 18446744073709551584;
  D.53763 = MEM[(long int *)D.53762];
  D.53764 = (sizetype) D.53763;
  D.53765 = _A_target + D.53764;
  this->visited = D.53765;
  this->invoked = _A_target;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>; T_return = void] (struct slot * const this, const struct bound_mem_functor0 & _A_func)
{
  struct slot0 * D.53766;

  D.53766 = &this->D.48981;
  sigc::slot0<void>::slot0<sigc::bound_mem_functor0<void, {anonymous}::Derived> > (D.53766, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>; T_return = void] (struct slot0 * const this, const struct bound_mem_functor0 & _A_func)
{
  void * D.52195;
  struct slot_base * D.53767;
  struct rep_type * D.53768;
  void * (*<T1711>) (void *) D.53769;

  D.52195 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::typed_slot_rep (D.52195, _A_func);
    }
  catch
    {
      operator delete (D.52195);
    }
  D.53767 = &this->D.48939;
  sigc::slot_base::slot_base (D.53767, D.52195);
  try
    {
      D.53768 = this->D.48939.rep_;
      D.53769 = sigc::internal::slot_call0<sigc::bound_mem_functor0<void, {anonymous}::Derived>, void>::address ();
      D.53768->call_ = D.53769;
    }
  catch
    {
      D.53767 = &this->D.48939;
      sigc::slot_base::~slot_base (D.53767);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>] (struct typed_slot_rep * const this, const struct bound_mem_functor0 & functor)
{
  struct slot_rep * D.53772;
  struct adaptor_type * D.53773;
  struct slot_do_bind D.52595;

  D.53772 = &this->D.52184;
  sigc::internal::slot_rep::slot_rep (D.53772, 0B, destroy, dup);
  try
    {
      D.53773 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::adaptor_functor (D.53773, functor);
      D.53773 = &this->functor_;
      D.53772 = &this->D.52184;
      sigc::internal::slot_do_bind::slot_do_bind (&D.52595, D.53772);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> > > (&D.52595, D.53773);
        }
      finally
        {
          D.52595 = {CLOBBER};
        }
    }
  catch
    {
      D.53772 = &this->D.52184;
      sigc::internal::slot_rep::~slot_rep (D.53772);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>] (void * data)
{
  void * D.53776;
  void * D.52762;
  struct slot_rep * a_rep;

  a_rep = data;
  D.52762 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::typed_slot_rep (D.52762, a_rep);
    }
  catch
    {
      operator delete (D.52762);
    }
  D.53776 = D.52762;
  return D.53776;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.53780;
  struct slot_rep * D.53781;
  struct adaptor_type * D.53782;
  struct slot_do_bind D.52920;

  D.53780 = cl->D.52184.call_;
  D.53781 = &this->D.52184;
  sigc::internal::slot_rep::slot_rep (D.53781, D.53780, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.53782 = &this->functor_;
      D.53781 = &this->D.52184;
      sigc::internal::slot_do_bind::slot_do_bind (&D.52920, D.53781);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> > > (&D.52920, D.53782);
        }
      finally
        {
          D.52920 = {CLOBBER};
        }
    }
  catch
    {
      D.53781 = &this->D.52184;
      sigc::internal::slot_rep::~slot_rep (D.53781);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>] (void * data)
{
  struct adaptor_type * D.53785;
  struct slot_do_unbind D.52747;
  void * D.53786;
  struct self * self_;

  self_ = data;
  self_->D.52184.call_ = 0B;
  self_->D.52184.destroy_ = 0B;
  D.53785 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.52747, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> > > (&D.52747, D.53785);
    }
  finally
    {
      D.52747 = {CLOBBER};
    }
  D.53786 = 0B;
  return D.53786;
}


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


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

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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> > >::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_functor0<void, {anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor0 * D.53790;

  D.53790 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor0<void, {anonymous}::Derived> > (_A_action, D.53790);
}


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_functor0<void, {anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::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_functor0<T_return, T_obj> >::do_visit_each(const T_action&, const sigc::bound_mem_functor0<T_return, T_obj>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_obj = {anonymous}::Derived] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.53791;

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


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

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


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

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


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

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

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


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

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


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


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


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


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

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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> > >::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_functor0<void, {anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor0 * D.53799;

  D.53799 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor0<void, {anonymous}::Derived> > (_A_action, D.53799);
}


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_functor0<void, {anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::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_functor0<T_return, T_obj> >::do_visit_each(const T_action&, const sigc::bound_mem_functor0<T_return, T_obj>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_obj = {anonymous}::Derived] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.53800;

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


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

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


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

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

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


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

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


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

  D.53807 = this->destroy_;
  if (D.53807 != 0B) goto <D.53808>; else goto <D.53809>;
  <D.53808>:
  D.53807 = this->destroy_;
  D.53807 (this);
  goto <D.53810>;
  <D.53809>:
  <D.53810>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.53811;

  D.53811 = call_it;
  return D.53811;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.53813;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.53813 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::Derived> >::operator() (D.53813);
  return;
}


sigc::adaptor_functor<T_functor>::result_type sigc::adaptor_functor<T_functor>::operator()() const [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::Derived>; sigc::adaptor_functor<T_functor>::result_type = void] (const struct adaptor_functor * const this)
{
  struct bound_mem_functor0 * D.53815;

  D.53815 = &this->functor_;
  sigc::bound_mem_functor0<void, {anonymous}::Derived>::operator() (D.53815);
  return;
}


T_return sigc::bound_mem_functor0<T_return, T_obj>::operator()() const [with T_return = void; T_obj = {anonymous}::Derived] (const struct bound_mem_functor0 * const this)
{
  const struct limit_reference * D.53817;
  struct Derived & D.53818;
  void Derived::<T8b2c> (struct Derived *) * iftmp.12;
  void Derived::<T8b2c> (struct Derived *) * D.53820;
  long int D.53821;
  long int D.53822;
  long int D.53826;
  sizetype D.53827;
  struct Derived * D.53828;
  int (*__vtbl_ptr_type) () * D.53829;
  long int D.53830;
  sizetype D.53831;
  int (*__vtbl_ptr_type) () * D.53832;

  D.53817 = &this->obj_;
  D.53818 = sigc::limit_reference<{anonymous}::Derived, true>::invoke (D.53817);
  D.53820 = this->D.49094.func_ptr_.__pfn;
  D.53821 = (long int) D.53820;
  D.53822 = D.53821 & 1;
  if (D.53822 == 0) goto <D.53823>; else goto <D.53824>;
  <D.53823>:
  iftmp.12 = this->D.49094.func_ptr_.__pfn;
  goto <D.53825>;
  <D.53824>:
  D.53826 = this->D.49094.func_ptr_.__delta;
  D.53827 = (sizetype) D.53826;
  D.53828 = D.53818 + D.53827;
  D.53829 = MEM[(int (*__vtbl_ptr_type) () * *)D.53828];
  D.53820 = this->D.49094.func_ptr_.__pfn;
  D.53821 = (long int) D.53820;
  D.53830 = D.53821 + -1;
  D.53831 = (sizetype) D.53830;
  D.53832 = D.53829 + D.53831;
  iftmp.12 = *D.53832;
  <D.53825>:
  D.53826 = this->D.49094.func_ptr_.__delta;
  D.53827 = (sizetype) D.53826;
  D.53828 = D.53818 + D.53827;
  iftmp.12 (D.53828);
  return;
}


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

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


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot() [with T_return = void; T_arg1 = {anonymous}::Derived&] (struct slot * const this)
{
  struct slot1 * D.53836;

  D.53836 = &this->D.49253;
  sigc::slot1<void, {anonymous}::Derived&>::slot1 (D.53836);
  try
    {

    }
  catch
    {
      D.53836 = &this->D.49253;
      sigc::slot1<void, {anonymous}::Derived&>::~slot1 (D.53836);
    }
}


sigc::slot1<T_return, T_arg1>::slot1() [with T_return = void; T_arg1 = {anonymous}::Derived&] (struct slot1 * const this)
{
  struct slot_base * D.53837;

  D.53837 = &this->D.49211;
  sigc::slot_base::slot_base (D.53837);
  try
    {

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


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void, {anonymous}::Derived&>] (const struct slot & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>; T_type1 = sigc::reference_wrapper<{anonymous}::Derived>; typename sigc::type_trait<T_base>::take = const sigc::slot<void, {anonymous}::Derived&>&; typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<{anonymous}::Derived>&] (struct bind_functor * const this, const struct slot & _A_func, const struct reference_wrapper & _A_bound1)
{
  struct adapts * D.53840;
  struct bound_argument * D.53841;

  D.53840 = &this->D.50167;
  sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::adapts (D.53840, _A_func);
  try
    {
      D.53841 = &this->bound1_;
      sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::bound_argument (D.53841, _A_bound1);
    }
  catch
    {
      D.53840 = &this->D.50167;
      sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::~adapts (D.53840);
    }
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::slot<void, {anonymous}::Derived&>] (struct adapts * const this, const struct slot & _A_functor)
{
  struct adaptor_type * D.53843;

  sigc::adaptor_base::adaptor_base (this);
  D.53843 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::adaptor_functor (D.53843, _A_functor);
  try
    {

    }
  catch
    {
      D.53843 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::~adaptor_functor (D.53843);
    }
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::slot<void, {anonymous}::Derived&>] (struct adaptor_functor * const this, const struct slot & _A_functor)
{
  struct slot * D.53844;

  sigc::adaptor_base::adaptor_base (this);
  D.53844 = &this->functor_;
  sigc::slot<void, {anonymous}::Derived&>::slot (D.53844, _A_functor);
  try
    {

    }
  catch
    {
      D.53844 = &this->functor_;
      sigc::slot<void, {anonymous}::Derived&>::~slot (D.53844);
    }
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = {anonymous}::Derived&] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.53845;

  D.53845 = &this->D.49253;
  sigc::slot1<void, {anonymous}::Derived&>::slot1 (D.53845, src);
  try
    {

    }
  catch
    {
      D.53845 = &this->D.49253;
      sigc::slot1<void, {anonymous}::Derived&>::~slot1 (D.53845);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = {anonymous}::Derived&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.53846;
  struct slot_base * D.53847;

  D.53846 = &src->D.49211;
  D.53847 = &this->D.49211;
  sigc::slot_base::slot_base (D.53847, D.53846);
  try
    {

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


sigc::bound_argument<sigc::reference_wrapper<T_type> >::bound_argument(const sigc::reference_wrapper<T_type>&) [with T_wrapped = {anonymous}::Derived] (struct bound_argument * const this, const struct reference_wrapper & _A_argument)
{
  struct Derived & D.53848;
  struct limit_reference * D.53849;

  D.53848 = sigc::unwrap<{anonymous}::Derived> (_A_argument);
  D.53849 = &this->visited_;
  sigc::limit_reference<{anonymous}::Derived, true>::limit_reference (D.53849, D.53848);
}


T_type& sigc::unwrap(const sigc::reference_wrapper<T_type>&) [with T_type = {anonymous}::Derived] (const struct reference_wrapper & v)
{
  struct Derived & D.53851;

  D.53851 = sigc::reference_wrapper<{anonymous}::Derived>::operator {anonymous}::Derived& (v);
  return D.53851;
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = {anonymous}::Derived] (const struct reference_wrapper * const this)
{
  struct Derived & D.53853;

  D.53853 = this->value_;
  return D.53853;
}


sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::~adapts() (struct adapts * const this)
{
  struct adaptor_type * D.53855;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.53855 = &this->functor_;
            sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::~adaptor_functor (D.53855);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50229>:
}


sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::~adaptor_functor() (struct adaptor_functor * const this)
{
  struct slot * D.53857;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.53857 = &this->functor_;
            sigc::slot<void, {anonymous}::Derived&>::~slot (D.53857);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50224>:
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot * const this, const struct bind_functor & _A_func)
{
  struct slot0 * D.53859;

  D.53859 = &this->D.48981;
  sigc::slot0<void>::slot0<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.53859, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot0 * const this, const struct bind_functor & _A_func)
{
  void * D.52315;
  struct slot_base * D.53860;
  struct rep_type * D.53861;
  void * (*<T1711>) (void *) D.53862;

  D.52315 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.52315, _A_func);
    }
  catch
    {
      operator delete (D.52315);
    }
  D.53860 = &this->D.48939;
  sigc::slot_base::slot_base (D.53860, D.52315);
  try
    {
      D.53861 = this->D.48939.rep_;
      D.53862 = sigc::internal::slot_call0<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void>::address ();
      D.53861->call_ = D.53862;
    }
  catch
    {
      D.53860 = &this->D.48939;
      sigc::slot_base::~slot_base (D.53860);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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.53865;
  struct adaptor_type * D.53866;
  struct slot_do_bind D.52642;

  D.53865 = &this->D.52304;
  sigc::internal::slot_rep::slot_rep (D.53865, 0B, destroy, dup);
  try
    {
      D.53866 = &this->functor_;
      sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (D.53866, functor);
      try
        {
          D.53866 = &this->functor_;
          D.53865 = &this->D.52304;
          sigc::internal::slot_do_bind::slot_do_bind (&D.52642, D.53865);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52642, D.53866);
            }
          finally
            {
              D.52642 = {CLOBBER};
            }
        }
      catch
        {
          D.53866 = &this->functor_;
          sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.53866);
        }
    }
  catch
    {
      D.53865 = &this->D.52304;
      sigc::internal::slot_rep::~slot_rep (D.53865);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.53870;
  void * D.52822;
  struct slot_rep * a_rep;

  a_rep = data;
  D.52822 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.52822, a_rep);
    }
  catch
    {
      operator delete (D.52822);
    }
  D.53870 = D.52822;
  return D.53870;
}


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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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.53874;
  struct slot_rep * D.53875;
  const struct adaptor_type * D.53876;
  struct adaptor_type * D.53877;
  struct slot_do_bind D.52952;

  D.53874 = cl->D.52304.call_;
  D.53875 = &this->D.52304;
  sigc::internal::slot_rep::slot_rep (D.53875, D.53874, destroy, dup);
  try
    {
      D.53876 = &cl->functor_;
      D.53877 = &this->functor_;
      sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (D.53877, D.53876);
      try
        {
          D.53877 = &this->functor_;
          D.53875 = &this->D.52304;
          sigc::internal::slot_do_bind::slot_do_bind (&D.52952, D.53875);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52952, D.53877);
            }
          finally
            {
              D.52952 = {CLOBBER};
            }
        }
      catch
        {
          D.53877 = &this->functor_;
          sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.53877);
        }
    }
  catch
    {
      D.53875 = &this->D.52304;
      sigc::internal::slot_rep::~slot_rep (D.53875);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.53881;
  struct slot_do_unbind D.52816;
  void * D.53882;
  struct self * self_;

  self_ = data;
  self_->D.52304.call_ = 0B;
  self_->D.52304.destroy_ = 0B;
  D.53881 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.52816, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52816, D.53881);
    }
  finally
    {
      D.52816 = {CLOBBER};
    }
  D.53881 = &self_->functor_;
  sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.53881);
  D.53882 = 0B;
  return D.53882;
}


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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>; T_type1 = sigc::reference_wrapper<{anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.53886;
  const struct bound_argument * D.53887;

  D.53886 = &_A_target->D.50167.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> > > (_A_action, D.53886);
  D.53887 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > > (_A_action, D.53887);
}


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::slot<void, {anonymous}::Derived&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> > >::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::slot<void, {anonymous}::Derived&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.53888;

  D.53888 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::slot<void, {anonymous}::Derived&> > (_A_action, D.53888);
}


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<void, {anonymous}::Derived&>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<void, {anonymous}::Derived&>, 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 = sigc::slot<void, {anonymous}::Derived&>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct slot & D.53446, const struct limit_derived_target & D.53447)
{
  GIMPLE_NOP
}


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<sigc::reference_wrapper<{anonymous}::Derived> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > >::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 = sigc::reference_wrapper<{anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.53889;

  D.53889 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<{anonymous}::Derived, true> > (_A_action, D.53889);
}


const sigc::limit_reference<T_wrapped>& sigc::bound_argument<sigc::reference_wrapper<T_type> >::visit() const [with T_wrapped = {anonymous}::Derived] (const struct bound_argument * const this)
{
  const struct limit_reference & D.53890;

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


sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(const sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) (struct bind_functor * const this, const struct bind_functor & D.51476)
{
  const struct adapts * D.53892;
  struct adapts * D.53893;

  D.53892 = &D.51476->D.50167;
  D.53893 = &this->D.50167;
  sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::adapts (D.53893, D.53892);
  try
    {
      this->bound1_ = D.51476->bound1_;
    }
  catch
    {
      D.53893 = &this->D.50167;
      sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::~adapts (D.53893);
    }
}


sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::adapts(const sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >&) (struct adapts * const this, const struct adapts & D.51458)
{
  struct adaptor_type * D.53894;
  struct adaptor_type * D.53895;

  D.53894 = &D.51458->functor_;
  D.53895 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::adaptor_functor (D.53895, D.53894);
  try
    {

    }
  catch
    {
      D.53895 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::~adaptor_functor (D.53895);
    }
}


sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::adaptor_functor(const sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >&) (struct adaptor_functor * const this, const struct adaptor_functor & D.51440)
{
  struct slot * D.53896;
  struct slot * D.53897;

  D.53896 = &D.51440->functor_;
  D.53897 = &this->functor_;
  sigc::slot<void, {anonymous}::Derived&>::slot (D.53897, D.53896);
  try
    {

    }
  catch
    {
      D.53897 = &this->functor_;
      sigc::slot<void, {anonymous}::Derived&>::~slot (D.53897);
    }
}


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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, 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::slot<void, {anonymous}::Derived&>; T_type1 = sigc::reference_wrapper<{anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.53899;
  const struct bound_argument * D.53900;

  D.53899 = &_A_target->D.50167.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> > > (_A_action, D.53899);
  D.53900 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > > (_A_action, D.53900);
}


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::slot<void, {anonymous}::Derived&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> > >::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::slot<void, {anonymous}::Derived&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.53901;

  D.53901 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::slot<void, {anonymous}::Derived&> > (_A_action, D.53901);
}


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<void, {anonymous}::Derived&>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<void, {anonymous}::Derived&>, 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 = sigc::slot<void, {anonymous}::Derived&>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct slot & D.53401, const struct limit_derived_target & D.53402)
{
  GIMPLE_NOP
}


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<sigc::reference_wrapper<{anonymous}::Derived> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > >::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 = sigc::reference_wrapper<{anonymous}::Derived>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.53902;

  D.53902 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<{anonymous}::Derived, true> > (_A_action, D.53902);
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.53903;

  D.53903 = call_it;
  return D.53903;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.53905;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.53905 = &typed_rep->functor_;
  sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (D.53905);
  return;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = sigc::slot<void, {anonymous}::Derived&>; T_type1 = sigc::reference_wrapper<{anonymous}::Derived>; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = void] (struct bind_functor * const this)
{
  struct bound_argument * D.53907;
  struct Derived & D.53908;
  struct adaptor_type * D.53909;

  D.53907 = &this->bound1_;
  D.53908 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::invoke (D.53907);
  D.53909 = &this->D.50167.functor_;
  sigc::adaptor_functor<sigc::slot<void, {anonymous}::Derived&> >::operator()<{anonymous}::Derived&> (D.53909, D.53908);
  return;
}


T_wrapped& sigc::bound_argument<sigc::reference_wrapper<T_type> >::invoke() [with T_wrapped = {anonymous}::Derived] (struct bound_argument * const this)
{
  struct Derived & D.53912;
  struct limit_reference * D.53913;

  D.53913 = &this->visited_;
  D.53912 = sigc::limit_reference<{anonymous}::Derived, true>::invoke (D.53913);
  return D.53912;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = {anonymous}::Derived&; T_functor = sigc::slot<void, {anonymous}::Derived&>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, struct Derived & _A_arg1)
{
  struct slot1 * D.53915;

  D.53915 = &this->functor_.D.49253;
  sigc::slot1<void, {anonymous}::Derived&>::operator() (D.53915, _A_arg1);
  return;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = {anonymous}::Derived&; sigc::slot1<T_return, T_arg1>::arg1_type_ = {anonymous}::Derived&] (const struct slot1 * const this, struct Derived & _A_a1)
{
  bool retval.13;
  bool iftmp.14;
  const struct slot_base * D.53921;
  bool D.53922;
  bool D.53923;
  bool D.53925;
  bool D.53926;
  struct rep_type * D.53930;
  void * (*<T1711>) (void *) D.53931;

  D.53921 = &this->D.49211;
  D.53922 = sigc::slot_base::empty (D.53921);
  D.53923 = ~D.53922;
  if (D.53923 != 0) goto <D.53924>; else goto <D.53919>;
  <D.53924>:
  D.53921 = &this->D.49211;
  D.53925 = sigc::slot_base::blocked (D.53921);
  D.53926 = ~D.53925;
  if (D.53926 != 0) goto <D.53927>; else goto <D.53919>;
  <D.53927>:
  iftmp.14 = 1;
  goto <D.53920>;
  <D.53919>:
  iftmp.14 = 0;
  <D.53920>:
  retval.13 = iftmp.14;
  if (retval.13 != 0) goto <D.53928>; else goto <D.53929>;
  <D.53928>:
  D.53930 = this->D.49211.rep_;
  D.53931 = D.53930->call_;
  D.53930 = this->D.49211.rep_;
  D.53931 (D.53930, _A_a1);
  return;
  <D.53929>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.53933;
  bool iftmp.15;
  struct rep_type * D.53938;
  void * (*<T1711>) (void *) D.53940;

  D.53938 = this->rep_;
  if (D.53938 == 0B) goto <D.53935>; else goto <D.53939>;
  <D.53939>:
  D.53938 = this->rep_;
  D.53940 = D.53938->call_;
  if (D.53940 == 0B) goto <D.53935>; else goto <D.53936>;
  <D.53935>:
  iftmp.15 = 1;
  goto <D.53937>;
  <D.53936>:
  iftmp.15 = 0;
  <D.53937>:
  D.53933 = iftmp.15;
  return D.53933;
}


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

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


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::Derived] (struct Derived & v)
{
  struct reference_wrapper D.53944;
  struct reference_wrapper D.51406;

  sigc::reference_wrapper<{anonymous}::Derived>::reference_wrapper (&D.51406, v);
  try
    {
      D.53944 = D.51406;
      return D.53944;
    }
  finally
    {
      D.51406 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::reference_wrapper(T_type&) [with T_type = {anonymous}::Derived] (struct reference_wrapper * const this, struct Derived & v)
{
  this->value_ = v;
}


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

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

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


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

  D.53948 = &this->D.48939;
  sigc::slot_base::slot_base (D.53948);
  try
    {

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


sigc::bind_return_functor<T_return, T_functor> sigc::bind_return(const T_functor&, T_return) [with T_return = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void>] (const struct slot & _A_functor, struct reference_wrapper _A_ret_value)
{
  sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::bind_return_functor (<retval>, _A_functor, &_A_ret_value);
  return <retval>;
}


sigc::bind_return_functor<T_return, T_functor>::bind_return_functor(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_base>::take) [with T_return = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void>; typename sigc::type_trait<T_derived>::take = const sigc::slot<void>&; typename sigc::type_trait<T_base>::take = const sigc::reference_wrapper<{anonymous}::Derived>&] (struct bind_return_functor * const this, const struct slot & _A_functor, const struct reference_wrapper & _A_ret_value)
{
  struct adapts * D.53951;
  struct bound_argument * D.53952;

  D.53951 = &this->D.51049;
  sigc::adapts<sigc::slot<void> >::adapts (D.53951, _A_functor);
  try
    {
      D.53952 = &this->ret_value_;
      sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::bound_argument (D.53952, _A_ret_value);
    }
  catch
    {
      D.53951 = &this->D.51049;
      sigc::adapts<sigc::slot<void> >::~adapts (D.53951);
    }
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::slot<void>] (struct adapts * const this, const struct slot & _A_functor)
{
  struct adaptor_type * D.53954;

  sigc::adaptor_base::adaptor_base (this);
  D.53954 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<void> >::adaptor_functor (D.53954, _A_functor);
  try
    {

    }
  catch
    {
      D.53954 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<void> >::~adaptor_functor (D.53954);
    }
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::slot<void>] (struct adaptor_functor * const this, const struct slot & _A_functor)
{
  struct slot * D.53955;

  sigc::adaptor_base::adaptor_base (this);
  D.53955 = &this->functor_;
  sigc::slot<void>::slot (D.53955, _A_functor);
  try
    {

    }
  catch
    {
      D.53955 = &this->functor_;
      sigc::slot<void>::~slot (D.53955);
    }
}


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

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

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


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

  D.53957 = &src->D.48939;
  D.53958 = &this->D.48939;
  sigc::slot_base::slot_base (D.53958, D.53957);
  try
    {

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


sigc::adapts<sigc::slot<void> >::~adapts() (struct adapts * const this)
{
  struct adaptor_type * D.53959;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.53959 = &this->functor_;
            sigc::adaptor_functor<sigc::slot<void> >::~adaptor_functor (D.53959);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51093>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.53961 = &this->functor_;
            sigc::slot<void>::~slot (D.53961);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51088>:
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >; T_return = {anonymous}::Derived] (struct slot * const this, const struct bind_return_functor & _A_func)
{
  struct slot0 * D.53963;

  D.53963 = &this->D.50342;
  sigc::slot0<{anonymous}::Derived>::slot0<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (D.53963, _A_func);
  try
    {

    }
  catch
    {
      D.53963 = &this->D.50342;
      sigc::slot0<{anonymous}::Derived>::~slot0 (D.53963);
    }
}


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >; T_return = {anonymous}::Derived] (struct slot0 * const this, const struct bind_return_functor & _A_func)
{
  void * D.52394;
  struct slot_base * D.53964;
  struct rep_type * D.53965;
  void * (*<T1711>) (void *) D.53966;

  D.52394 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > >::typed_slot_rep (D.52394, _A_func);
    }
  catch
    {
      operator delete (D.52394);
    }
  D.53964 = &this->D.50300;
  sigc::slot_base::slot_base (D.53964, D.52394);
  try
    {
      D.53965 = this->D.50300.rep_;
      D.53966 = sigc::internal::slot_call0<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >, {anonymous}::Derived>::address ();
      D.53965->call_ = D.53966;
    }
  catch
    {
      D.53964 = &this->D.50300;
      sigc::slot_base::~slot_base (D.53964);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (struct typed_slot_rep * const this, const struct bind_return_functor & functor)
{
  struct slot_rep * D.53969;
  struct adaptor_type * D.53970;
  struct slot_do_bind D.52663;

  D.53969 = &this->D.52383;
  sigc::internal::slot_rep::slot_rep (D.53969, 0B, destroy, dup);
  try
    {
      D.53970 = &this->functor_;
      sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::bind_return_functor (D.53970, functor);
      try
        {
          D.53970 = &this->functor_;
          D.53969 = &this->D.52383;
          sigc::internal::slot_do_bind::slot_do_bind (&D.52663, D.53969);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&D.52663, D.53970);
            }
          finally
            {
              D.52663 = {CLOBBER};
            }
        }
      catch
        {
          D.53970 = &this->functor_;
          sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::~bind_return_functor (D.53970);
        }
    }
  catch
    {
      D.53969 = &this->D.52383;
      sigc::internal::slot_rep::~slot_rep (D.53969);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (void * data)
{
  void * D.53974;
  void * D.52843;
  struct slot_rep * a_rep;

  a_rep = data;
  D.52843 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > >::typed_slot_rep (D.52843, a_rep);
    }
  catch
    {
      operator delete (D.52843);
    }
  D.53974 = D.52843;
  return D.53974;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.53978;
  struct slot_rep * D.53979;
  const struct adaptor_type * D.53980;
  struct adaptor_type * D.53981;
  struct slot_do_bind D.53101;

  D.53978 = cl->D.52383.call_;
  D.53979 = &this->D.52383;
  sigc::internal::slot_rep::slot_rep (D.53979, D.53978, destroy, dup);
  try
    {
      D.53980 = &cl->functor_;
      D.53981 = &this->functor_;
      sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::bind_return_functor (D.53981, D.53980);
      try
        {
          D.53981 = &this->functor_;
          D.53979 = &this->D.52383;
          sigc::internal::slot_do_bind::slot_do_bind (&D.53101, D.53979);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&D.53101, D.53981);
            }
          finally
            {
              D.53101 = {CLOBBER};
            }
        }
      catch
        {
          D.53981 = &this->functor_;
          sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::~bind_return_functor (D.53981);
        }
    }
  catch
    {
      D.53979 = &this->D.52383;
      sigc::internal::slot_rep::~slot_rep (D.53979);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (void * data)
{
  struct adaptor_type * D.53985;
  struct slot_do_unbind D.52837;
  void * D.53986;
  struct self * self_;

  self_ = data;
  self_->D.52383.call_ = 0B;
  self_->D.52383.destroy_ = 0B;
  D.53985 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.52837, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&D.52837, D.53985);
    }
  finally
    {
      D.52837 = {CLOBBER};
    }
  D.53985 = &self_->functor_;
  sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::~bind_return_functor (D.53985);
  D.53986 = 0B;
  return D.53986;
}


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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (const struct slot_do_unbind & _A_action, const struct bind_return_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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_functor)
{
  sigc::visitor<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > >::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_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::bind_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void>] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_target)
{
  const struct bound_argument * D.53990;
  struct adaptor_type * D.53991;

  D.53990 = &_A_target->ret_value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > > (_A_action, D.53990);
  D.53991 = &_A_target->D.51049.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::slot<void> > > (_A_action, D.53991);
}


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::slot<void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<void> > >::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::slot<void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.53992;

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


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<void>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<void>, 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 = sigc::slot<void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct slot & D.53454, const struct limit_derived_target & D.53455)
{
  GIMPLE_NOP
}


sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::bind_return_functor(const sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >&) (struct bind_return_functor * const this, const struct bind_return_functor & D.51538)
{
  const struct adapts * D.53993;
  struct adapts * D.53994;

  D.53993 = &D.51538->D.51049;
  D.53994 = &this->D.51049;
  sigc::adapts<sigc::slot<void> >::adapts (D.53994, D.53993);
  try
    {
      this->ret_value_ = D.51538->ret_value_;
    }
  catch
    {
      D.53994 = &this->D.51049;
      sigc::adapts<sigc::slot<void> >::~adapts (D.53994);
    }
}


sigc::adapts<sigc::slot<void> >::adapts(const sigc::adapts<sigc::slot<void> >&) (struct adapts * const this, const struct adapts & D.51529)
{
  struct adaptor_type * D.53995;
  struct adaptor_type * D.53996;

  D.53995 = &D.51529->functor_;
  D.53996 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<void> >::adaptor_functor (D.53996, D.53995);
  try
    {

    }
  catch
    {
      D.53996 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<void> >::~adaptor_functor (D.53996);
    }
}


sigc::adaptor_functor<sigc::slot<void> >::adaptor_functor(const sigc::adaptor_functor<sigc::slot<void> >&) (struct adaptor_functor * const this, const struct adaptor_functor & D.51511)
{
  struct slot * D.53997;
  struct slot * D.53998;

  D.53997 = &D.51511->functor_;
  D.53998 = &this->functor_;
  sigc::slot<void>::slot (D.53998, D.53997);
  try
    {

    }
  catch
    {
      D.53998 = &this->functor_;
      sigc::slot<void>::~slot (D.53998);
    }
}


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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (const struct slot_do_bind & _A_action, const struct bind_return_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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_functor)
{
  sigc::visitor<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> > >::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_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::bind_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void>] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_target)
{
  const struct bound_argument * D.54000;
  struct adaptor_type * D.54001;

  D.54000 = &_A_target->ret_value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> > > (_A_action, D.54000);
  D.54001 = &_A_target->D.51049.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::slot<void> > > (_A_action, D.54001);
}


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::slot<void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<void> > >::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::slot<void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.54002;

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


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<void>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<void>, 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 = sigc::slot<void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct slot & D.53427, const struct limit_derived_target & D.53428)
{
  GIMPLE_NOP
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >; T_return = {anonymous}::Derived; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.54003;

  D.54003 = call_it;
  return D.54003;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >; T_return = {anonymous}::Derived] (struct slot_rep * rep)
{
  struct adaptor_type * D.54006;
  struct Derived & D.54007;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.54006 = &typed_rep->functor_;
  D.54007 = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::operator() (D.54006);
  {anonymous}::Derived::Derived (<retval>, D.54007);
  return <retval>;
}


typename sigc::unwrap_reference<T_type>::type sigc::bind_return_functor<T_return, T_functor>::operator()() [with T_return = sigc::reference_wrapper<{anonymous}::Derived>; T_functor = sigc::slot<void>; typename sigc::unwrap_reference<T_type>::type = {anonymous}::Derived&] (struct bind_return_functor * const this)
{
  struct adaptor_type * D.54010;
  struct Derived & D.54011;
  struct bound_argument * D.54012;

  D.54010 = &this->D.51049.functor_;
  sigc::adaptor_functor<sigc::slot<void> >::operator() (D.54010);
  D.54012 = &this->ret_value_;
  D.54011 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Derived> >::invoke (D.54012);
  return D.54011;
}


sigc::adaptor_functor<T_functor>::result_type sigc::adaptor_functor<T_functor>::operator()() const [with T_functor = sigc::slot<void>; sigc::adaptor_functor<T_functor>::result_type = void] (const struct adaptor_functor * const this)
{
  struct slot0 * D.54015;

  D.54015 = &this->functor_.D.48981;
  sigc::slot0<void>::operator() (D.54015);
  return;
}


{anonymous}::Derived::Derived(const {anonymous}::Derived&) (struct Derived * const this, const struct Derived & D.48866)
{
  int (*__vtbl_ptr_type) () * D.54019;
  int (*__vtbl_ptr_type) () * D.54020;
  long int D.54021;
  sizetype D.54022;
  const struct trackable * D.54023;
  struct trackable * D.54024;
  int (*__vtbl_ptr_type) () * D.54028;
  long int D.54029;
  sizetype D.54030;
  const struct Base * D.54031;
  const void * * iftmp.16;
  struct Base * D.54036;
  const struct Base2 * D.54038;
  struct Base2 * D.54039;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.54043;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.54048;
  int (*__vtbl_ptr_type) () * D.54049;
  long int D.54050;
  struct Base * D.54052;
  int (*__vtbl_ptr_type) () * iftmp.19;
  const void * * iftmp.20;

  if (1 != 0) goto <D.54017>; else goto <D.54018>;
  <D.54017>:
  D.54019 = D.48866->D.48787._vptr.Base2;
  D.54020 = D.54019 + 18446744073709551584;
  D.54021 = MEM[(long int *)D.54020];
  D.54022 = (sizetype) D.54021;
  D.54023 = D.48866 + D.54022;
  D.54024 = &this->D.48790;
  sigc::trackable::trackable (D.54024, D.54023);
  goto <D.54025>;
  <D.54018>:
  <D.54025>:
  try
    {
      if (1 != 0) goto <D.54026>; else goto <D.54027>;
      <D.54026>:
      D.54019 = D.48866->D.48787._vptr.Base2;
      D.54028 = D.54019 + 18446744073709551592;
      D.54029 = MEM[(long int *)D.54028];
      D.54030 = (sizetype) D.54029;
      D.54031 = D.48866 + D.54030;
      if (1 == 0) goto <D.54033>; else goto <D.54034>;
      <D.54033>:
      iftmp.16 = 16B;
      goto <D.54035>;
      <D.54034>:
      iftmp.16 = &MEM[(void *)&_ZTTN12_GLOBAL__N_17DerivedE + 16B];
      <D.54035>:
      D.54036 = &this->D.48789;
      {anonymous}::Base::Base (D.54036, iftmp.16, D.54031);
      goto <D.54037>;
      <D.54027>:
      <D.54037>:
      try
        {
          D.54038 = &D.48866->D.48787;
          D.54039 = &this->D.48787;
          {anonymous}::Base2::Base2 (D.54039, D.54038);
          try
            {
              if (1 == 0) goto <D.54041>; else goto <D.54042>;
              <D.54041>:
              D.54043 = 0B;
              iftmp.17 = *D.54043;
              goto <D.54044>;
              <D.54042>:
              iftmp.17 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 32B];
              <D.54044>:
              this->D.48787._vptr.Base2 = iftmp.17;
              if (1 == 0) goto <D.54046>; else goto <D.54047>;
              <D.54046>:
              D.54048 = this->D.48787._vptr.Base2;
              D.54049 = D.54048 + 18446744073709551592;
              D.54050 = MEM[(long int *)D.54049];
              iftmp.18 = (sizetype) D.54050;
              goto <D.54051>;
              <D.54047>:
              iftmp.18 = 8;
              <D.54051>:
              D.54052 = this + iftmp.18;
              if (1 == 0) goto <D.54054>; else goto <D.54055>;
              <D.54054>:
              iftmp.19 = MEM[(const void * *)0B + 8B];
              goto <D.54056>;
              <D.54055>:
              iftmp.19 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 72B];
              <D.54056>:
              D.54052->_vptr.Base = iftmp.19;
            }
          catch
            {
              D.54039 = &this->D.48787;
              {anonymous}::Base2::~Base2 (D.54039);
            }
        }
      catch
        {
          if (1 != 0) goto <D.54057>; else goto <D.54058>;
          <D.54057>:
          if (1 == 0) goto <D.54060>; else goto <D.54061>;
          <D.54060>:
          iftmp.20 = 16B;
          goto <D.54062>;
          <D.54061>:
          iftmp.20 = &MEM[(void *)&_ZTTN12_GLOBAL__N_17DerivedE + 16B];
          <D.54062>:
          D.54036 = &this->D.48789;
          {anonymous}::Base::~Base (D.54036, iftmp.20);
          goto <D.54063>;
          <D.54058>:
          <D.54063>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.54064>; else goto <D.54065>;
      <D.54064>:
      D.54024 = &this->D.48790;
      sigc::trackable::~trackable (D.54024);
      goto <D.54066>;
      <D.54065>:
      <D.54066>:
    }
}


{anonymous}::Base::Base(const {anonymous}::Base&) (struct Base * const this, const void * * __vtt_parm, const struct Base & D.48844)
{
  int (*__vtbl_ptr_type) () * D.54070;
  int (*__vtbl_ptr_type) () * D.54071;
  long int D.54072;
  sizetype D.54073;
  const struct trackable * D.54074;
  struct trackable * D.54075;
  int (*__vtbl_ptr_type) () * iftmp.21;

  if (0 != 0) goto <D.54068>; else goto <D.54069>;
  <D.54068>:
  D.54070 = D.48844->_vptr.Base;
  D.54071 = D.54070 + 18446744073709551592;
  D.54072 = MEM[(long int *)D.54071];
  D.54073 = (sizetype) D.54072;
  D.54074 = D.48844 + D.54073;
  D.54075 = &this->D.48724;
  sigc::trackable::trackable (D.54075, D.54074);
  goto <D.54076>;
  <D.54069>:
  <D.54076>:
  try
    {
      if (0 == 0) goto <D.54078>; else goto <D.54079>;
      <D.54078>:
      iftmp.21 = *__vtt_parm;
      goto <D.54080>;
      <D.54079>:
      iftmp.21 = &MEM[(void *)&_ZTVN12_GLOBAL__N_14BaseE + 24B];
      <D.54080>:
      this->_vptr.Base = iftmp.21;
    }
  catch
    {
      if (0 != 0) goto <D.54081>; else goto <D.54082>;
      <D.54081>:
      D.54075 = &this->D.48724;
      sigc::trackable::~trackable (D.54075);
      goto <D.54083>;
      <D.54082>:
      <D.54083>:
    }
}


{anonymous}::Base2::Base2(const {anonymous}::Base2&) (struct Base2 * const this, const struct Base2 & D.48817)
{
  this->_vptr.Base2 = &MEM[(void *)&_ZTVN12_GLOBAL__N_15Base2E + 16B];
}


virtual {anonymous}::Derived::~Derived() (struct Derived * const this)
{
  {anonymous}::Derived::~Derived (this);
  <D.53515>:
  operator delete (this);
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.22;
  bool iftmp.23;
  const struct slot_base * D.54088;
  bool D.54089;
  bool D.54090;
  bool D.54092;
  bool D.54093;
  struct rep_type * D.54097;
  void * (*<T1711>) (void *) D.54098;

  D.54088 = &this->D.48939;
  D.54089 = sigc::slot_base::empty (D.54088);
  D.54090 = ~D.54089;
  if (D.54090 != 0) goto <D.54091>; else goto <D.54086>;
  <D.54091>:
  D.54088 = &this->D.48939;
  D.54092 = sigc::slot_base::blocked (D.54088);
  D.54093 = ~D.54092;
  if (D.54093 != 0) goto <D.54094>; else goto <D.54086>;
  <D.54094>:
  iftmp.23 = 1;
  goto <D.54087>;
  <D.54086>:
  iftmp.23 = 0;
  <D.54087>:
  retval.22 = iftmp.23;
  if (retval.22 != 0) goto <D.54095>; else goto <D.54096>;
  <D.54095>:
  D.54097 = this->D.48939.rep_;
  D.54098 = D.54097->call_;
  D.54097 = this->D.48939.rep_;
  D.54098 (D.54097);
  return;
  <D.54096>:
  return;
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = {anonymous}::Derived] (const struct slot0 * const this)
{
  bool retval.24;
  bool iftmp.25;
  const struct slot_base * D.54105;
  bool D.54106;
  bool D.54107;
  bool D.54109;
  bool D.54110;
  struct rep_type * D.54114;
  void * (*<T1711>) (void *) D.54115;

  D.54105 = &this->D.50300;
  D.54106 = sigc::slot_base::empty (D.54105);
  D.54107 = ~D.54106;
  if (D.54107 != 0) goto <D.54108>; else goto <D.54103>;
  <D.54108>:
  D.54105 = &this->D.50300;
  D.54109 = sigc::slot_base::blocked (D.54105);
  D.54110 = ~D.54109;
  if (D.54110 != 0) goto <D.54111>; else goto <D.54103>;
  <D.54111>:
  iftmp.25 = 1;
  goto <D.54104>;
  <D.54103>:
  iftmp.25 = 0;
  <D.54104>:
  retval.24 = iftmp.25;
  if (retval.24 != 0) goto <D.54112>; else goto <D.54113>;
  <D.54112>:
  D.54114 = this->D.50300.rep_;
  D.54115 = D.54114->call_;
  D.54114 = this->D.50300.rep_;
  *<retval> = D.54115 (D.54114); [return slot optimization]
  return <retval>;
  <D.54113>:
  *<retval> = {};
  {anonymous}::Derived::Derived (<retval>);
  return <retval>;
}


virtual {anonymous}::Derived::~Derived() (struct Derived * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * D.54120;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.54125;
  int (*__vtbl_ptr_type) () * D.54126;
  long int D.54127;
  struct Base * D.54129;
  int (*__vtbl_ptr_type) () * iftmp.28;
  struct Base2 * D.54134;
  int D.54135;
  const void * * iftmp.29;
  struct Base * D.54142;
  struct trackable * D.54146;
  int D.54148;

  {
    if (2 == 0) goto <D.54118>; else goto <D.54119>;
    <D.54118>:
    D.54120 = 0B;
    iftmp.26 = *D.54120;
    goto <D.54121>;
    <D.54119>:
    iftmp.26 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 32B];
    <D.54121>:
    this->D.48787._vptr.Base2 = iftmp.26;
    if (2 == 0) goto <D.54123>; else goto <D.54124>;
    <D.54123>:
    D.54125 = this->D.48787._vptr.Base2;
    D.54126 = D.54125 + 18446744073709551592;
    D.54127 = MEM[(long int *)D.54126];
    iftmp.27 = (sizetype) D.54127;
    goto <D.54128>;
    <D.54124>:
    iftmp.27 = 8;
    <D.54128>:
    D.54129 = this + iftmp.27;
    if (2 == 0) goto <D.54131>; else goto <D.54132>;
    <D.54131>:
    iftmp.28 = MEM[(const void * *)0B + 8B];
    goto <D.54133>;
    <D.54132>:
    iftmp.28 = &MEM[(void *)&_ZTVN12_GLOBAL__N_17DerivedE + 72B];
    <D.54133>:
    D.54129->_vptr.Base = iftmp.28;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.54134 = &this->D.48787;
                    {anonymous}::Base2::~Base2 (D.54134);
                  }
              }
            finally
              {
                D.54135 = 2;
                if (D.54135 != 0) goto <D.54136>; else goto <D.54137>;
                <D.54136>:
                if (2 == 0) goto <D.54139>; else goto <D.54140>;
                <D.54139>:
                iftmp.29 = 16B;
                goto <D.54141>;
                <D.54140>:
                iftmp.29 = &MEM[(void *)&_ZTTN12_GLOBAL__N_17DerivedE + 16B];
                <D.54141>:
                D.54142 = &this->D.48789;
                {anonymous}::Base::~Base (D.54142, iftmp.29);
                goto <D.54143>;
                <D.54137>:
                <D.54143>:
              }
          }
        finally
          {
            D.54135 = 2;
            if (D.54135 != 0) goto <D.54144>; else goto <D.54145>;
            <D.54144>:
            D.54146 = &this->D.48790;
            sigc::trackable::~trackable (D.54146);
            goto <D.54147>;
            <D.54145>:
            <D.54147>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53513>:
  D.54148 = 0;
  if (D.54148 != 0) goto <D.54149>; else goto <D.54150>;
  <D.54149>:
  operator delete (this);
  goto <D.54151>;
  <D.54150>:
  <D.54151>:
}


{anonymous}::Base::~Base() (struct Base * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.30;
  int D.54161;
  struct trackable * D.54164;

  {
    if (0 == 0) goto <D.54158>; else goto <D.54159>;
    <D.54158>:
    iftmp.30 = *__vtt_parm;
    goto <D.54160>;
    <D.54159>:
    iftmp.30 = &MEM[(void *)&_ZTVN12_GLOBAL__N_14BaseE + 24B];
    <D.54160>:
    this->_vptr.Base = iftmp.30;
    try
      {
        try
          {

          }
        finally
          {
            D.54161 = 0;
            if (D.54161 != 0) goto <D.54162>; else goto <D.54163>;
            <D.54162>:
            D.54164 = &this->D.48724;
            sigc::trackable::~trackable (D.54164);
            goto <D.54165>;
            <D.54163>:
            <D.54165>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48880>:
}


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

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

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


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

  try
    {
      {

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


sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Derived&>, sigc::reference_wrapper<{anonymous}::Derived>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor() (struct bind_functor * const this)
{
  struct adapts * D.54169;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54169 = &this->D.50167;
            sigc::adapts<sigc::slot<void, {anonymous}::Derived&> >::~adapts (D.54169);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50234>:
}


sigc::slot<void, {anonymous}::Derived&>::~slot() (struct slot * const this)
{
  struct slot1 * D.54171;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54171 = &this->D.49253;
            sigc::slot1<void, {anonymous}::Derived&>::~slot1 (D.54171);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49285>:
}


sigc::slot1<void, {anonymous}::Derived&>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.54173;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54173 = &this->D.49211;
            sigc::slot_base::~slot_base (D.54173);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49280>:
}


sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::Derived>, sigc::slot<void> >::~bind_return_functor() (struct bind_return_functor * const this)
{
  struct adapts * D.54175;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54175 = &this->D.51049;
            sigc::adapts<sigc::slot<void> >::~adapts (D.54175);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51098>:
}


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.51398;
  struct _Rep * D.54177;
  struct _Alloc_hider * D.54178;

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


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

  D.54184 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.54184);
  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.54186;

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


__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.54187;

  try
    {
      {

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


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.54188;
  char * D.54189;

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


_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.54192;

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


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.31;
  struct _Rep & D.54195;
  bool D.54196;
  long int D.54197;
  long int D.54198;
  bool retval.32;
  _Atomic_word * D.54202;
  int D.54203;

  D.54195 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.54196 = D.54195 != this;
  D.54197 = (long int) D.54196;
  D.54198 = __builtin_expect (D.54197, 0);
  retval.31 = D.54198 != 0;
  if (retval.31 != 0) goto <D.54199>; else goto <D.54200>;
  <D.54199>:
  D.54202 = &this->D.11865._M_refcount;
  D.54203 = __gnu_cxx::__exchange_and_add_dispatch (D.54202, -1);
  retval.32 = D.54203 <= 0;
  if (retval.32 != 0) goto <D.54204>; else goto <D.54205>;
  <D.54204>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.54206>;
  <D.54205>:
  <D.54206>:
  goto <D.54207>;
  <D.54200>:
  <D.54207>:
}


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.54209;
  void * __p;

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.33;
  int D.54212;
  _Atomic_word D.54215;

  D.54212 = __gthread_active_p ();
  retval.33 = D.54212 != 0;
  if (retval.33 != 0) goto <D.54213>; else goto <D.54214>;
  <D.54213>:
  D.54215 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.54215;
  <D.54214>:
  D.54215 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.54215;
}


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

  D.54218 = __gthrw___pthread_key_create != 0B;
  D.54217 = (int) D.54218;
  return D.54217;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.54220;
  unsigned int __val.34;
  unsigned int D.54222;

  __val.34 = (unsigned int) __val;
  D.54222 = __atomic_fetch_add_4 (__mem, __val.34, 4);
  D.54220 = (_Atomic_word) D.54222;
  return D.54220;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.54224;
  int D.54225;
  _Atomic_word D.54226;
  _Atomic_word __result;

  __result = *__mem;
  D.54224 = *__mem;
  D.54225 = D.54224 + __val;
  *__mem = D.54225;
  D.54226 = __result;
  return D.54226;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<{anonymous}::Derived>::~slot() (struct slot * const this)
{
  struct slot0 * D.54230;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54230 = &this->D.50342;
            sigc::slot0<{anonymous}::Derived>::~slot0 (D.54230);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51140>:
}


sigc::slot0<{anonymous}::Derived>::~slot0() (struct slot0 * const this)
{
  struct slot_base * D.54232;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54232 = &this->D.50300;
            sigc::slot_base::~slot_base (D.54232);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51135>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54234 = &this->D.48981;
            sigc::slot0<void>::~slot0 (D.54234);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49137>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54236 = &this->D.48939;
            sigc::slot_base::~slot_base (D.54236);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49132>:
}


(static initializers for test_limit_reference.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.54238>; else goto <D.54239>;
  <D.54238>:
  if (__priority == 65535) goto <D.54240>; else goto <D.54241>;
  <D.54240>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.54242>;
  <D.54241>:
  <D.54242>:
  goto <D.54243>;
  <D.54239>:
  <D.54243>:
}


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.35;
  const void * * D.54247;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.54252;
  int (*__vtbl_ptr_type) () * D.54253;
  long int D.54254;
  struct basic_ios * D.54256;
  int (*__vtbl_ptr_type) () * iftmp.37;
  struct __stringbuf_type * D.54261;
  const void * * iftmp.38;
  struct basic_ostream * D.54266;
  int D.54267;
  struct basic_ios * D.54270;
  int D.54272;

  {
    if (2 == 0) goto <D.54245>; else goto <D.54246>;
    <D.54245>:
    D.54247 = 0B;
    iftmp.35 = *D.54247;
    goto <D.54248>;
    <D.54246>:
    iftmp.35 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.54248>:
    this->D.22312._vptr.basic_ostream = iftmp.35;
    if (2 == 0) goto <D.54250>; else goto <D.54251>;
    <D.54250>:
    D.54252 = this->D.22312._vptr.basic_ostream;
    D.54253 = D.54252 + 18446744073709551592;
    D.54254 = MEM[(long int *)D.54253];
    iftmp.36 = (sizetype) D.54254;
    goto <D.54255>;
    <D.54251>:
    iftmp.36 = 88;
    <D.54255>:
    D.54256 = this + iftmp.36;
    if (2 == 0) goto <D.54258>; else goto <D.54259>;
    <D.54258>:
    iftmp.37 = MEM[(const void * *)0B + 24B];
    goto <D.54260>;
    <D.54259>:
    iftmp.37 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.54260>:
    D.54256->D.19008._vptr.ios_base = iftmp.37;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.54261 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.54261);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.54263>; else goto <D.54264>;
                <D.54263>:
                iftmp.38 = 8B;
                goto <D.54265>;
                <D.54264>:
                iftmp.38 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.54265>:
                D.54266 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.54266, iftmp.38);
              }
          }
        finally
          {
            D.54267 = 2;
            if (D.54267 != 0) goto <D.54268>; else goto <D.54269>;
            <D.54268>:
            D.54270 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.54270);
            goto <D.54271>;
            <D.54269>:
            <D.54271>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53523>:
  D.54272 = 0;
  if (D.54272 != 0) goto <D.54273>; else goto <D.54274>;
  <D.54273>:
  operator delete (this);
  goto <D.54275>;
  <D.54274>:
  <D.54275>:
}


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.53525>:
  operator delete (this);
}


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.54285;
  struct basic_streambuf * D.54286;
  int D.54287;

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

              }
            finally
              {
                D.54285 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.54285);
              }
          }
        finally
          {
            D.54286 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.54286);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51323>:
  D.54287 = 0;
  if (D.54287 != 0) goto <D.54288>; else goto <D.54289>;
  <D.54288>:
  operator delete (this);
  goto <D.54290>;
  <D.54289>:
  <D.54290>:
}


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

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

          }
        finally
          {
            D.54293 = &this->_M_buf_locale;
            std::locale::~locale (D.54293);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51683>:
  D.54294 = 0;
  if (D.54294 != 0) goto <D.54295>; else goto <D.54296>;
  <D.54295>:
  operator delete (this);
  goto <D.54297>;
  <D.54296>:
  <D.54297>:
}


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.51687>:
  operator delete (this);
}


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.51327>:
  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.39;
  sizetype iftmp.40;
  int (*__vtbl_ptr_type) () * D.54305;
  int (*__vtbl_ptr_type) () * D.54306;
  long int D.54307;
  struct basic_ios * D.54309;
  int (*__vtbl_ptr_type) () * iftmp.41;
  int D.54314;
  struct basic_ios * D.54317;
  int D.54319;

  {
    if (0 == 0) goto <D.54299>; else goto <D.54300>;
    <D.54299>:
    iftmp.39 = *__vtt_parm;
    goto <D.54301>;
    <D.54300>:
    iftmp.39 = &MEM[(void *)&_ZTVSo + 24B];
    <D.54301>:
    this->_vptr.basic_ostream = iftmp.39;
    if (0 == 0) goto <D.54303>; else goto <D.54304>;
    <D.54303>:
    D.54305 = this->_vptr.basic_ostream;
    D.54306 = D.54305 + 18446744073709551592;
    D.54307 = MEM[(long int *)D.54306];
    iftmp.40 = (sizetype) D.54307;
    goto <D.54308>;
    <D.54304>:
    iftmp.40 = 8;
    <D.54308>:
    D.54309 = this + iftmp.40;
    if (0 == 0) goto <D.54311>; else goto <D.54312>;
    <D.54311>:
    iftmp.41 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.54313>;
    <D.54312>:
    iftmp.41 = &MEM[(void *)&_ZTVSo + 64B];
    <D.54313>:
    D.54309->D.19008._vptr.ios_base = iftmp.41;
    try
      {
        try
          {

          }
        finally
          {
            D.54314 = 0;
            if (D.54314 != 0) goto <D.54315>; else goto <D.54316>;
            <D.54315>:
            D.54317 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.54317);
            goto <D.54318>;
            <D.54316>:
            <D.54318>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51668>:
  D.54319 = 0;
  if (D.54319 != 0) goto <D.54320>; else goto <D.54321>;
  <D.54320>:
  operator delete (this);
  goto <D.54322>;
  <D.54321>:
  <D.54322>:
}


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

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

          }
        finally
          {
            D.54324 = &this->D.19008;
            std::ios_base::~ios_base (D.54324);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51656>:
  D.54325 = 0;
  if (D.54325 != 0) goto <D.54326>; else goto <D.54327>;
  <D.54326>:
  operator delete (this);
  goto <D.54328>;
  <D.54327>:
  <D.54328>:
}


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.51660>:
  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.54332;
  const void * * iftmp.42;
  struct basic_ostream * D.54338;
  int (*__vtbl_ptr_type) () * iftmp.43;
  const void * * D.54342;
  sizetype iftmp.44;
  int (*__vtbl_ptr_type) () * D.54347;
  int (*__vtbl_ptr_type) () * D.54348;
  long int D.54349;
  struct basic_ios * D.54351;
  int (*__vtbl_ptr_type) () * iftmp.45;
  _Ios_Openmode D.54356;
  struct __stringbuf_type * D.54357;
  struct basic_streambuf * D.54358;
  sizetype iftmp.46;
  struct basic_ios * D.54363;
  const void * * iftmp.47;

  if (1 != 0) goto <D.54330>; else goto <D.54331>;
  <D.54330>:
  D.54332 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.54332);
  goto <D.54333>;
  <D.54331>:
  <D.54333>:
  try
    {
      if (1 == 0) goto <D.54335>; else goto <D.54336>;
      <D.54335>:
      iftmp.42 = 8B;
      goto <D.54337>;
      <D.54336>:
      iftmp.42 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.54337>:
      D.54338 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.54338, iftmp.42);
      try
        {
          if (1 == 0) goto <D.54340>; else goto <D.54341>;
          <D.54340>:
          D.54342 = 0B;
          iftmp.43 = *D.54342;
          goto <D.54343>;
          <D.54341>:
          iftmp.43 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.54343>:
          this->D.22312._vptr.basic_ostream = iftmp.43;
          if (1 == 0) goto <D.54345>; else goto <D.54346>;
          <D.54345>:
          D.54347 = this->D.22312._vptr.basic_ostream;
          D.54348 = D.54347 + 18446744073709551592;
          D.54349 = MEM[(long int *)D.54348];
          iftmp.44 = (sizetype) D.54349;
          goto <D.54350>;
          <D.54346>:
          iftmp.44 = 88;
          <D.54350>:
          D.54351 = this + iftmp.44;
          if (1 == 0) goto <D.54353>; else goto <D.54354>;
          <D.54353>:
          iftmp.45 = MEM[(const void * *)0B + 24B];
          goto <D.54355>;
          <D.54354>:
          iftmp.45 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.54355>:
          D.54351->D.19008._vptr.ios_base = iftmp.45;
          D.54356 = std::operator| (__mode, 16);
          D.54357 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.54357, D.54356);
          try
            {
              D.54358 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.54360>; else goto <D.54361>;
              <D.54360>:
              D.54347 = this->D.22312._vptr.basic_ostream;
              D.54348 = D.54347 + 18446744073709551592;
              D.54349 = MEM[(long int *)D.54348];
              iftmp.46 = (sizetype) D.54349;
              goto <D.54362>;
              <D.54361>:
              iftmp.46 = 88;
              <D.54362>:
              D.54363 = this + iftmp.46;
              std::basic_ios<char>::init (D.54363, D.54358);
            }
          catch
            {
              D.54357 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.54357);
            }
        }
      catch
        {
          if (1 == 0) goto <D.54365>; else goto <D.54366>;
          <D.54365>:
          iftmp.47 = 8B;
          goto <D.54367>;
          <D.54366>:
          iftmp.47 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.54367>:
          D.54338 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.54338, iftmp.47);
        }
    }
  catch
    {
      if (1 != 0) goto <D.54368>; else goto <D.54369>;
      <D.54368>:
      D.54332 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.54332);
      goto <D.54370>;
      <D.54369>:
      <D.54370>:
    }
}


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

  D.54374 = &this->D.19008;
  std::ios_base::ios_base (D.54374);
  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.54374 = &this->D.19008;
      std::ios_base::~ios_base (D.54374);
    }
}


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.54377;
  int (*__vtbl_ptr_type) () * iftmp.48;
  sizetype iftmp.49;
  int (*__vtbl_ptr_type) () * D.54386;
  int (*__vtbl_ptr_type) () * D.54387;
  long int D.54388;
  struct basic_ios * D.54390;
  int (*__vtbl_ptr_type) () * iftmp.50;
  sizetype iftmp.51;
  struct basic_ios * D.54399;

  if (0 != 0) goto <D.54375>; else goto <D.54376>;
  <D.54375>:
  D.54377 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.54377);
  goto <D.54378>;
  <D.54376>:
  <D.54378>:
  try
    {
      if (0 == 0) goto <D.54380>; else goto <D.54381>;
      <D.54380>:
      iftmp.48 = *__vtt_parm;
      goto <D.54382>;
      <D.54381>:
      iftmp.48 = &MEM[(void *)&_ZTVSo + 24B];
      <D.54382>:
      this->_vptr.basic_ostream = iftmp.48;
      if (0 == 0) goto <D.54384>; else goto <D.54385>;
      <D.54384>:
      D.54386 = this->_vptr.basic_ostream;
      D.54387 = D.54386 + 18446744073709551592;
      D.54388 = MEM[(long int *)D.54387];
      iftmp.49 = (sizetype) D.54388;
      goto <D.54389>;
      <D.54385>:
      iftmp.49 = 8;
      <D.54389>:
      D.54390 = this + iftmp.49;
      if (0 == 0) goto <D.54392>; else goto <D.54393>;
      <D.54392>:
      iftmp.50 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.54394>;
      <D.54393>:
      iftmp.50 = &MEM[(void *)&_ZTVSo + 64B];
      <D.54394>:
      D.54390->D.19008._vptr.ios_base = iftmp.50;
      if (0 == 0) goto <D.54396>; else goto <D.54397>;
      <D.54396>:
      D.54386 = this->_vptr.basic_ostream;
      D.54387 = D.54386 + 18446744073709551592;
      D.54388 = MEM[(long int *)D.54387];
      iftmp.51 = (sizetype) D.54388;
      goto <D.54398>;
      <D.54397>:
      iftmp.51 = 8;
      <D.54398>:
      D.54399 = this + iftmp.51;
      std::basic_ios<char>::init (D.54399, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.54400>; else goto <D.54401>;
      <D.54400>:
      D.54377 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.54377);
      goto <D.54402>;
      <D.54401>:
      <D.54402>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.54404;
  int __a.52;
  int __b.53;
  int D.54407;

  __a.52 = (int) __a;
  __b.53 = (int) __b;
  D.54407 = __a.52 | __b.53;
  D.54404 = (_Ios_Openmode) D.54407;
  return D.54404;
}


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.54409;
  struct __string_type * D.54410;

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

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


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

  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.54412 = &this->_M_buf_locale;
  std::locale::locale (D.54412);
  try
    {

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


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.52526;
  struct _Rep & D.54413;
  char * D.54414;
  struct _Alloc_hider * D.54415;

  std::allocator<char>::allocator (&D.52526);
  try
    {
      D.54413 = std::basic_string<char>::_S_empty_rep ();
      D.54414 = std::basic_string<char>::_Rep::_M_refdata (D.54413);
      D.54415 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.54415, D.54414, &D.52526);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.52526);
      D.52526 = {CLOBBER};
    }
  try
    {

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


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

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


_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.54421;
  void * D.54422;

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


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


