void on_print(const string&) (const struct string & str)
{
  std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&cout, str);
}


std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostream & __os, const struct basic_string & __str)
{
  struct basic_ostream & D.48808;
  long unsigned int D.48809;
  long int D.48810;
  const char * D.48811;

  D.48809 = std::basic_string<char>::size (__str);
  D.48810 = (long int) D.48809;
  D.48811 = std::basic_string<char>::data (__str);
  D.48808 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.48811, D.48810);
  return D.48808;
}


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.48816;
  struct _Rep * D.48817;

  D.48817 = std::basic_string<char>::_M_rep (this);
  D.48816 = D.48817->D.11865._M_length;
  return D.48816;
}


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.48820;
  char * D.48821;

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


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

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


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

  D.48826 = std::basic_string<char>::_M_data (this);
  return D.48826;
}


int main() ()
{
  struct iterator D.47274;
  const struct slot_type D.47195;
  struct pointer_functor1 D.47185;
  const struct basic_string D.47277;
  struct allocator D.47276;
  int D.48829;

  {
    struct signal signal_print;

    try
      {
        sigc::signal<void, const std::basic_string<char>&>::signal (&signal_print);
        try
          {
            D.47185 = sigc::ptr_fun<const std::basic_string<char>&, void> (on_print);
            try
              {
                sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<const std::basic_string<char>&, void> > (&D.47195, &D.47185);
                try
                  {
                    D.47274 = sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::connect (&signal_print.D.47125, &D.47195);
                  }
                finally
                  {
                    sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.47195);
                    D.47195 = {CLOBBER};
                  }
              }
            finally
              {
                D.47185 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.47276);
            try
              {
                std::basic_string<char>::basic_string (&D.47277, "hello world\n", &D.47276);
                try
                  {
                    sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::emit (&signal_print.D.47125, &D.47277);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.47277);
                    D.47277 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.47276);
                D.47276 = {CLOBBER};
              }
            D.48829 = 0;
            return D.48829;
          }
        finally
          {
            sigc::signal<void, const std::basic_string<char>&>::~signal (&signal_print);
          }
      }
    finally
      {
        signal_print = {CLOBBER};
      }
  }
  D.48829 = 0;
  return D.48829;
}


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::signal() [with T_return = void; T_arg1 = const std::basic_string<char>&] (struct signal * const this)
{
  struct signal1 * D.48840;

  D.48840 = &this->D.47125;
  sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::signal1 (D.48840);
  try
    {

    }
  catch
    {
      D.48840 = &this->D.47125;
      sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::~signal1 (D.48840);
    }
}


