int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.41502;
  int D.41505;
  int iftmp.1;
  bool D.41507;
  struct iterator D.39944;
  const struct slot_type D.39865;
  struct bound_mem_functor0 D.39763;
  struct 
{
  void HandlerClass::<T7002> (struct HandlerClass *) * __pfn;
  long int __delta;
} D.41511;
  const struct string D.39959;
  struct allocator D.39958;
  int iftmp.2;
  bool D.41513;

  {
    struct TestUtilities * util;
    struct HandlerClass instance;
    struct signal signal_test;

    try
      {
        util = TestUtilities::get_instance ();
        D.41502 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.41502;
        if (retval.0 != 0) goto <D.41503>; else goto <D.41504>;
        <D.41503>:
        D.41507 = TestUtilities::get_result_and_delete_instance ();
        if (D.41507 != 0) goto <D.41508>; else goto <D.41509>;
        <D.41508>:
        iftmp.1 = 0;
        goto <D.41510>;
        <D.41509>:
        iftmp.1 = 1;
        <D.41510>:
        D.41505 = iftmp.1;
        return D.41505;
        <D.41504>:
        {anonymous}::HandlerClass::HandlerClass (&instance);
        try
          {
            sigc::signal<void>::signal (&signal_test);
            try
              {
                D.41511.__pfn = handler;
                D.41511.__delta = 0;
                D.39763 = sigc::mem_fun<void, {anonymous}::HandlerClass, {anonymous}::HandlerClass> (&instance, D.41511); [return slot optimization]
                try
                  {
                    sigc::slot<void>::slot<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > (&D.39865, &D.39763);
                    try
                      {
                        D.39944 = sigc::signal0<void, sigc::nil>::connect (&signal_test.D.39619, &D.39865);
                        try
                          {
                            sigc::connection::operator=<sigc::slot<void> > (&connection, &D.39944);
                          }
                        finally
                          {
                            D.39944 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        sigc::slot<void>::~slot (&D.39865);
                        D.39865 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.39763 = {CLOBBER};
                  }
                sigc::signal0<void, sigc::nil>::emit (&signal_test.D.39619);
                std::allocator<char>::allocator (&D.39958);
                try
                  {
                    std::basic_string<char>::basic_string (&D.39959, "handler called", &D.39958);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.39959);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.39959);
                        D.39959 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.39958);
                    D.39958 = {CLOBBER};
                  }
                D.41513 = TestUtilities::get_result_and_delete_instance ();
                if (D.41513 != 0) goto <D.41514>; else goto <D.41515>;
                <D.41514>:
                iftmp.2 = 0;
                goto <D.41516>;
                <D.41515>:
                iftmp.2 = 1;
                <D.41516>:
                D.41505 = iftmp.2;
                return D.41505;
              }
            finally
              {
                sigc::signal<void>::~signal (&signal_test);
              }
          }
        finally
          {
            {anonymous}::HandlerClass::~HandlerClass (&instance);
          }
      }
    finally
      {
        instance = {CLOBBER};
        signal_test = {CLOBBER};
      }
  }
  D.41505 = 0;
  return D.41505;
}


void {anonymous}::HandlerClass::handler() (struct HandlerClass * const this)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "handler called");
  sigc::connection::disconnect (&connection);
}


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.41536;
  int (*__vtbl_ptr_type) () * D.41537;
  long int D.41538;
  sizetype D.41539;
  struct basic_ios * D.41540;
  long unsigned int D.41542;
  long int D.41543;
  struct basic_ostream & D.41544;

  if (__s == 0B) goto <D.41534>; else goto <D.41535>;
  <D.41534>:
  D.41536 = __out->_vptr.basic_ostream;
  D.41537 = D.41536 + 18446744073709551592;
  D.41538 = MEM[(long int *)D.41537];
  D.41539 = (sizetype) D.41538;
  D.41540 = __out + D.41539;
  std::basic_ios<char>::setstate (D.41540, 1);
  goto <D.41541>;
  <D.41535>:
  D.41542 = std::char_traits<char>::length (__s);
  D.41543 = (long int) D.41542;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.41543);
  <D.41541>:
  D.41544 = __out;
  return D.41544;
}


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.41546;
  _Ios_Iostate D.41547;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.41551;
  int __a.3;
  int __b.4;
  int D.41554;

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.41554 = __a.3 | __b.4;
  D.41551 = (_Ios_Iostate) D.41554;
  return D.41551;
}


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

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


{anonymous}::HandlerClass::HandlerClass() (struct HandlerClass * const this)
{
  struct trackable * D.41558;

  D.41558 = &this->D.39433;
  sigc::trackable::trackable (D.41558);
  try
    {

    }
  catch
    {
      D.41558 = &this->D.39433;
      sigc::trackable::~trackable (D.41558);
    }
}