sigc::signal1<T_return, T_arg1, T_accumulator>::signal1() [with T_return = void; T_arg1 = const std::basic_string<char>&; T_accumulator = sigc::nil] (struct signal1 * const this)
{
  struct signal_base * D.48841;

  D.48841 = &this->D.47100;
  sigc::signal_base::signal_base (D.48841);
  try
    {

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = const std::basic_string<char>&; T_return = void] (void (*<T862e>) (const struct basic_string &) _A_func)
{
  struct pointer_functor1 D.48842;
  struct pointer_functor1 D.47450;

  sigc::pointer_functor1<const std::basic_string<char>&, void>::pointer_functor1 (&D.47450, _A_func);
  try
    {
      D.48842 = D.47450;
      return D.48842;
    }
  finally
    {
      D.47450 = {CLOBBER};
    }
}


sigc::pointer_functor1<T_arg1, T_return>::pointer_functor1(sigc::pointer_functor1<T_arg1, T_return>::function_type) [with T_arg1 = const std::basic_string<char>&; T_return = void; sigc::pointer_functor1<T_arg1, T_return>::function_type = void (*)(const std::basic_string<char>&)] (struct pointer_functor1 * const this, void (*function_type) (const struct basic_string &) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


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

}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&] (struct slot * const this, const struct pointer_functor1 & _A_func)
{
  struct slot1 * D.48845;

  D.48845 = &this->D.46976;
  sigc::slot1<void, const std::basic_string<char>&>::slot1<sigc::pointer_functor1<const std::basic_string<char>&, void> > (D.48845, _A_func);
  try
    {

    }
  catch
    {
      D.48845 = &this->D.46976;
      sigc::slot1<void, const std::basic_string<char>&>::~slot1 (D.48845);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.48113;
  struct slot_base * D.48846;
  struct rep_type * D.48847;
  void * (*<T1192>) (void *) D.48848;

  D.48113 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<const std::basic_string<char>&, void> >::typed_slot_rep (D.48113, _A_func);
    }
  catch
    {
      operator delete (D.48113);
    }
  D.48846 = &this->D.46934;
  sigc::slot_base::slot_base (D.48846, D.48113);
  try
    {
      D.48847 = this->D.46934.rep_;
      D.48848 = sigc::internal::slot_call1<sigc::pointer_functor1<const std::basic_string<char>&, void>, void, const std::basic_string<char>&>::address ();
      D.48847->call_ = D.48848;
    }
  catch
    {
      D.48846 = &this->D.46934;
      sigc::slot_base::~slot_base (D.48846);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (struct typed_slot_rep * const this, const struct pointer_functor1 & functor)
{
  struct slot_rep * D.48851;
  struct adaptor_type * D.48852;
  struct slot_do_bind D.48306;

  D.48851 = &this->D.48095;
  sigc::internal::slot_rep::slot_rep (D.48851, 0B, destroy, dup);
  try
    {
      D.48852 = &this->functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> >::adaptor_functor (D.48852, functor);
      D.48852 = &this->functor_;
      D.48851 = &this->D.48095;
      sigc::internal::slot_do_bind::slot_do_bind (&D.48306, D.48851);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> > > (&D.48306, D.48852);
        }
      finally
        {
          D.48306 = {CLOBBER};
        }
    }
  catch
    {
      D.48851 = &this->D.48095;
      sigc::internal::slot_rep::~slot_rep (D.48851);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (void * data)
{
  void * D.48855;
  void * D.48414;
  struct slot_rep * a_rep;

  a_rep = data;
  D.48414 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<const std::basic_string<char>&, void> >::typed_slot_rep (D.48414, a_rep);
    }
  catch
    {
      operator delete (D.48414);
    }
  D.48855 = D.48414;
  return D.48855;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1192>) (void *) D.48859;
  struct slot_rep * D.48860;
  struct adaptor_type * D.48861;
  struct slot_do_bind D.48667;

  D.48859 = cl->D.48095.call_;
  D.48860 = &this->D.48095;
  sigc::internal::slot_rep::slot_rep (D.48860, D.48859, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.48861 = &this->functor_;
      D.48860 = &this->D.48095;
      sigc::internal::slot_do_bind::slot_do_bind (&D.48667, D.48860);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> > > (&D.48667, D.48861);
        }
      finally
        {
          D.48667 = {CLOBBER};
        }
    }
  catch
    {
      D.48860 = &this->D.48095;
      sigc::internal::slot_rep::~slot_rep (D.48860);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (void * data)
{
  struct adaptor_type * D.48864;
  struct slot_do_unbind D.48399;
  void * D.48865;
  struct self * self_;

  self_ = data;
  self_->D.48095.call_ = 0B;
  self_->D.48095.destroy_ = 0B;
  D.48864 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.48399, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> > > (&D.48399, D.48864);
    }
  finally
    {
      D.48399 = {CLOBBER};
    }
  D.48865 = 0B;
  return D.48865;
}


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::pointer_functor1<const std::basic_string<char>&, void> >] (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::pointer_functor1<const std::basic_string<char>&, void> > > (&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::pointer_functor1<const std::basic_string<char>&, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.48869;

  D.48869 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::pointer_functor1<const std::basic_string<char>&, void> > (_A_action, D.48869);
}


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.48793, const struct limit_derived_target & D.48794)
{
  GIMPLE_NOP
}


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

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


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (struct adaptor_functor * const this, const struct pointer_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> >] (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::pointer_functor1<const std::basic_string<char>&, void> > > (&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::pointer_functor1<const std::basic_string<char>&, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.48872;

  D.48872 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::pointer_functor1<const std::basic_string<char>&, void> > (_A_action, D.48872);
}


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.48784, const struct limit_derived_target & D.48785)
{
  GIMPLE_NOP
}


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

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


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

  D.48876 = this->destroy_;
  if (D.48876 != 0B) goto <D.48877>; else goto <D.48878>;
  <D.48877>:
  D.48876 = this->destroy_;
  D.48876 (this);
  goto <D.48879>;
  <D.48878>:
  <D.48879>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.48880;

  D.48880 = call_it;
  return D.48880;
}


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

  typed_rep = rep;
  D.48882 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> >::operator()<const std::basic_string<char>&> (D.48882, a_1);
  return;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const std::basic_string<char>&; T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, const struct basic_string & _A_arg1)
{
  struct pointer_functor1 * D.48884;

  D.48884 = &this->functor_;
  sigc::pointer_functor1<const std::basic_string<char>&, void>::operator() (D.48884, _A_arg1);
  return;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = const std::basic_string<char>&; T_return = void; typename sigc::type_trait<T_base>::take = const std::basic_string<char>&] (const struct pointer_functor1 * const this, const struct basic_string & _A_a1)
{
  void (*<T862e>) (const struct basic_string &) D.48886;

  D.48886 = this->func_ptr_;
  D.48886 (_A_a1);
  return;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = void; T_arg1 = const std::basic_string<char>&; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.48888;
  struct iterator D.47480;
  struct iterator_type D.47470;
  const struct slot_base * D.48889;
  struct signal_base * D.48890;

  D.48889 = &slot_->D.46976.D.46934;
  D.48890 = &this->D.47100;
  D.47470 = sigc::signal_base::connect (D.48890, D.48889);
  try
    {
      sigc::slot_iterator<sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.47480, &D.47470);
      try
        {
          D.48888 = D.47480;
          return D.48888;
        }
      finally
        {
          D.47480 = {CLOBBER};
        }
    }
  finally
    {
      D.47470 = {CLOBBER};
    }
}


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


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

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

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


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

  try
    {
      {

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


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

  D.48896 = this->D.47100.impl_;
  sigc::internal::signal_emit1<void, const std::basic_string<char>&, sigc::nil>::emit (D.48896, _A_a1);
  return;
}


static sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_base>::take) [with T_arg1 = const std::basic_string<char>&; sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type = void; typename sigc::type_trait<T_base>::take = const std::basic_string<char>&] (struct signal_impl * impl, const struct basic_string & _A_a1)
{
  bool retval.0;
  bool iftmp.1;
  struct list * D.48904;
  bool D.48905;
  struct iterator D.48145;
  bool retval.2;
  bool iftmp.3;
  const struct slot_base * D.48913;
  bool D.48914;
  const struct slot_base * D.48916;
  bool D.48917;
  const struct slot_base * D.48920;
  struct rep_type * D.48921;
  void * (*<T1192>) (void *) D.48922;
  const struct slot_base * D.48923;
  struct rep_type * D.48924;
  bool retval.4;
  const struct _Self D.48148;
  struct iterator D.48147;
  struct signal_exec exec;
  struct temp_slot_list slots;

  try
    {
      if (impl == 0B) goto <D.48900>; else goto <D.48903>;
      <D.48903>:
      D.48904 = &impl->slots_;
      D.48905 = std::list<sigc::slot_base>::empty (D.48904);
      if (D.48905 != 0) goto <D.48900>; else goto <D.48901>;
      <D.48900>:
      iftmp.1 = 1;
      goto <D.48902>;
      <D.48901>:
      iftmp.1 = 0;
      <D.48902>:
      retval.0 = iftmp.1;
      if (retval.0 != 0) goto <D.48906>; else goto <D.48907>;
      <D.48906>:
      return;
      <D.48907>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.48904 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.48904);
          try
            {
              {
                struct iterator_type it;

                try
                  {
                    D.48145 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.48145);
                      }
                    finally
                      {
                        D.48145 = {CLOBBER};
                      }
                    goto <D.48152>;
                    <D.48151>:
                    D.48913 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.48914 = sigc::slot_base::empty (D.48913);
                    if (D.48914 != 0) goto <D.48910>; else goto <D.48915>;
                    <D.48915>:
                    D.48916 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.48917 = sigc::slot_base::blocked (D.48916);
                    if (D.48917 != 0) goto <D.48910>; else goto <D.48911>;
                    <D.48910>:
                    iftmp.3 = 1;
                    goto <D.48912>;
                    <D.48911>:
                    iftmp.3 = 0;
                    <D.48912>:
                    retval.2 = iftmp.3;
                    if (retval.2 != 0) goto <D.48918>; else goto <D.48919>;
                    <D.48918>:
                    goto <D.48150>;
                    <D.48919>:
                    D.48920 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.48921 = D.48920->rep_;
                    D.48922 = D.48921->call_;
                    D.48923 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.48924 = D.48923->rep_;
                    D.48922 (D.48924, _A_a1);
                    <D.48150>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.48152>:
                    D.48147 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.48148, &D.48147);
                        try
                          {
                            retval.4 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.48148);
                          }
                        finally
                          {
                            D.48148 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.48147 = {CLOBBER};
                      }
                    if (retval.4 != 0) goto <D.48151>; else goto <D.48149>;
                    <D.48149>:
                  }
                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.48937;
  struct _List_node_base * D.48938;
  const struct _List_node_base * D.48939;

  D.48938 = this->D.34095._M_impl._M_node._M_next;
  D.48939 = &this->D.34095._M_impl._M_node;
  D.48937 = D.48938 == D.48939;
  return D.48937;
}


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

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.48942;
  unsigned short D.48943;
  unsigned short D.48944;
  short int D.48945;
  short int D.48946;
  unsigned short D.48947;
  unsigned short D.48948;
  short int D.48949;

  D.48942 = this->ref_count_;
  D.48943 = (unsigned short) D.48942;
  D.48944 = D.48943 + 1;
  D.48945 = (short int) D.48944;
  this->ref_count_ = D.48945;
  D.48946 = this->exec_count_;
  D.48947 = (unsigned short) D.48946;
  D.48948 = D.48947 + 1;
  D.48949 = (short int) D.48948;
  this->exec_count_ = D.48949;
}


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.48950;
  struct slot_base D.34316;
  struct slot_list & D.48951;
  struct _List_iterator D.48952;

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


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


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

  D.48955 = &this->D.34095._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.47384, D.48955);
  try
    {
      D.48954 = D.47384;
      return D.48954;
    }
  finally
    {
      D.47384 = {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.47392;
  struct _List_node_base * D.48958;
  struct _List_node_base * D.48959;
  struct iterator D.48960;
  struct iterator D.47393;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.47392 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.48958 = D.47392._M_node;
  D.48959 = &__tmp->D.47389;
  std::__detail::_List_node_base::_M_hook (D.48959, D.48958);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.47393, __tmp);
  try
    {
      D.48960 = D.47393;
      return D.48960;
    }
  finally
    {
      D.47393 = {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.48964;
  struct slot_base * D.48965;
  struct slot_base * D.48966;
  struct _Tp_alloc_type D.47566;
  void * D.48967;
  struct _Node * D.48968;
  struct _Node * __p;

  D.48964 = &this->D.34095;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.48964);
  try
    {
      D.48965 = &__p->_M_data;
      D.48966 = std::__addressof<sigc::slot_base> (D.48965);
      D.48964 = &this->D.34095;
      D.47566 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.48964); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.47566, D.48966, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.47566);
          D.47566 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.48967 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.48967);
              D.48964 = &this->D.34095;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.48964, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.48968 = __p;
  return D.48968;
}


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.48975;
  struct _List_impl * D.48976;

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.33588)
{
  bool retval.5;
  long unsigned int D.48980;
  struct _List_node * D.48983;
  long unsigned int D.48984;

  D.48980 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.5 = D.48980 < __n;
  if (retval.5 != 0) goto <D.48981>; else goto <D.48982>;
  <D.48981>:
  std::__throw_bad_alloc ();
  <D.48982>:
  D.48984 = __n * 32;
  D.48983 = operator new (D.48984);
  return D.48983;
}


__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.48987;
  void * D.48988;

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


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

  D.48990 = __r;
  return D.48990;
}


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

  D.48993 = 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.48993);
  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.48995;

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


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.48219)
{
  void * D.48997;

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


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

  try
    {
      {

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


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.48257;
  void * D.48258;
  struct slot_base * iftmp.6;

  D.48257 = __p;
  D.48258 = operator new (16, D.48257);
  if (D.48258 != 0B) goto <D.49000>; else goto <D.49001>;
  <D.49000>:
  try
    {
      sigc::slot_base::slot_base (D.48258, __val);
    }
  catch
    {
      operator delete (D.48258, D.48257);
    }
  iftmp.6 = D.48258;
  goto <D.49002>;
  <D.49001>:
  iftmp.6 = D.48258;
  <D.49002>:
}


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

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


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

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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


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


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

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


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

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


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.49016;
  struct iterator D.47400;
  struct _List_node_base * D.49017;

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


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.49020;
  bool iftmp.7;
  struct rep_type * D.49025;
  void * (*<T1192>) (void *) D.49027;

  D.49025 = this->rep_;
  if (D.49025 == 0B) goto <D.49022>; else goto <D.49026>;
  <D.49026>:
  D.49025 = this->rep_;
  D.49027 = D.49025->call_;
  if (D.49027 == 0B) goto <D.49022>; else goto <D.49023>;
  <D.49022>:
  iftmp.7 = 1;
  goto <D.49024>;
  <D.49023>:
  iftmp.7 = 0;
  <D.49024>:
  D.49020 = iftmp.7;
  return D.49020;
}


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

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


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.49031;
  const struct _List_node_base * D.49032;
  const struct slot_base * D.49033;

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


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

  D.49035 = __r;
  return D.49035;
}


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.49037;
  struct _List_node_base * D.49038;
  struct _Self & D.49039;

  D.49037 = this->_M_node;
  D.49038 = D.49037->_M_next;
  this->_M_node = D.49038;
  D.49039 = this;
  return D.49039;
}


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

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


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

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


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.49044;
  const struct _List_node_base * D.49045;
  const struct _List_node_base * D.49046;

  D.49045 = this->_M_node;
  D.49046 = __x->_M_node;
  D.49044 = D.49045 != D.49046;
  return D.49044;
}


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

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


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.49050;
  struct _List_node_base * D.49051;
  struct _List_iterator D.49052;
  struct iterator D.49053;
  struct iterator __ret;

  try
    {
      D.49050 = __position._M_node;
      D.49051 = D.49050->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.49051);
      D.49052 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.49052);
      D.49053 = __ret;
      return D.49053;
    }
  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.49057;
  struct slot_base * D.49058;
  struct slot_base * D.49059;
  struct _Tp_alloc_type D.47572;
  struct _List_base * D.49060;
  struct _Node * __n;

  D.49057 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.49057);
  __n = __position._M_node;
  D.49058 = &__n->_M_data;
  D.49059 = std::__addressof<sigc::slot_base> (D.49058);
  D.49060 = &this->D.34095;
  D.47572 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.49060); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.47572, D.49059);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.47572);
      D.47572 = {CLOBBER};
    }
  D.49060 = &this->D.34095;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.49060, __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.49062;

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.8;
  short int D.49065;
  unsigned short D.49066;
  unsigned short D.49067;
  short int D.49068;
  bool retval.9;
  bool iftmp.10;
  short int D.49079;
  unsigned short D.49080;
  unsigned short D.49081;
  short int D.49082;
  bool D.49084;

  D.49065 = this->ref_count_;
  D.49066 = (unsigned short) D.49065;
  D.49067 = D.49066 + 65535;
  D.49068 = (short int) D.49067;
  this->ref_count_ = D.49068;
  D.49065 = this->ref_count_;
  retval.8 = D.49065 == 0;
  if (retval.8 != 0) goto <D.49069>; else goto <D.49070>;
  <D.49069>:
  if (this != 0B) goto <D.49071>; else goto <D.49072>;
  <D.49071>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.49073>;
  <D.49072>:
  <D.49073>:
  goto <D.49074>;
  <D.49070>:
  D.49079 = this->exec_count_;
  D.49080 = (unsigned short) D.49079;
  D.49081 = D.49080 + 65535;
  D.49082 = (short int) D.49081;
  this->exec_count_ = D.49082;
  D.49079 = this->exec_count_;
  if (D.49079 == 0) goto <D.49083>; else goto <D.49077>;
  <D.49083>:
  D.49084 = this->deferred_;
  if (D.49084 != 0) goto <D.49085>; else goto <D.49077>;
  <D.49085>:
  iftmp.10 = 1;
  goto <D.49078>;
  <D.49077>:
  iftmp.10 = 0;
  <D.49078>:
  retval.9 = iftmp.10;
  if (retval.9 != 0) goto <D.49086>; else goto <D.49087>;
  <D.49086>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.49088>;
  <D.49087>:
  <D.49088>:
  <D.49074>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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

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


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.49096;
  struct slot_base * D.49097;
  struct _Tp_alloc_type D.47555;
  struct _List_node_base * D.49098;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.47389._M_next;
    D.49096 = &__tmp->_M_data;
    D.49097 = std::__addressof<sigc::slot_base> (D.49096);
    D.47555 = 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.47555, D.49097);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.47555);
        D.47555 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.47559>:
  D.49098 = &this->_M_impl._M_node;
  if (D.49098 != __cur) goto <D.47560>; else goto <D.47558>;
  <D.47558>:
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<void, const std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot() (struct slot * const this)
{
  struct slot1 * D.49102;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49102 = &this->D.46976;
            sigc::slot1<void, const std::basic_string<char>&>::~slot1 (D.49102);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47225>:
}