sigc::signal<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::signal() [with T_return = void] (struct signal * const this)
{
  struct signal0 * D.41559;

  D.41559 = &this->D.39619;
  sigc::signal0<void, sigc::nil>::signal0 (D.41559);
  try
    {

    }
  catch
    {
      D.41559 = &this->D.39619;
      sigc::signal0<void, sigc::nil>::~signal0 (D.41559);
    }
}


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

  D.41560 = &this->D.39594;
  sigc::signal_base::signal_base (D.41560);
  try
    {

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


sigc::bound_mem_functor0<T_return, T_obj> sigc::mem_fun(T_obj&, T_return (T_obj2::*)()) [with T_return = void; T_obj = {anonymous}::HandlerClass; T_obj2 = {anonymous}::HandlerClass] (struct HandlerClass & _A_obj, struct 
{
  void HandlerClass::<T7002> (struct HandlerClass *) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>::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}::HandlerClass; sigc::bound_mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::HandlerClass::*)()] (struct bound_mem_functor0 * const this, struct HandlerClass & _A_obj, struct function_type _A_func)
{
  struct mem_functor0 * D.41563;
  struct limit_reference * D.41564;

  D.41563 = &this->D.39760;
  sigc::mem_functor0<void, {anonymous}::HandlerClass>::mem_functor0 (D.41563, _A_func);
  D.41564 = &this->obj_;
  sigc::limit_reference<{anonymous}::HandlerClass, true>::limit_reference (D.41564, _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}::HandlerClass; sigc::mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::HandlerClass::*)()] (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}::HandlerClass] (struct limit_reference * const this, struct HandlerClass & _A_target)
{
  struct trackable * D.41565;

  D.41565 = &_A_target->D.39433;
  this->visited = D.41565;
  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}::HandlerClass>; T_return = void] (struct slot * const this, const struct bound_mem_functor0 & _A_func)
{
  struct slot0 * D.41566;

  D.41566 = &this->D.39854;
  sigc::slot0<void>::slot0<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > (D.41566, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>; T_return = void] (struct slot0 * const this, const struct bound_mem_functor0 & _A_func)
{
  void * D.40833;
  struct slot_base * D.41567;
  struct rep_type * D.41568;
  void * (*<T1711>) (void *) D.41569;

  D.40833 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> >::typed_slot_rep (D.40833, _A_func);
    }
  catch
    {
      operator delete (D.40833);
    }
  D.41567 = &this->D.39812;
  sigc::slot_base::slot_base (D.41567, D.40833);
  try
    {
      D.41568 = this->D.39812.rep_;
      D.41569 = sigc::internal::slot_call0<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>, void>::address ();
      D.41568->call_ = D.41569;
    }
  catch
    {
      D.41567 = &this->D.39812;
      sigc::slot_base::~slot_base (D.41567);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>] (struct typed_slot_rep * const this, const struct bound_mem_functor0 & functor)
{
  struct slot_rep * D.41572;
  struct adaptor_type * D.41573;
  struct slot_do_bind D.41058;

  D.41572 = &this->D.40822;
  sigc::internal::slot_rep::slot_rep (D.41572, 0B, destroy, dup);
  try
    {
      D.41573 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> >::adaptor_functor (D.41573, functor);
      D.41573 = &this->functor_;
      D.41572 = &this->D.40822;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41058, D.41572);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > > (&D.41058, D.41573);
        }
      finally
        {
          D.41058 = {CLOBBER};
        }
    }
  catch
    {
      D.41572 = &this->D.40822;
      sigc::internal::slot_rep::~slot_rep (D.41572);
    }
}


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

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


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}::HandlerClass>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.41580;
  struct slot_rep * D.41581;
  struct adaptor_type * D.41582;
  struct slot_do_bind D.41304;

  D.41580 = cl->D.40822.call_;
  D.41581 = &this->D.40822;
  sigc::internal::slot_rep::slot_rep (D.41581, D.41580, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.41582 = &this->functor_;
      D.41581 = &this->D.40822;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41304, D.41581);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > > (&D.41304, D.41582);
        }
      finally
        {
          D.41304 = {CLOBBER};
        }
    }
  catch
    {
      D.41581 = &this->D.40822;
      sigc::internal::slot_rep::~slot_rep (D.41581);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>] (void * data)
{
  struct adaptor_type * D.41585;
  struct slot_do_unbind D.41157;
  void * D.41586;
  struct self * self_;

  self_ = data;
  self_->D.40822.call_ = 0B;
  self_->D.40822.destroy_ = 0B;
  D.41585 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.41157, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > > (&D.41157, D.41585);
    }
  finally
    {
      D.41157 = {CLOBBER};
    }
  D.41586 = 0B;
  return D.41586;
}


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

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


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}::HandlerClass>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> >::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}::HandlerClass] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.41591;

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


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

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


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

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


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

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

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


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

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


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::HandlerClass>] (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}::HandlerClass> >] (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}::HandlerClass> > > (&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}::HandlerClass> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> > >::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}::HandlerClass>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor0 * D.41599;

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


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}::HandlerClass>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor0<void, {anonymous}::HandlerClass> >::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}::HandlerClass] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.41600;

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


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

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


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

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

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


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

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


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

  D.41607 = this->destroy_;
  if (D.41607 != 0B) goto <D.41608>; else goto <D.41609>;
  <D.41608>:
  D.41607 = this->destroy_;
  D.41607 (this);
  goto <D.41610>;
  <D.41609>:
  <D.41610>:
}


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

  D.41611 = call_it;
  return D.41611;
}


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}::HandlerClass>; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.41613;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

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


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

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


T_return sigc::bound_mem_functor0<T_return, T_obj>::operator()() const [with T_return = void; T_obj = {anonymous}::HandlerClass] (const struct bound_mem_functor0 * const this)
{
  const struct limit_reference * D.41617;
  struct HandlerClass & D.41618;
  void HandlerClass::<T7002> (struct HandlerClass *) * iftmp.5;
  void HandlerClass::<T7002> (struct HandlerClass *) * D.41620;
  long int D.41621;
  long int D.41622;
  long int D.41626;
  sizetype D.41627;
  struct HandlerClass * D.41628;
  int (*__vtbl_ptr_type) () * D.41629;
  long int D.41630;
  sizetype D.41631;
  int (*__vtbl_ptr_type) () * D.41632;

  D.41617 = &this->obj_;
  D.41618 = sigc::limit_reference<{anonymous}::HandlerClass, true>::invoke (D.41617);
  D.41620 = this->D.39760.func_ptr_.__pfn;
  D.41621 = (long int) D.41620;
  D.41622 = D.41621 & 1;
  if (D.41622 == 0) goto <D.41623>; else goto <D.41624>;
  <D.41623>:
  iftmp.5 = this->D.39760.func_ptr_.__pfn;
  goto <D.41625>;
  <D.41624>:
  D.41626 = this->D.39760.func_ptr_.__delta;
  D.41627 = (sizetype) D.41626;
  D.41628 = D.41618 + D.41627;
  D.41629 = MEM[(int (*__vtbl_ptr_type) () * *)D.41628];
  D.41620 = this->D.39760.func_ptr_.__pfn;
  D.41621 = (long int) D.41620;
  D.41630 = D.41621 + -1;
  D.41631 = (sizetype) D.41630;
  D.41632 = D.41629 + D.41631;
  iftmp.5 = *D.41632;
  <D.41625>:
  D.41626 = this->D.39760.func_ptr_.__delta;
  D.41627 = (sizetype) D.41626;
  D.41628 = D.41618 + D.41627;
  iftmp.5 (D.41628);
  return;
}


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

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


sigc::signal0<T_return, T_accumulator>::iterator sigc::signal0<T_return, T_accumulator>::connect(const slot_type&) [with T_return = void; T_accumulator = sigc::nil; sigc::signal0<T_return, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<void> >; sigc::signal0<T_return, T_accumulator>::slot_type = sigc::slot<void>] (struct signal0 * const this, const struct slot_type & slot_)
{
  struct iterator D.41636;
  struct iterator D.40168;
  struct iterator_type D.40158;
  const struct slot_base * D.41637;
  struct signal_base * D.41638;

  D.41637 = &slot_->D.39854.D.39812;
  D.41638 = &this->D.39594;
  D.40158 = sigc::signal_base::connect (D.41638, D.41637);
  try
    {
      sigc::slot_iterator<sigc::slot<void> >::slot_iterator (&D.40168, &D.40158);
      try
        {
          D.41636 = D.40168;
          return D.41636;
        }
      finally
        {
          D.40168 = {CLOBBER};
        }
    }
  finally
    {
      D.40158 = {CLOBBER};
    }
}


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


sigc::connection& sigc::connection::operator=(const sigc::slot_iterator<T_slot>&) [with T_slot = sigc::slot<void>] (struct connection * const this, const struct slot_iterator & it)
{
  struct slot & D.41642;
  struct connection & D.41643;

  D.41642 = sigc::slot_iterator<sigc::slot<void> >::operator* (it);
  sigc::connection::set_slot (this, D.41642);
  D.41643 = this;
  return D.41643;
}