sigc::slot1<void, const std::basic_string<char>&>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.49104;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49104 = &this->D.46934;
            sigc::slot_base::~slot_base (D.49104);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47220>:
}


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.47512;
  struct _Rep * D.49106;
  struct _Alloc_hider * D.49107;

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


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

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

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


__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.7882)
{
  void * D.49116;

  try
    {
      {

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


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.11;
  struct _Rep & D.49118;
  bool D.49119;
  long int D.49120;
  long int D.49121;
  bool retval.12;
  _Atomic_word * D.49125;
  int D.49126;

  D.49118 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.49119 = D.49118 != this;
  D.49120 = (long int) D.49119;
  D.49121 = __builtin_expect (D.49120, 0);
  retval.11 = D.49121 != 0;
  if (retval.11 != 0) goto <D.49122>; else goto <D.49123>;
  <D.49122>:
  D.49125 = &this->D.11865._M_refcount;
  D.49126 = __gnu_cxx::__exchange_and_add_dispatch (D.49125, -1);
  retval.12 = D.49126 <= 0;
  if (retval.12 != 0) goto <D.49127>; else goto <D.49128>;
  <D.49127>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.49129>;
  <D.49128>:
  <D.49129>:
  goto <D.49130>;
  <D.49123>:
  <D.49130>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.13;
  int D.49135;
  _Atomic_word D.49138;

  D.49135 = __gthread_active_p ();
  retval.13 = D.49135 != 0;
  if (retval.13 != 0) goto <D.49136>; else goto <D.49137>;
  <D.49136>:
  D.49138 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.49138;
  <D.49137>:
  D.49138 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.49138;
}


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

  D.49141 = __gthrw___pthread_key_create != 0B;
  D.49140 = (int) D.49141;
  return D.49140;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.49143;
  unsigned int __val.14;
  unsigned int D.49145;

  __val.14 = (unsigned int) __val;
  D.49145 = __atomic_fetch_add_4 (__mem, __val.14, 4);
  D.49143 = (_Atomic_word) D.49145;
  return D.49143;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.49147;
  int D.49148;
  _Atomic_word D.49149;
  _Atomic_word __result;

  __result = *__mem;
  D.49147 = *__mem;
  D.49148 = D.49147 + __val;
  *__mem = D.49148;
  D.49149 = __result;
  return D.49149;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::signal<void, const std::basic_string<char>&>::~signal() (struct signal * const this)
{
  struct signal1 * D.49153;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49153 = &this->D.47125;
            sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::~signal1 (D.49153);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47156>:
}


sigc::signal1<void, const std::basic_string<char>&, sigc::nil>::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.49155;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49155 = &this->D.47100;
            sigc::signal_base::~signal_base (D.49155);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47151>:
}


(static initializers for hello_world.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.49157>; else goto <D.49158>;
  <D.49157>:
  if (__priority == 65535) goto <D.49159>; else goto <D.49160>;
  <D.49159>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  goto <D.49161>;
  <D.49160>:
  <D.49161>:
  goto <D.49162>;
  <D.49158>:
  <D.49162>:
}