T_slot& sigc::slot_iterator<T_slot>::operator*() const [with T_slot = sigc::slot<void>; sigc::slot_iterator<T_slot>::reference = sigc::slot<void>&] (const struct slot_iterator * const this)
{
  struct slot & D.41646;
  const struct iterator_type * D.41647;

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


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

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


sigc::signal0<T_return, T_accumulator>::result_type sigc::signal0<T_return, T_accumulator>::emit() const [with T_return = void; T_accumulator = sigc::nil; sigc::signal0<T_return, T_accumulator>::result_type = void] (const struct signal0 * const this)
{
  struct signal_impl * D.41652;

  D.41652 = this->D.39594.impl_;
  sigc::internal::signal_emit0<void, sigc::nil>::emit (D.41652);
  return;
}


static sigc::internal::signal_emit0<void, sigc::nil>::result_type sigc::internal::signal_emit0<void, sigc::nil>::emit(sigc::internal::signal_impl*) (struct signal_impl * impl)
{
  bool retval.6;
  bool iftmp.7;
  struct list * D.41660;
  bool D.41661;
  struct iterator D.36354;
  bool retval.8;
  bool iftmp.9;
  const struct slot_base * D.41669;
  bool D.41670;
  const struct slot_base * D.41672;
  bool D.41673;
  const struct slot_base * D.41676;
  struct rep_type * D.41677;
  void * (*<T1711>) (void *) D.41678;
  const struct slot_base * D.41679;
  struct rep_type * D.41680;
  bool retval.10;
  const struct _Self D.36357;
  struct iterator D.36356;
  struct signal_exec exec;
  struct temp_slot_list slots;

  try
    {
      if (impl == 0B) goto <D.41656>; else goto <D.41659>;
      <D.41659>:
      D.41660 = &impl->slots_;
      D.41661 = std::list<sigc::slot_base>::empty (D.41660);
      if (D.41661 != 0) goto <D.41656>; else goto <D.41657>;
      <D.41656>:
      iftmp.7 = 1;
      goto <D.41658>;
      <D.41657>:
      iftmp.7 = 0;
      <D.41658>:
      retval.6 = iftmp.7;
      if (retval.6 != 0) goto <D.41662>; else goto <D.41663>;
      <D.41662>:
      return;
      <D.41663>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.41660 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.41660);
          try
            {
              {
                struct iterator_type it;

                try
                  {
                    D.36354 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.36354);
                      }
                    finally
                      {
                        D.36354 = {CLOBBER};
                      }
                    goto <D.36361>;
                    <D.36360>:
                    D.41669 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.41670 = sigc::slot_base::empty (D.41669);
                    if (D.41670 != 0) goto <D.41666>; else goto <D.41671>;
                    <D.41671>:
                    D.41672 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.41673 = sigc::slot_base::blocked (D.41672);
                    if (D.41673 != 0) goto <D.41666>; else goto <D.41667>;
                    <D.41666>:
                    iftmp.9 = 1;
                    goto <D.41668>;
                    <D.41667>:
                    iftmp.9 = 0;
                    <D.41668>:
                    retval.8 = iftmp.9;
                    if (retval.8 != 0) goto <D.41674>; else goto <D.41675>;
                    <D.41674>:
                    goto <D.36359>;
                    <D.41675>:
                    D.41676 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.41677 = D.41676->rep_;
                    D.41678 = D.41677->call_;
                    D.41679 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.41680 = D.41679->rep_;
                    D.41678 (D.41680);
                    <D.36359>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.36361>:
                    D.36356 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.36357, &D.36356);
                        try
                          {
                            retval.10 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.36357);
                          }
                        finally
                          {
                            D.36357 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.36356 = {CLOBBER};
                      }
                    if (retval.10 != 0) goto <D.36360>; else goto <D.36358>;
                    <D.36358>:
                  }
                finally
                  {
                    it = {CLOBBER};
                  }
              }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
      slots = {CLOBBER};
    }
}


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

  D.41694 = this->D.35179._M_impl._M_node._M_next;
  D.41695 = &this->D.35179._M_impl._M_node;
  D.41693 = D.41694 == D.41695;
  return D.41693;
}


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

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.41698;
  unsigned short D.41699;
  unsigned short D.41700;
  short int D.41701;
  short int D.41702;
  unsigned short D.41703;
  unsigned short D.41704;
  short int D.41705;

  D.41698 = this->ref_count_;
  D.41699 = (unsigned short) D.41698;
  D.41700 = D.41699 + 1;
  D.41701 = (short int) D.41700;
  this->ref_count_ = D.41701;
  D.41702 = this->exec_count_;
  D.41703 = (unsigned short) D.41702;
  D.41704 = D.41703 + 1;
  D.41705 = (short int) D.41704;
  this->exec_count_ = D.41705;
}


sigc::internal::temp_slot_list::temp_slot_list(sigc::internal::temp_slot_list::slot_list&) (struct temp_slot_list * const this, struct slot_list & slots)
{
  struct iterator * D.41706;
  struct slot_base D.35400;
  struct slot_list & D.41707;
  struct _List_iterator D.41708;

  this->slots_ = slots;
  D.41706 = &this->placeholder;
  std::_List_iterator<sigc::slot_base>::_List_iterator (D.41706);
  sigc::slot_base::slot_base (&D.35400);
  try
    {
      D.41707 = this->slots_;
      D.41708 = std::list<sigc::slot_base>::end (D.41707);
      D.41707 = this->slots_;
      this->placeholder = std::list<sigc::slot_base>::insert (D.41707, D.41708, &D.35400);
    }
  finally
    {
      sigc::slot_base::~slot_base (&D.35400);
      D.35400 = {CLOBBER};
    }
}


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


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

  D.41711 = &this->D.35179._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.40066, D.41711);
  try
    {
      D.41710 = D.40066;
      return D.41710;
    }
  finally
    {
      D.40066 = {CLOBBER};
    }
}


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


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, struct iterator __position, const struct value_type & __x)
{
  struct _Self D.40074;
  struct _List_node_base * D.41714;
  struct _List_node_base * D.41715;
  struct iterator D.41716;
  struct iterator D.40075;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.40074 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.41714 = D.40074._M_node;
  D.41715 = &__tmp->D.40071;
  std::__detail::_List_node_base::_M_hook (D.41715, D.41714);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.40075, __tmp);
  try
    {
      D.41716 = D.40075;
      return D.41716;
    }
  finally
    {
      D.40075 = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.41720;
  struct slot_base * D.41721;
  struct slot_base * D.41722;
  struct _Tp_alloc_type D.40255;
  void * D.41723;
  struct _Node * D.41724;
  struct _Node * __p;

  D.41720 = &this->D.35179;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.41720);
  try
    {
      D.41721 = &__p->_M_data;
      D.41722 = std::__addressof<sigc::slot_base> (D.41721);
      D.41720 = &this->D.35179;
      D.40255 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.41720); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.40255, D.41722, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.40255);
          D.40255 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.41723 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.41723);
              D.41720 = &this->D.35179;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.41720, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.41724 = __p;
  return D.41724;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.34672)
{
  bool retval.11;
  long unsigned int D.41736;
  struct _List_node * D.41739;
  long unsigned int D.41740;

  D.41736 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.11 = D.41736 < __n;
  if (retval.11 != 0) goto <D.41737>; else goto <D.41738>;
  <D.41737>:
  std::__throw_bad_alloc ();
  <D.41738>:
  D.41740 = __n * 32;
  D.41739 = operator new (D.41740);
  return D.41739;
}


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

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


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

  D.41746 = __r;
  return D.41746;
}


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

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


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

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


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

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

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


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

  try
    {
      {

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


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

  D.40966 = __p;
  D.40967 = operator new (16, D.40966);
  if (D.40967 != 0B) goto <D.41756>; else goto <D.41757>;
  <D.41756>:
  try
    {
      sigc::slot_base::slot_base (D.40967, __val);
    }
  catch
    {
      operator delete (D.40967, D.40966);
    }
  iftmp.12 = D.40967;
  goto <D.41758>;
  <D.41757>:
  iftmp.12 = D.40967;
  <D.41758>:
}


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

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


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

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.41766 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.41766, __p, 1);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _List_node * __p, size_type D.34676)
{
  operator delete (__p);
}


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

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


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

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


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

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


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.41776;
  bool iftmp.13;
  struct rep_type * D.41781;
  void * (*<T1711>) (void *) D.41783;

  D.41781 = this->rep_;
  if (D.41781 == 0B) goto <D.41778>; else goto <D.41782>;
  <D.41782>:
  D.41781 = this->rep_;
  D.41783 = D.41781->call_;
  if (D.41783 == 0B) goto <D.41778>; else goto <D.41779>;
  <D.41778>:
  iftmp.13 = 1;
  goto <D.41780>;
  <D.41779>:
  iftmp.13 = 0;
  <D.41780>:
  D.41776 = iftmp.13;
  return D.41776;
}


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

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


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

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


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

  D.41791 = __r;
  return D.41791;
}


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

  D.41793 = this->_M_node;
  D.41794 = D.41793->_M_next;
  this->_M_node = D.41794;
  D.41795 = this;
  return D.41795;
}


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

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


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

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


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

  D.41801 = this->_M_node;
  D.41802 = __x->_M_node;
  D.41800 = D.41801 != D.41802;
  return D.41800;
}


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

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


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.41806;
  struct _List_node_base * D.41807;
  struct _List_iterator D.41808;
  struct iterator D.41809;
  struct iterator __ret;

  try
    {
      D.41806 = __position._M_node;
      D.41807 = D.41806->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.41807);
      D.41808 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.41808);
      D.41809 = __ret;
      return D.41809;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.41813;
  struct slot_base * D.41814;
  struct slot_base * D.41815;
  struct _Tp_alloc_type D.40261;
  struct _List_base * D.41816;
  struct _Node * __n;

  D.41813 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.41813);
  __n = __position._M_node;
  D.41814 = &__n->_M_data;
  D.41815 = std::__addressof<sigc::slot_base> (D.41814);
  D.41816 = &this->D.35179;
  D.40261 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.41816); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.40261, D.41815);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.40261);
      D.40261 = {CLOBBER};
    }
  D.41816 = &this->D.35179;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.41816, __n);
}


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


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

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.14;
  short int D.41821;
  unsigned short D.41822;
  unsigned short D.41823;
  short int D.41824;
  bool retval.15;
  bool iftmp.16;
  short int D.41835;
  unsigned short D.41836;
  unsigned short D.41837;
  short int D.41838;
  bool D.41840;

  D.41821 = this->ref_count_;
  D.41822 = (unsigned short) D.41821;
  D.41823 = D.41822 + 65535;
  D.41824 = (short int) D.41823;
  this->ref_count_ = D.41824;
  D.41821 = this->ref_count_;
  retval.14 = D.41821 == 0;
  if (retval.14 != 0) goto <D.41825>; else goto <D.41826>;
  <D.41825>:
  if (this != 0B) goto <D.41827>; else goto <D.41828>;
  <D.41827>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.41829>;
  <D.41828>:
  <D.41829>:
  goto <D.41830>;
  <D.41826>:
  D.41835 = this->exec_count_;
  D.41836 = (unsigned short) D.41835;
  D.41837 = D.41836 + 65535;
  D.41838 = (short int) D.41837;
  this->exec_count_ = D.41838;
  D.41835 = this->exec_count_;
  if (D.41835 == 0) goto <D.41839>; else goto <D.41833>;
  <D.41839>:
  D.41840 = this->deferred_;
  if (D.41840 != 0) goto <D.41841>; else goto <D.41833>;
  <D.41841>:
  iftmp.16 = 1;
  goto <D.41834>;
  <D.41833>:
  iftmp.16 = 0;
  <D.41834>:
  retval.15 = iftmp.16;
  if (retval.15 != 0) goto <D.41842>; else goto <D.41843>;
  <D.41842>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.41844>;
  <D.41843>:
  <D.41844>:
  <D.41830>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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

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


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

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

    __tmp = __cur;
    __cur = __cur->D.40071._M_next;
    D.41852 = &__tmp->_M_data;
    D.41853 = std::__addressof<sigc::slot_base> (D.41852);
    D.40244 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.40244, D.41853);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.40244);
        D.40244 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.40248>:
  D.41854 = &this->_M_impl._M_node;
  if (D.41854 != __cur) goto <D.40249>; else goto <D.40247>;
  <D.40247>:
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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

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


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

  try
    {
      {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.41860 = &this->D.39854;
            sigc::slot0<void>::~slot0 (D.41860);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39895>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.41862 = &this->D.39812;
            sigc::slot_base::~slot_base (D.41862);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39890>:
}


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.40202;
  struct _Rep * D.41864;
  struct _Alloc_hider * D.41865;

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


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

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

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


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

  try
    {
      {

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


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.41875;
  char * D.41876;

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


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

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


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.17;
  struct _Rep & D.41882;
  bool D.41883;
  long int D.41884;
  long int D.41885;
  bool retval.18;
  _Atomic_word * D.41889;
  int D.41890;

  D.41882 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.41883 = D.41882 != this;
  D.41884 = (long int) D.41883;
  D.41885 = __builtin_expect (D.41884, 0);
  retval.17 = D.41885 != 0;
  if (retval.17 != 0) goto <D.41886>; else goto <D.41887>;
  <D.41886>:
  D.41889 = &this->D.11865._M_refcount;
  D.41890 = __gnu_cxx::__exchange_and_add_dispatch (D.41889, -1);
  retval.18 = D.41890 <= 0;
  if (retval.18 != 0) goto <D.41891>; else goto <D.41892>;
  <D.41891>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.41893>;
  <D.41892>:
  <D.41893>:
  goto <D.41894>;
  <D.41887>:
  <D.41894>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.19;
  int D.41899;
  _Atomic_word D.41902;

  D.41899 = __gthread_active_p ();
  retval.19 = D.41899 != 0;
  if (retval.19 != 0) goto <D.41900>; else goto <D.41901>;
  <D.41900>:
  D.41902 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.41902;
  <D.41901>:
  D.41902 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.41902;
}


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

  D.41905 = __gthrw___pthread_key_create != 0B;
  D.41904 = (int) D.41905;
  return D.41904;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.41907;
  unsigned int __val.20;
  unsigned int D.41909;

  __val.20 = (unsigned int) __val;
  D.41909 = __atomic_fetch_add_4 (__mem, __val.20, 4);
  D.41907 = (_Atomic_word) D.41909;
  return D.41907;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.41911;
  int D.41912;
  _Atomic_word D.41913;
  _Atomic_word __result;

  __result = *__mem;
  D.41911 = *__mem;
  D.41912 = D.41911 + __val;
  *__mem = D.41912;
  D.41913 = __result;
  return D.41913;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::signal<void>::~signal() (struct signal * const this)
{
  struct signal0 * D.41917;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.41917 = &this->D.39619;
            sigc::signal0<void, sigc::nil>::~signal0 (D.41917);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39650>:
}


sigc::signal0<void, sigc::nil>::~signal0() (struct signal0 * const this)
{
  struct signal_base * D.41919;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.41919 = &this->D.39594;
            sigc::signal_base::~signal_base (D.41919);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39645>:
}


{anonymous}::HandlerClass::~HandlerClass() (struct HandlerClass * const this)
{
  struct trackable * D.41921;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.41921 = &this->D.39433;
            sigc::trackable::~trackable (D.41921);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39473>:
}


(static initializers for test_disconnect_during_emit.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.41923>; else goto <D.41924>;
  <D.41923>:
  if (__priority == 65535) goto <D.41925>; else goto <D.41926>;
  <D.41925>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  sigc::connection::connection (&connection);
  __cxa_atexit (__comp_dtor , &connection, &__dso_handle);
  goto <D.41927>;
  <D.41926>:
  <D.41927>:
  goto <D.41928>;
  <D.41924>:
  <D.41928>:
}


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.21;
  const void * * D.41932;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.41937;
  int (*__vtbl_ptr_type) () * D.41938;
  long int D.41939;
  struct basic_ios * D.41941;
  int (*__vtbl_ptr_type) () * iftmp.23;
  struct __stringbuf_type * D.41946;
  const void * * iftmp.24;
  struct basic_ostream * D.41951;
  int D.41952;
  struct basic_ios * D.41955;
  int D.41957;

  {
    if (2 == 0) goto <D.41930>; else goto <D.41931>;
    <D.41930>:
    D.41932 = 0B;
    iftmp.21 = *D.41932;
    goto <D.41933>;
    <D.41931>:
    iftmp.21 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.41933>:
    this->D.22312._vptr.basic_ostream = iftmp.21;
    if (2 == 0) goto <D.41935>; else goto <D.41936>;
    <D.41935>:
    D.41937 = this->D.22312._vptr.basic_ostream;
    D.41938 = D.41937 + 18446744073709551592;
    D.41939 = MEM[(long int *)D.41938];
    iftmp.22 = (sizetype) D.41939;
    goto <D.41940>;
    <D.41936>:
    iftmp.22 = 88;
    <D.41940>:
    D.41941 = this + iftmp.22;
    if (2 == 0) goto <D.41943>; else goto <D.41944>;
    <D.41943>:
    iftmp.23 = MEM[(const void * *)0B + 24B];
    goto <D.41945>;
    <D.41944>:
    iftmp.23 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.41945>:
    D.41941->D.19008._vptr.ios_base = iftmp.23;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.41946 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.41946);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.41948>; else goto <D.41949>;
                <D.41948>:
                iftmp.24 = 8B;
                goto <D.41950>;
                <D.41949>:
                iftmp.24 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.41950>:
                D.41951 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.41951, iftmp.24);
              }
          }
        finally
          {
            D.41952 = 2;
            if (D.41952 != 0) goto <D.41953>; else goto <D.41954>;
            <D.41953>:
            D.41955 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.41955);
            goto <D.41956>;
            <D.41954>:
            <D.41956>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41472>:
  D.41957 = 0;
  if (D.41957 != 0) goto <D.41958>; else goto <D.41959>;
  <D.41958>:
  operator delete (this);
  goto <D.41960>;
  <D.41959>:
  <D.41960>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.41970;
  struct basic_streambuf * D.41971;
  int D.41972;

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

              }
            finally
              {
                D.41970 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.41970);
              }
          }
        finally
          {
            D.41971 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.41971);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40123>:
  D.41972 = 0;
  if (D.41972 != 0) goto <D.41973>; else goto <D.41974>;
  <D.41973>:
  operator delete (this);
  goto <D.41975>;
  <D.41974>:
  <D.41975>:
}


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

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

          }
        finally
          {
            D.41978 = &this->_M_buf_locale;
            std::locale::~locale (D.41978);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40304>:
  D.41979 = 0;
  if (D.41979 != 0) goto <D.41980>; else goto <D.41981>;
  <D.41980>:
  operator delete (this);
  goto <D.41982>;
  <D.41981>:
  <D.41982>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.40127>:
  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.25;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.41990;
  int (*__vtbl_ptr_type) () * D.41991;
  long int D.41992;
  struct basic_ios * D.41994;
  int (*__vtbl_ptr_type) () * iftmp.27;
  int D.41999;
  struct basic_ios * D.42002;
  int D.42004;

  {
    if (0 == 0) goto <D.41984>; else goto <D.41985>;
    <D.41984>:
    iftmp.25 = *__vtt_parm;
    goto <D.41986>;
    <D.41985>:
    iftmp.25 = &MEM[(void *)&_ZTVSo + 24B];
    <D.41986>:
    this->_vptr.basic_ostream = iftmp.25;
    if (0 == 0) goto <D.41988>; else goto <D.41989>;
    <D.41988>:
    D.41990 = this->_vptr.basic_ostream;
    D.41991 = D.41990 + 18446744073709551592;
    D.41992 = MEM[(long int *)D.41991];
    iftmp.26 = (sizetype) D.41992;
    goto <D.41993>;
    <D.41989>:
    iftmp.26 = 8;
    <D.41993>:
    D.41994 = this + iftmp.26;
    if (0 == 0) goto <D.41996>; else goto <D.41997>;
    <D.41996>:
    iftmp.27 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.41998>;
    <D.41997>:
    iftmp.27 = &MEM[(void *)&_ZTVSo + 64B];
    <D.41998>:
    D.41994->D.19008._vptr.ios_base = iftmp.27;
    try
      {
        try
          {

          }
        finally
          {
            D.41999 = 0;
            if (D.41999 != 0) goto <D.42000>; else goto <D.42001>;
            <D.42000>:
            D.42002 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.42002);
            goto <D.42003>;
            <D.42001>:
            <D.42003>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40289>:
  D.42004 = 0;
  if (D.42004 != 0) goto <D.42005>; else goto <D.42006>;
  <D.42005>:
  operator delete (this);
  goto <D.42007>;
  <D.42006>:
  <D.42007>:
}


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

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

          }
        finally
          {
            D.42009 = &this->D.19008;
            std::ios_base::~ios_base (D.42009);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40277>:
  D.42010 = 0;
  if (D.42010 != 0) goto <D.42011>; else goto <D.42012>;
  <D.42011>:
  operator delete (this);
  goto <D.42013>;
  <D.42012>:
  <D.42013>:
}


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.40281>:
  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.42017;
  const void * * iftmp.28;
  struct basic_ostream * D.42023;
  int (*__vtbl_ptr_type) () * iftmp.29;
  const void * * D.42027;
  sizetype iftmp.30;
  int (*__vtbl_ptr_type) () * D.42032;
  int (*__vtbl_ptr_type) () * D.42033;
  long int D.42034;
  struct basic_ios * D.42036;
  int (*__vtbl_ptr_type) () * iftmp.31;
  _Ios_Openmode D.42041;
  struct __stringbuf_type * D.42042;
  struct basic_streambuf * D.42043;
  sizetype iftmp.32;
  struct basic_ios * D.42048;
  const void * * iftmp.33;

  if (1 != 0) goto <D.42015>; else goto <D.42016>;
  <D.42015>:
  D.42017 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.42017);
  goto <D.42018>;
  <D.42016>:
  <D.42018>:
  try
    {
      if (1 == 0) goto <D.42020>; else goto <D.42021>;
      <D.42020>:
      iftmp.28 = 8B;
      goto <D.42022>;
      <D.42021>:
      iftmp.28 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.42022>:
      D.42023 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.42023, iftmp.28);
      try
        {
          if (1 == 0) goto <D.42025>; else goto <D.42026>;
          <D.42025>:
          D.42027 = 0B;
          iftmp.29 = *D.42027;
          goto <D.42028>;
          <D.42026>:
          iftmp.29 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.42028>:
          this->D.22312._vptr.basic_ostream = iftmp.29;
          if (1 == 0) goto <D.42030>; else goto <D.42031>;
          <D.42030>:
          D.42032 = this->D.22312._vptr.basic_ostream;
          D.42033 = D.42032 + 18446744073709551592;
          D.42034 = MEM[(long int *)D.42033];
          iftmp.30 = (sizetype) D.42034;
          goto <D.42035>;
          <D.42031>:
          iftmp.30 = 88;
          <D.42035>:
          D.42036 = this + iftmp.30;
          if (1 == 0) goto <D.42038>; else goto <D.42039>;
          <D.42038>:
          iftmp.31 = MEM[(const void * *)0B + 24B];
          goto <D.42040>;
          <D.42039>:
          iftmp.31 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.42040>:
          D.42036->D.19008._vptr.ios_base = iftmp.31;
          D.42041 = std::operator| (__mode, 16);
          D.42042 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.42042, D.42041);
          try
            {
              D.42043 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.42045>; else goto <D.42046>;
              <D.42045>:
              D.42032 = this->D.22312._vptr.basic_ostream;
              D.42033 = D.42032 + 18446744073709551592;
              D.42034 = MEM[(long int *)D.42033];
              iftmp.32 = (sizetype) D.42034;
              goto <D.42047>;
              <D.42046>:
              iftmp.32 = 88;
              <D.42047>:
              D.42048 = this + iftmp.32;
              std::basic_ios<char>::init (D.42048, D.42043);
            }
          catch
            {
              D.42042 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.42042);
            }
        }
      catch
        {
          if (1 == 0) goto <D.42050>; else goto <D.42051>;
          <D.42050>:
          iftmp.33 = 8B;
          goto <D.42052>;
          <D.42051>:
          iftmp.33 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.42052>:
          D.42023 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.42023, iftmp.33);
        }
    }
  catch
    {
      if (1 != 0) goto <D.42053>; else goto <D.42054>;
      <D.42053>:
      D.42017 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.42017);
      goto <D.42055>;
      <D.42054>:
      <D.42055>:
    }
}


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

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


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.42062;
  int (*__vtbl_ptr_type) () * iftmp.34;
  sizetype iftmp.35;
  int (*__vtbl_ptr_type) () * D.42071;
  int (*__vtbl_ptr_type) () * D.42072;
  long int D.42073;
  struct basic_ios * D.42075;
  int (*__vtbl_ptr_type) () * iftmp.36;
  sizetype iftmp.37;
  struct basic_ios * D.42084;

  if (0 != 0) goto <D.42060>; else goto <D.42061>;
  <D.42060>:
  D.42062 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.42062);
  goto <D.42063>;
  <D.42061>:
  <D.42063>:
  try
    {
      if (0 == 0) goto <D.42065>; else goto <D.42066>;
      <D.42065>:
      iftmp.34 = *__vtt_parm;
      goto <D.42067>;
      <D.42066>:
      iftmp.34 = &MEM[(void *)&_ZTVSo + 24B];
      <D.42067>:
      this->_vptr.basic_ostream = iftmp.34;
      if (0 == 0) goto <D.42069>; else goto <D.42070>;
      <D.42069>:
      D.42071 = this->_vptr.basic_ostream;
      D.42072 = D.42071 + 18446744073709551592;
      D.42073 = MEM[(long int *)D.42072];
      iftmp.35 = (sizetype) D.42073;
      goto <D.42074>;
      <D.42070>:
      iftmp.35 = 8;
      <D.42074>:
      D.42075 = this + iftmp.35;
      if (0 == 0) goto <D.42077>; else goto <D.42078>;
      <D.42077>:
      iftmp.36 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.42079>;
      <D.42078>:
      iftmp.36 = &MEM[(void *)&_ZTVSo + 64B];
      <D.42079>:
      D.42075->D.19008._vptr.ios_base = iftmp.36;
      if (0 == 0) goto <D.42081>; else goto <D.42082>;
      <D.42081>:
      D.42071 = this->_vptr.basic_ostream;
      D.42072 = D.42071 + 18446744073709551592;
      D.42073 = MEM[(long int *)D.42072];
      iftmp.37 = (sizetype) D.42073;
      goto <D.42083>;
      <D.42082>:
      iftmp.37 = 8;
      <D.42083>:
      D.42084 = this + iftmp.37;
      std::basic_ios<char>::init (D.42084, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.42085>; else goto <D.42086>;
      <D.42085>:
      D.42062 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.42062);
      goto <D.42087>;
      <D.42086>:
      <D.42087>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.42089;
  int __a.38;
  int __b.39;
  int D.42092;

  __a.38 = (int) __a;
  __b.39 = (int) __b;
  D.42092 = __a.38 | __b.39;
  D.42089 = (_Ios_Openmode) D.42092;
  return D.42089;
}


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.42094;
  struct __string_type * D.42095;

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

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


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

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

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


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.40989;
  struct _Rep & D.42098;
  char * D.42099;
  struct _Alloc_hider * D.42100;

  std::allocator<char>::allocator (&D.40989);
  try
    {
      D.42098 = std::basic_string<char>::_S_empty_rep ();
      D.42099 = std::basic_string<char>::_Rep::_M_refdata (D.42098);
      D.42100 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.42100, D.42099, &D.40989);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.40989);
      D.40989 = {CLOBBER};
    }
  try
    {

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


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

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


_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.42106;
  void * D.42107;

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


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


