int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.54428;
  int D.54431;
  int iftmp.1;
  bool D.54433;
  struct iterator D.52918;
  const struct slot_type D.52839;
  struct bind_functor D.52737;
  struct pointer_functor1 D.51891;
  struct iterator D.52922;
  const struct slot_type D.52921;
  struct bind_functor D.52920;
  struct pointer_functor1 D.52919;
  struct iterator D.52926;
  const struct slot_type D.52925;
  struct bind_functor D.52924;
  struct pointer_functor1 D.52923;
  int D.54437;
  const struct string D.52929;
  struct allocator D.52928;
  int iftmp.2;
  bool D.54439;

  {
    struct TestUtilities * util;
    struct signal0 signal;

    try
      {
        util = TestUtilities::get_instance ();
        D.54428 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.54428;
        if (retval.0 != 0) goto <D.54429>; else goto <D.54430>;
        <D.54429>:
        D.54433 = TestUtilities::get_result_and_delete_instance ();
        if (D.54433 != 0) goto <D.54434>; else goto <D.54435>;
        <D.54434>:
        iftmp.1 = 0;
        goto <D.54436>;
        <D.54435>:
        iftmp.1 = 1;
        <D.54436>:
        D.54431 = iftmp.1;
        return D.54431;
        <D.54430>:
        sigc::signal0<int, {anonymous}::min_accum<int> >::signal0 (&signal);
        try
          {
            D.51891 = sigc::ptr_fun<int, int> (ident);
            try
              {
                D.52737 = sigc::bind<int, sigc::pointer_functor1<int, int> > (&D.51891, 3); [return slot optimization]
                try
                  {
                    sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52839, &D.52737);
                    try
                      {
                        D.52918 = sigc::signal0<int, {anonymous}::min_accum<int> >::connect (&signal, &D.52839);
                      }
                    finally
                      {
                        sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.52839);
                        D.52839 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.52737 = {CLOBBER};
                  }
              }
            finally
              {
                D.51891 = {CLOBBER};
              }
            D.52919 = sigc::ptr_fun<int, int> (ident);
            try
              {
                D.52920 = sigc::bind<int, sigc::pointer_functor1<int, int> > (&D.52919, 1); [return slot optimization]
                try
                  {
                    sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52921, &D.52920);
                    try
                      {
                        D.52922 = sigc::signal0<int, {anonymous}::min_accum<int> >::connect (&signal, &D.52921);
                      }
                    finally
                      {
                        sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.52921);
                        D.52921 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.52920 = {CLOBBER};
                  }
              }
            finally
              {
                D.52919 = {CLOBBER};
              }
            D.52923 = sigc::ptr_fun<int, int> (ident);
            try
              {
                D.52924 = sigc::bind<int, sigc::pointer_functor1<int, int> > (&D.52923, 42); [return slot optimization]
                try
                  {
                    sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.52925, &D.52924);
                    try
                      {
                        D.52926 = sigc::signal0<int, {anonymous}::min_accum<int> >::connect (&signal, &D.52925);
                      }
                    finally
                      {
                        sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.52925);
                        D.52925 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.52924 = {CLOBBER};
                  }
              }
            finally
              {
                D.52923 = {CLOBBER};
              }
            D.54437 = sigc::signal0<int, {anonymous}::min_accum<int> >::operator() (&signal);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.54437);
            std::allocator<char>::allocator (&D.52928);
            try
              {
                std::basic_string<char>::basic_string (&D.52929, "1", &D.52928);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.52929);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.52929);
                    D.52929 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.52928);
                D.52928 = {CLOBBER};
              }
            D.54439 = TestUtilities::get_result_and_delete_instance ();
            if (D.54439 != 0) goto <D.54440>; else goto <D.54441>;
            <D.54440>:
            iftmp.2 = 0;
            goto <D.54442>;
            <D.54441>:
            iftmp.2 = 1;
            <D.54442>:
            D.54431 = iftmp.2;
            return D.54431;
          }
        finally
          {
            sigc::signal0<int, {anonymous}::min_accum<int> >::~signal0 (&signal);
          }
      }
    finally
      {
        signal = {CLOBBER};
      }
  }
  D.54431 = 0;
  return D.54431;
}


int {anonymous}::ident(int) (int i)
{
  int D.54465;

  D.54465 = i;
  return D.54465;
}


sigc::signal0<T_return, T_accumulator>::signal0() [with T_return = int; T_accumulator = {anonymous}::min_accum<int>] (struct signal0 * const this)
{
  struct signal_base * D.54467;

  D.54467 = &this->D.51840;
  sigc::signal_base::signal_base (D.54467);
  try
    {

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = int] (int (*<T91a4>) (int) _A_func)
{
  struct pointer_functor1 D.54468;
  struct pointer_functor1 D.53113;

  sigc::pointer_functor1<int, int>::pointer_functor1 (&D.53113, _A_func);
  try
    {
      D.54468 = D.53113;
      return D.54468;
    }
  finally
    {
      D.53113 = {CLOBBER};
    }
}


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


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

}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = int; T_functor = sigc::pointer_functor1<int, int>] (const struct pointer_functor1 & _A_func, int _A_b1)
{
  sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::pointer_functor1<int, int>; T_type1 = int; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor1<int, int>&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct pointer_functor1 & _A_func, const int & _A_bound1)
{
  struct adapts * D.54473;
  struct bound_argument * D.54474;

  D.54473 = &this->D.52734;
  sigc::adapts<sigc::pointer_functor1<int, int> >::adapts (D.54473, _A_func);
  D.54474 = &this->bound1_;
  sigc::bound_argument<int>::bound_argument (D.54474, _A_bound1);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.54475 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<int, int> >::adaptor_functor (D.54475, _A_functor);
}


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


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


sigc::bound_argument<T_type>::bound_argument(const T_type&) [with T_type = int] (struct bound_argument * const this, const int & _A_argument)
{
  int D.54476;

  D.54476 = *_A_argument;
  this->visited_ = D.54476;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = int] (struct slot * const this, const struct bind_functor & _A_func)
{
  struct slot0 * D.54477;

  D.54477 = &this->D.52828;
  sigc::slot0<int>::slot0<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.54477, _A_func);
  try
    {

    }
  catch
    {
      D.54477 = &this->D.52828;
      sigc::slot0<int>::~slot0 (D.54477);
    }
}


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = int] (struct slot0 * const this, const struct bind_functor & _A_func)
{
  void * D.53413;
  struct slot_base * D.54478;
  struct rep_type * D.54479;
  void * (*<T1711>) (void *) D.54480;

  D.53413 = operator new (80);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.53413, _A_func);
    }
  catch
    {
      operator delete (D.53413);
    }
  D.54478 = &this->D.52786;
  sigc::slot_base::slot_base (D.54478, D.53413);
  try
    {
      D.54479 = this->D.52786.rep_;
      D.54480 = sigc::internal::slot_call0<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, int>::address ();
      D.54479->call_ = D.54480;
    }
  catch
    {
      D.54478 = &this->D.52786;
      sigc::slot_base::~slot_base (D.54478);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct bind_functor & functor)
{
  struct slot_rep * D.54483;
  struct adaptor_type * D.54484;
  struct slot_do_bind D.53637;

  D.54483 = &this->D.53396;
  sigc::internal::slot_rep::slot_rep (D.54483, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.54484 = &this->functor_;
      D.54483 = &this->D.53396;
      sigc::internal::slot_do_bind::slot_do_bind (&D.53637, D.54483);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.53637, D.54484);
        }
      finally
        {
          D.53637 = {CLOBBER};
        }
    }
  catch
    {
      D.54483 = &this->D.53396;
      sigc::internal::slot_rep::~slot_rep (D.54483);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.54487;
  void * D.53852;
  struct slot_rep * a_rep;

  a_rep = data;
  D.53852 = operator new (80);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.53852, a_rep);
    }
  catch
    {
      operator delete (D.53852);
    }
  D.54487 = D.53852;
  return D.54487;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.54491;
  struct slot_rep * D.54492;
  struct adaptor_type * D.54493;
  struct slot_do_bind D.53970;

  D.54491 = cl->D.53396.call_;
  D.54492 = &this->D.53396;
  sigc::internal::slot_rep::slot_rep (D.54492, D.54491, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.54493 = &this->functor_;
      D.54492 = &this->D.53396;
      sigc::internal::slot_do_bind::slot_do_bind (&D.53970, D.54492);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.53970, D.54493);
        }
      finally
        {
          D.53970 = {CLOBBER};
        }
    }
  catch
    {
      D.54492 = &this->D.53396;
      sigc::internal::slot_rep::~slot_rep (D.54492);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.54496;
  struct slot_do_unbind D.53837;
  void * D.54497;
  struct self * self_;

  self_ = data;
  self_->D.53396.call_ = 0B;
  self_->D.53396.destroy_ = 0B;
  D.54496 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.53837, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.53837, D.54496);
    }
  finally
    {
      D.53837 = {CLOBBER};
    }
  D.54497 = 0B;
  return D.54497;
}


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct bind_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<int, int>; T_type1 = int] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.54501;
  const struct bound_argument * D.54502;

  D.54501 = &_A_target->D.52734.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (_A_action, D.54501);
  D.54502 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<int> > (_A_action, D.54502);
}


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


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

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


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<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, int> >::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<int, int>] (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<int, int> > (_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<int, int>; 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<int, int>, 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<int, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.54385, const struct limit_derived_target & D.54386)
{
  GIMPLE_NOP
}


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


static void sigc::visitor<sigc::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = int] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const int & D.54504;

  D.54504 = sigc::bound_argument<int>::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, int> (_A_action, D.54504);
}


const T_type& sigc::bound_argument<T_type>::visit() const [with T_type = int] (const struct bound_argument * const this)
{
  const int & D.54505;

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


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


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

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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct bind_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<int, int>; T_type1 = int] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.54509;
  const struct bound_argument * D.54510;

  D.54509 = &_A_target->D.52734.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (_A_action, D.54509);
  D.54510 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<int> > (_A_action, D.54510);
}


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


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

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


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<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, int> >::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<int, int>] (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<int, int> > (_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<int, int>; 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<int, int>, 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<int, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.54354, const struct limit_derived_target & D.54355)
{
  GIMPLE_NOP
}


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


static void sigc::visitor<sigc::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = int] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const int & D.54512;

  D.54512 = sigc::bound_argument<int>::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, int> (_A_action, D.54512);
}


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


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


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

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


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

  D.54516 = this->destroy_;
  if (D.54516 != 0B) goto <D.54517>; else goto <D.54518>;
  <D.54517>:
  D.54516 = this->destroy_;
  D.54516 (this);
  goto <D.54519>;
  <D.54518>:
  <D.54519>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.54520;

  D.54520 = call_it;
  return D.54520;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = int] (struct slot_rep * rep)
{
  int D.54522;
  struct adaptor_type * D.54523;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.54523 = &typed_rep->functor_;
  D.54522 = sigc::bind_functor<-1, sigc::pointer_functor1<int, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (D.54523);
  return D.54522;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = sigc::pointer_functor1<int, int>; T_type1 = int; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = int] (struct bind_functor * const this)
{
  result_type D.54526;
  struct bound_argument * D.54527;
  int & D.54528;
  struct adaptor_type * D.54529;

  D.54527 = &this->bound1_;
  D.54528 = sigc::bound_argument<int>::invoke (D.54527);
  D.54529 = &this->D.52734.functor_;
  D.54526 = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >::operator()<int&> (D.54529, D.54528);
  return D.54526;
}


T_type& sigc::bound_argument<T_type>::invoke() [with T_type = int] (struct bound_argument * const this)
{
  int & D.54532;

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


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

  D.54535 = &this->functor_;
  D.54534 = sigc::pointer_functor1<int, int>::operator() (D.54535, _A_arg1);
  return D.54534;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = int; T_return = int; typename sigc::type_trait<T_base>::take = const int&] (const struct pointer_functor1 * const this, const int & _A_a1)
{
  int D.54538;
  int (*<T91a4>) (int) D.54539;
  int D.54540;

  D.54539 = this->func_ptr_;
  D.54540 = *_A_a1;
  D.54538 = D.54539 (D.54540);
  return D.54538;
}


sigc::signal0<T_return, T_accumulator>::iterator sigc::signal0<T_return, T_accumulator>::connect(const slot_type&) [with T_return = int; T_accumulator = {anonymous}::min_accum<int>; sigc::signal0<T_return, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal0<T_return, T_accumulator>::slot_type = sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal0 * const this, const struct slot_type & slot_)
{
  struct iterator D.54543;
  struct iterator D.53154;
  struct iterator_type D.53144;
  const struct slot_base * D.54544;
  struct signal_base * D.54545;

  D.54544 = &slot_->D.52828.D.52786;
  D.54545 = &this->D.51840;
  D.53144 = sigc::signal_base::connect (D.54545, D.54544);
  try
    {
      sigc::slot_iterator<sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.53154, &D.53144);
      try
        {
          D.54543 = D.53154;
          return D.54543;
        }
      finally
        {
          D.53154 = {CLOBBER};
        }
    }
  finally
    {
      D.53144 = {CLOBBER};
    }
}


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


sigc::signal0<T_return, T_accumulator>::result_type sigc::signal0<T_return, T_accumulator>::operator()() const [with T_return = int; T_accumulator = {anonymous}::min_accum<int>; sigc::signal0<T_return, T_accumulator>::result_type = int] (const struct signal0 * const this)
{
  result_type D.54549;

  D.54549 = sigc::signal0<int, {anonymous}::min_accum<int> >::emit (this);
  return D.54549;
}


sigc::signal0<T_return, T_accumulator>::result_type sigc::signal0<T_return, T_accumulator>::emit() const [with T_return = int; T_accumulator = {anonymous}::min_accum<int>; sigc::signal0<T_return, T_accumulator>::result_type = int] (const struct signal0 * const this)
{
  result_type D.54552;
  struct signal_impl * D.54553;

  D.54553 = this->D.51840.impl_;
  D.54552 = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >::emit (D.54553);
  return D.54552;
}


static sigc::internal::signal_emit0<T_return, T_accumulator>::result_type sigc::internal::signal_emit0<T_return, T_accumulator>::emit(sigc::internal::signal_impl*) [with T_return = int; T_accumulator = {anonymous}::min_accum<int>; sigc::internal::signal_emit0<T_return, T_accumulator>::result_type = int] (struct signal_impl * impl)
{
  result_type D.54558;
  struct slot_iterator_buf_type D.53707;
  struct slot_iterator_buf_type D.53706;
  struct list * D.54559;
  struct slot_iterator_buf_type D.53737;
  const struct iterator_type D.53736;
  struct iterator D.53735;
  struct slot_iterator_buf_type D.53734;
  const struct iterator_type D.53733;
  struct iterator D.53732;
  struct min_accum accumulator;
  struct signal_exec exec;
  struct temp_slot_list slots;
  struct self_type self;

  try
    {
      if (impl == 0B) goto <D.54556>; else goto <D.54557>;
      <D.54556>:
      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::slot_iterator_buf (&D.53707);
      try
        {
          sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::slot_iterator_buf (&D.53706);
          try
            {
              D.54558 = {anonymous}::min_accum<int>::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int> > (&accumulator, D.53706, D.53707);
              return D.54558;
            }
          finally
            {
              D.53706 = {CLOBBER};
            }
        }
      finally
        {
          D.53707 = {CLOBBER};
        }
      <D.54557>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.54559 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.54559);
          try
            {
              sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >::signal_emit0 (&self);
              D.53735 = sigc::internal::temp_slot_list::end (&slots);
              try
                {
                  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.53736, &D.53735);
                  try
                    {
                      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::slot_iterator_buf (&D.53737, &D.53736, &self);
                      try
                        {
                          D.53732 = sigc::internal::temp_slot_list::begin (&slots);
                          try
                            {
                              std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.53733, &D.53732);
                              try
                                {
                                  sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::slot_iterator_buf (&D.53734, &D.53733, &self);
                                  try
                                    {
                                      D.54558 = {anonymous}::min_accum<int>::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int> > (&accumulator, D.53734, D.53737);
                                      return D.54558;
                                    }
                                  finally
                                    {
                                      D.53734 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.53733 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.53732 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.53737 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.53736 = {CLOBBER};
                    }
                }
              finally
                {
                  D.53735 = {CLOBBER};
                }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      accumulator = {CLOBBER};
      exec = {CLOBBER};
      slots = {CLOBBER};
      self = {CLOBBER};
    }
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf() [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.54585;

  D.54585 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (D.54585);
  this->c_ = 0B;
  this->invoked_ = 0;
}


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


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

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.54587;
  unsigned short D.54588;
  unsigned short D.54589;
  short int D.54590;
  short int D.54591;
  unsigned short D.54592;
  unsigned short D.54593;
  short int D.54594;

  D.54587 = this->ref_count_;
  D.54588 = (unsigned short) D.54587;
  D.54589 = D.54588 + 1;
  D.54590 = (short int) D.54589;
  this->ref_count_ = D.54590;
  D.54591 = this->exec_count_;
  D.54592 = (unsigned short) D.54591;
  D.54593 = D.54592 + 1;
  D.54594 = (short int) D.54593;
  this->exec_count_ = D.54594;
}


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.54595;
  struct slot_base D.35400;
  struct slot_list & D.54596;
  struct _List_iterator D.54597;

  this->slots_ = slots;
  D.54595 = &this->placeholder;
  std::_List_iterator<sigc::slot_base>::_List_iterator (D.54595);
  sigc::slot_base::slot_base (&D.35400);
  try
    {
      D.54596 = this->slots_;
      D.54597 = std::list<sigc::slot_base>::end (D.54596);
      D.54596 = this->slots_;
      this->placeholder = std::list<sigc::slot_base>::insert (D.54596, D.54597, &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.54599;
  struct iterator D.53036;
  struct _List_node_base * D.54600;

  D.54600 = &this->D.35179._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.53036, D.54600);
  try
    {
      D.54599 = D.53036;
      return D.54599;
    }
  finally
    {
      D.53036 = {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.53044;
  struct _List_node_base * D.54603;
  struct _List_node_base * D.54604;
  struct iterator D.54605;
  struct iterator D.53045;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.53044 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.54603 = D.53044._M_node;
  D.54604 = &__tmp->D.53041;
  std::__detail::_List_node_base::_M_hook (D.54604, D.54603);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.53045, __tmp);
  try
    {
      D.54605 = D.53045;
      return D.54605;
    }
  finally
    {
      D.53045 = {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.54609;
  struct slot_base * D.54610;
  struct slot_base * D.54611;
  struct _Tp_alloc_type D.53240;
  void * D.54612;
  struct _Node * D.54613;
  struct _Node * __p;

  D.54609 = &this->D.35179;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.54609);
  try
    {
      D.54610 = &__p->_M_data;
      D.54611 = std::__addressof<sigc::slot_base> (D.54610);
      D.54609 = &this->D.35179;
      D.53240 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.54609); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.53240, D.54611, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.53240);
          D.53240 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.54612 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.54612);
              D.54609 = &this->D.35179;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.54609, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.54613 = __p;
  return D.54613;
}


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.54620;
  struct _List_impl * D.54621;

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


_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.3;
  long unsigned int D.54625;
  struct _List_node * D.54628;
  long unsigned int D.54629;

  D.54625 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.3 = D.54625 < __n;
  if (retval.3 != 0) goto <D.54626>; else goto <D.54627>;
  <D.54626>:
  std::__throw_bad_alloc ();
  <D.54627>:
  D.54629 = __n * 32;
  D.54628 = operator new (D.54629);
  return D.54628;
}


__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.54632;
  void * D.54633;

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


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

  D.54635 = __r;
  return D.54635;
}


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

  D.54638 = 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.54638);
  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.54640;

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


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.53508)
{
  void * D.54642;

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


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

  try
    {
      {

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


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.53546;
  void * D.53547;
  struct slot_base * iftmp.4;

  D.53546 = __p;
  D.53547 = operator new (16, D.53546);
  if (D.53547 != 0B) goto <D.54645>; else goto <D.54646>;
  <D.54645>:
  try
    {
      sigc::slot_base::slot_base (D.53547, __val);
    }
  catch
    {
      operator delete (D.53547, D.53546);
    }
  iftmp.4 = D.53547;
  goto <D.54647>;
  <D.54646>:
  iftmp.4 = D.53547;
  <D.54647>:
}


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

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


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

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.54655 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.54655, __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.54656;

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


sigc::internal::signal_emit0<T_return, T_accumulator>::signal_emit0() [with T_return = int; T_accumulator = {anonymous}::min_accum<int>] (struct signal_emit0 * const this)
{

}


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

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


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

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


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.54663;
  struct iterator D.53052;
  struct _List_node_base * D.54664;

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


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

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


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf(const iterator_type&, const emitter_type*) [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::iterator_type = std::_List_const_iterator<sigc::slot_base>; sigc::internal::slot_iterator_buf<T_emitter, T_result>::emitter_type = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >] (struct slot_iterator_buf * const this, const struct iterator_type & i, const struct emitter_type * c)
{
  this->i_ = MEM[(const struct _List_const_iterator &)i];
  this->c_ = c;
  this->invoked_ = 0;
}


typename std::iterator_traits<_ForwardIterator1>::value_type {anonymous}::min_accum<T>::operator()(I, I) [with I = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>; T = int; typename std::iterator_traits<_ForwardIterator1>::value_type = int] (struct min_accum * const this, struct slot_iterator_buf i1, struct slot_iterator_buf i2)
{
  value_type D.54668;
  struct slot_iterator_buf D.53903;

  D.53903 = std::min_element<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int> > (i1, i2); [return slot optimization]
  try
    {
      D.54668 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator* (&D.53903);
      return D.54668;
    }
  finally
    {
      D.53903 = {CLOBBER};
    }
}


_FIter std::min_element(_FIter, _FIter) [with _FIter = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>] (struct slot_iterator_buf __first, struct slot_iterator_buf __last)
{
  struct _Iter_less_iter D.54121;
  struct _Iter_less_iter D.54674;

  __gnu_cxx::__ops::__iter_less_iter ();
  try
    {
      <retval> = std::__min_element<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>, __gnu_cxx::__ops::_Iter_less_iter> (__first, __last, D.54674); [return slot optimization]
      return <retval>;
    }
  finally
    {
      D.54121 = {CLOBBER};
    }
}


__gnu_cxx::__ops::_Iter_less_iter __gnu_cxx::__ops::__iter_less_iter() ()
{
  struct _Iter_less_iter D.54678;

  return D.54678;
}


_ForwardIterator std::__min_element(_ForwardIterator, _ForwardIterator, _Compare) [with _ForwardIterator = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>; _Compare = __gnu_cxx::__ops::_Iter_less_iter] (struct slot_iterator_buf __first, struct slot_iterator_buf __last, struct _Iter_less_iter __comp)
{
  bool retval.5;
  bool retval.6;
  bool retval.7;
  struct slot_iterator_buf & D.54689;
  struct slot_iterator_buf __result;

  try
    {
      retval.5 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator== (&__first, &__last);
      if (retval.5 != 0) goto <D.54682>; else goto <D.54683>;
      <D.54682>:
      <retval> = __first;
      return <retval>;
      <D.54683>:
      __result = __first;
      goto <D.54182>;
      <D.54183>:
      retval.6 = __gnu_cxx::__ops::_Iter_less_iter::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>, sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int> > (&__comp, __first, __result);
      if (retval.6 != 0) goto <D.54685>; else goto <D.54686>;
      <D.54685>:
      MEM[(struct slot_iterator_buf *)&__result] = MEM[(struct slot_iterator_buf *)&__first];
      goto <D.54687>;
      <D.54686>:
      <D.54687>:
      <D.54182>:
      D.54689 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator++ (&__first);
      retval.7 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator!= (D.54689, &__last);
      if (retval.7 != 0) goto <D.54183>; else goto <D.54181>;
      <D.54181>:
      <retval> = __result;
      return <retval>;
    }
  finally
    {
      __result = {CLOBBER};
    }
}


bool sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator==(const sigc::internal::slot_iterator_buf<T_emitter, T_result>&) const [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int] (const struct slot_iterator_buf * const this, const struct slot_iterator_buf & other)
{
  bool D.54695;
  bool iftmp.8;
  const struct emitter_type * D.54700;
  const struct iterator_type * D.54702;
  const struct iterator_type * D.54703;
  bool D.54704;

  D.54700 = this->c_;
  if (D.54700 == 0B) goto <D.54697>; else goto <D.54701>;
  <D.54701>:
  D.54702 = &other->i_;
  D.54703 = &this->i_;
  D.54704 = std::_List_const_iterator<sigc::slot_base>::operator== (D.54703, D.54702);
  if (D.54704 != 0) goto <D.54697>; else goto <D.54698>;
  <D.54697>:
  iftmp.8 = 1;
  goto <D.54699>;
  <D.54698>:
  iftmp.8 = 0;
  <D.54699>:
  D.54695 = iftmp.8;
  return D.54695;
}


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.54706;
  const struct _List_node_base * D.54707;
  const struct _List_node_base * D.54708;

  D.54707 = this->_M_node;
  D.54708 = __x->_M_node;
  D.54706 = D.54707 == D.54708;
  return D.54706;
}


bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>; _Iterator2 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>] (const struct _Iter_less_iter * const this, struct slot_iterator_buf __it1, struct slot_iterator_buf __it2)
{
  bool D.54710;
  int D.54711;
  int D.54712;

  D.54711 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator* (&__it1);
  D.54712 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >, int>::operator* (&__it2);
  D.54710 = D.54711 < D.54712;
  return D.54710;
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>& sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator++() [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.54716;
  struct slot_iterator_buf & D.54717;

  D.54716 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::operator++ (D.54716);
  this->invoked_ = 0;
  D.54717 = this;
  return D.54717;
}


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.54719;
  struct _List_node_base * D.54720;
  struct _Self & D.54721;

  D.54719 = this->_M_node;
  D.54720 = D.54719->_M_next;
  this->_M_node = D.54720;
  D.54721 = this;
  return D.54721;
}


bool sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator!=(const sigc::internal::slot_iterator_buf<T_emitter, T_result>&) const [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int] (const struct slot_iterator_buf * const this, const struct slot_iterator_buf & other)
{
  bool D.54723;
  bool iftmp.9;
  const struct emitter_type * D.54727;
  const struct iterator_type * D.54729;
  const struct iterator_type * D.54730;
  bool D.54731;

  D.54727 = this->c_;
  if (D.54727 != 0B) goto <D.54728>; else goto <D.54725>;
  <D.54728>:
  D.54729 = &other->i_;
  D.54730 = &this->i_;
  D.54731 = std::_List_const_iterator<sigc::slot_base>::operator!= (D.54730, D.54729);
  if (D.54731 != 0) goto <D.54732>; else goto <D.54725>;
  <D.54732>:
  iftmp.9 = 1;
  goto <D.54726>;
  <D.54725>:
  iftmp.9 = 0;
  <D.54726>:
  D.54723 = iftmp.9;
  return D.54723;
}


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.54734;
  const struct _List_node_base * D.54735;
  const struct _List_node_base * D.54736;

  D.54735 = this->_M_node;
  D.54736 = __x->_M_node;
  D.54734 = D.54735 != D.54736;
  return D.54734;
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator*() const [with T_emitter = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type = int] (const struct slot_iterator_buf * const this)
{
  bool retval.10;
  bool iftmp.11;
  const struct iterator_type * D.54742;
  const struct slot_base * D.54743;
  bool D.54744;
  bool D.54745;
  const struct slot_base * D.54747;
  bool D.54748;
  bool D.54749;
  bool D.54751;
  bool D.54752;
  const struct slot_base & D.54756;
  const struct emitter_type * D.54757;
  int D.54758;
  result_type D.54760;

  D.54742 = &this->i_;
  D.54743 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.54742);
  D.54744 = sigc::slot_base::empty (D.54743);
  D.54745 = ~D.54744;
  if (D.54745 != 0) goto <D.54746>; else goto <D.54740>;
  <D.54746>:
  D.54742 = &this->i_;
  D.54747 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.54742);
  D.54748 = sigc::slot_base::blocked (D.54747);
  D.54749 = ~D.54748;
  if (D.54749 != 0) goto <D.54750>; else goto <D.54740>;
  <D.54750>:
  D.54751 = this->invoked_;
  D.54752 = ~D.54751;
  if (D.54752 != 0) goto <D.54753>; else goto <D.54740>;
  <D.54753>:
  iftmp.11 = 1;
  goto <D.54741>;
  <D.54740>:
  iftmp.11 = 0;
  <D.54741>:
  retval.10 = iftmp.11;
  if (retval.10 != 0) goto <D.54754>; else goto <D.54755>;
  <D.54754>:
  D.54742 = &this->i_;
  D.54756 = std::_List_const_iterator<sigc::slot_base>::operator* (D.54742);
  D.54757 = this->c_;
  D.54758 = sigc::internal::signal_emit0<int, {anonymous}::min_accum<int> >::operator() (D.54757, D.54756);
  this->r_ = D.54758;
  this->invoked_ = 1;
  goto <D.54759>;
  <D.54755>:
  <D.54759>:
  D.54760 = this->r_;
  return D.54760;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.54765;
  bool iftmp.12;
  struct rep_type * D.54770;
  void * (*<T1711>) (void *) D.54772;

  D.54770 = this->rep_;
  if (D.54770 == 0B) goto <D.54767>; else goto <D.54771>;
  <D.54771>:
  D.54770 = this->rep_;
  D.54772 = D.54770->call_;
  if (D.54772 == 0B) goto <D.54767>; else goto <D.54768>;
  <D.54767>:
  iftmp.12 = 1;
  goto <D.54769>;
  <D.54768>:
  iftmp.12 = 0;
  <D.54769>:
  D.54765 = iftmp.12;
  return D.54765;
}


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.54774;
  const struct _List_node_base * D.54775;
  const struct slot_base * D.54776;

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


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

  D.54778 = __r;
  return D.54778;
}


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

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


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

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


T_return sigc::internal::signal_emit0<T_return, T_accumulator>::operator()(const slot_type&) const [with T_return = int; T_accumulator = {anonymous}::min_accum<int>; sigc::internal::signal_emit0<T_return, T_accumulator>::slot_type = sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct signal_emit0 * const this, const struct slot_type & _A_slot)
{
  int D.54785;
  struct rep_type * D.54786;
  void * (*<T1711>) (void *) D.54787;

  D.54786 = _A_slot->D.52828.D.52786.rep_;
  D.54787 = D.54786->call_;
  D.54786 = _A_slot->D.52828.D.52786.rep_;
  D.54785 = D.54787 (D.54786);
  return D.54785;
}


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

  {
    try
      {
        D.54790 = this->slots_;
        D.35408 = std::list<sigc::slot_base>::erase (D.54790, 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.54792;
  struct _List_node_base * D.54793;
  struct _List_iterator D.54794;
  struct iterator D.54795;
  struct iterator __ret;

  try
    {
      D.54792 = __position._M_node;
      D.54793 = D.54792->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.54793);
      D.54794 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.54794);
      D.54795 = __ret;
      return D.54795;
    }
  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.54799;
  struct slot_base * D.54800;
  struct slot_base * D.54801;
  struct _Tp_alloc_type D.53246;
  struct _List_base * D.54802;
  struct _Node * __n;

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

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.13;
  short int D.54807;
  unsigned short D.54808;
  unsigned short D.54809;
  short int D.54810;
  bool retval.14;
  bool iftmp.15;
  short int D.54821;
  unsigned short D.54822;
  unsigned short D.54823;
  short int D.54824;
  bool D.54826;

  D.54807 = this->ref_count_;
  D.54808 = (unsigned short) D.54807;
  D.54809 = D.54808 + 65535;
  D.54810 = (short int) D.54809;
  this->ref_count_ = D.54810;
  D.54807 = this->ref_count_;
  retval.13 = D.54807 == 0;
  if (retval.13 != 0) goto <D.54811>; else goto <D.54812>;
  <D.54811>:
  if (this != 0B) goto <D.54813>; else goto <D.54814>;
  <D.54813>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.54815>;
  <D.54814>:
  <D.54815>:
  goto <D.54816>;
  <D.54812>:
  D.54821 = this->exec_count_;
  D.54822 = (unsigned short) D.54821;
  D.54823 = D.54822 + 65535;
  D.54824 = (short int) D.54823;
  this->exec_count_ = D.54824;
  D.54821 = this->exec_count_;
  if (D.54821 == 0) goto <D.54825>; else goto <D.54819>;
  <D.54825>:
  D.54826 = this->deferred_;
  if (D.54826 != 0) goto <D.54827>; else goto <D.54819>;
  <D.54827>:
  iftmp.15 = 1;
  goto <D.54820>;
  <D.54819>:
  iftmp.15 = 0;
  <D.54820>:
  retval.14 = iftmp.15;
  if (retval.14 != 0) goto <D.54828>; else goto <D.54829>;
  <D.54828>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.54830>;
  <D.54829>:
  <D.54830>:
  <D.54816>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54833 = &this->D.35179;
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::~_List_base (D.54833);
          }
      }
    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.54835;

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


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.54838;
  struct slot_base * D.54839;
  struct _Tp_alloc_type D.53229;
  struct _List_node_base * D.54840;
  typedef struct _Node _Node;
  struct _Node * __cur;

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

    __tmp = __cur;
    __cur = __cur->D.53041._M_next;
    D.54838 = &__tmp->_M_data;
    D.54839 = std::__addressof<sigc::slot_base> (D.54838);
    D.53229 = 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.53229, D.54839);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.53229);
        D.53229 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.53233>:
  D.54840 = &this->_M_impl._M_node;
  if (D.54840 != __cur) goto <D.53234>; else goto <D.53232>;
  <D.53232>:
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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

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


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

  try
    {
      {

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


sigc::slot<int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot() (struct slot * const this)
{
  struct slot0 * D.54846;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54846 = &this->D.52828;
            sigc::slot0<int>::~slot0 (D.54846);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.52869>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54848 = &this->D.52786;
            sigc::slot_base::~slot_base (D.54848);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.52864>:
}


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.53187;
  struct _Rep * D.54850;
  struct _Alloc_hider * D.54851;

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


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

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

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


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

  try
    {
      {

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


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.54861;
  char * D.54862;

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


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

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


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.16;
  struct _Rep & D.54868;
  bool D.54869;
  long int D.54870;
  long int D.54871;
  bool retval.17;
  _Atomic_word * D.54875;
  int D.54876;

  D.54868 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.54869 = D.54868 != this;
  D.54870 = (long int) D.54869;
  D.54871 = __builtin_expect (D.54870, 0);
  retval.16 = D.54871 != 0;
  if (retval.16 != 0) goto <D.54872>; else goto <D.54873>;
  <D.54872>:
  D.54875 = &this->D.11865._M_refcount;
  D.54876 = __gnu_cxx::__exchange_and_add_dispatch (D.54875, -1);
  retval.17 = D.54876 <= 0;
  if (retval.17 != 0) goto <D.54877>; else goto <D.54878>;
  <D.54877>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.54879>;
  <D.54878>:
  <D.54879>:
  goto <D.54880>;
  <D.54873>:
  <D.54880>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.18;
  int D.54885;
  _Atomic_word D.54888;

  D.54885 = __gthread_active_p ();
  retval.18 = D.54885 != 0;
  if (retval.18 != 0) goto <D.54886>; else goto <D.54887>;
  <D.54886>:
  D.54888 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.54888;
  <D.54887>:
  D.54888 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.54888;
}


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

  D.54891 = __gthrw___pthread_key_create != 0B;
  D.54890 = (int) D.54891;
  return D.54890;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.54893;
  unsigned int __val.19;
  unsigned int D.54895;

  __val.19 = (unsigned int) __val;
  D.54895 = __atomic_fetch_add_4 (__mem, __val.19, 4);
  D.54893 = (_Atomic_word) D.54895;
  return D.54893;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.54897;
  int D.54898;
  _Atomic_word D.54899;
  _Atomic_word __result;

  __result = *__mem;
  D.54897 = *__mem;
  D.54898 = D.54897 + __val;
  *__mem = D.54898;
  D.54899 = __result;
  return D.54899;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::signal0<int, {anonymous}::min_accum<int> >::~signal0() (struct signal0 * const this)
{
  struct signal_base * D.54903;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.54903 = &this->D.51840;
            sigc::signal_base::~signal_base (D.54903);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.51855>:
}


(static initializers for test_accum_iter.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.54905>; else goto <D.54906>;
  <D.54905>:
  if (__priority == 65535) goto <D.54907>; else goto <D.54908>;
  <D.54907>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.54909>;
  <D.54908>:
  <D.54909>:
  goto <D.54910>;
  <D.54906>:
  <D.54910>:
}


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.20;
  const void * * D.54914;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.54919;
  int (*__vtbl_ptr_type) () * D.54920;
  long int D.54921;
  struct basic_ios * D.54923;
  int (*__vtbl_ptr_type) () * iftmp.22;
  struct __stringbuf_type * D.54928;
  const void * * iftmp.23;
  struct basic_ostream * D.54933;
  int D.54934;
  struct basic_ios * D.54937;
  int D.54939;

  {
    if (2 == 0) goto <D.54912>; else goto <D.54913>;
    <D.54912>:
    D.54914 = 0B;
    iftmp.20 = *D.54914;
    goto <D.54915>;
    <D.54913>:
    iftmp.20 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.54915>:
    this->D.22312._vptr.basic_ostream = iftmp.20;
    if (2 == 0) goto <D.54917>; else goto <D.54918>;
    <D.54917>:
    D.54919 = this->D.22312._vptr.basic_ostream;
    D.54920 = D.54919 + 18446744073709551592;
    D.54921 = MEM[(long int *)D.54920];
    iftmp.21 = (sizetype) D.54921;
    goto <D.54922>;
    <D.54918>:
    iftmp.21 = 88;
    <D.54922>:
    D.54923 = this + iftmp.21;
    if (2 == 0) goto <D.54925>; else goto <D.54926>;
    <D.54925>:
    iftmp.22 = MEM[(const void * *)0B + 24B];
    goto <D.54927>;
    <D.54926>:
    iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.54927>:
    D.54923->D.19008._vptr.ios_base = iftmp.22;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.54928 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.54928);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.54930>; else goto <D.54931>;
                <D.54930>:
                iftmp.23 = 8B;
                goto <D.54932>;
                <D.54931>:
                iftmp.23 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.54932>:
                D.54933 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.54933, iftmp.23);
              }
          }
        finally
          {
            D.54934 = 2;
            if (D.54934 != 0) goto <D.54935>; else goto <D.54936>;
            <D.54935>:
            D.54937 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.54937);
            goto <D.54938>;
            <D.54936>:
            <D.54938>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.54416>:
  D.54939 = 0;
  if (D.54939 != 0) goto <D.54940>; else goto <D.54941>;
  <D.54940>:
  operator delete (this);
  goto <D.54942>;
  <D.54941>:
  <D.54942>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.54952;
  struct basic_streambuf * D.54953;
  int D.54954;

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

              }
            finally
              {
                D.54952 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.54952);
              }
          }
        finally
          {
            D.54953 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.54953);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53093>:
  D.54954 = 0;
  if (D.54954 != 0) goto <D.54955>; else goto <D.54956>;
  <D.54955>:
  operator delete (this);
  goto <D.54957>;
  <D.54956>:
  <D.54957>:
}


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

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

          }
        finally
          {
            D.54960 = &this->_M_buf_locale;
            std::locale::~locale (D.54960);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53289>:
  D.54961 = 0;
  if (D.54961 != 0) goto <D.54962>; else goto <D.54963>;
  <D.54962>:
  operator delete (this);
  goto <D.54964>;
  <D.54963>:
  <D.54964>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.53097>:
  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.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.54972;
  int (*__vtbl_ptr_type) () * D.54973;
  long int D.54974;
  struct basic_ios * D.54976;
  int (*__vtbl_ptr_type) () * iftmp.26;
  int D.54981;
  struct basic_ios * D.54984;
  int D.54986;

  {
    if (0 == 0) goto <D.54966>; else goto <D.54967>;
    <D.54966>:
    iftmp.24 = *__vtt_parm;
    goto <D.54968>;
    <D.54967>:
    iftmp.24 = &MEM[(void *)&_ZTVSo + 24B];
    <D.54968>:
    this->_vptr.basic_ostream = iftmp.24;
    if (0 == 0) goto <D.54970>; else goto <D.54971>;
    <D.54970>:
    D.54972 = this->_vptr.basic_ostream;
    D.54973 = D.54972 + 18446744073709551592;
    D.54974 = MEM[(long int *)D.54973];
    iftmp.25 = (sizetype) D.54974;
    goto <D.54975>;
    <D.54971>:
    iftmp.25 = 8;
    <D.54975>:
    D.54976 = this + iftmp.25;
    if (0 == 0) goto <D.54978>; else goto <D.54979>;
    <D.54978>:
    iftmp.26 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.54980>;
    <D.54979>:
    iftmp.26 = &MEM[(void *)&_ZTVSo + 64B];
    <D.54980>:
    D.54976->D.19008._vptr.ios_base = iftmp.26;
    try
      {
        try
          {

          }
        finally
          {
            D.54981 = 0;
            if (D.54981 != 0) goto <D.54982>; else goto <D.54983>;
            <D.54982>:
            D.54984 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.54984);
            goto <D.54985>;
            <D.54983>:
            <D.54985>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53274>:
  D.54986 = 0;
  if (D.54986 != 0) goto <D.54987>; else goto <D.54988>;
  <D.54987>:
  operator delete (this);
  goto <D.54989>;
  <D.54988>:
  <D.54989>:
}


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

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

          }
        finally
          {
            D.54991 = &this->D.19008;
            std::ios_base::~ios_base (D.54991);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.53262>:
  D.54992 = 0;
  if (D.54992 != 0) goto <D.54993>; else goto <D.54994>;
  <D.54993>:
  operator delete (this);
  goto <D.54995>;
  <D.54994>:
  <D.54995>:
}


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.53266>:
  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.54999;
  const void * * iftmp.27;
  struct basic_ostream * D.55005;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * D.55009;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.55014;
  int (*__vtbl_ptr_type) () * D.55015;
  long int D.55016;
  struct basic_ios * D.55018;
  int (*__vtbl_ptr_type) () * iftmp.30;
  _Ios_Openmode D.55023;
  struct __stringbuf_type * D.55024;
  struct basic_streambuf * D.55025;
  sizetype iftmp.31;
  struct basic_ios * D.55030;
  const void * * iftmp.32;

  if (1 != 0) goto <D.54997>; else goto <D.54998>;
  <D.54997>:
  D.54999 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.54999);
  goto <D.55000>;
  <D.54998>:
  <D.55000>:
  try
    {
      if (1 == 0) goto <D.55002>; else goto <D.55003>;
      <D.55002>:
      iftmp.27 = 8B;
      goto <D.55004>;
      <D.55003>:
      iftmp.27 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.55004>:
      D.55005 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.55005, iftmp.27);
      try
        {
          if (1 == 0) goto <D.55007>; else goto <D.55008>;
          <D.55007>:
          D.55009 = 0B;
          iftmp.28 = *D.55009;
          goto <D.55010>;
          <D.55008>:
          iftmp.28 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.55010>:
          this->D.22312._vptr.basic_ostream = iftmp.28;
          if (1 == 0) goto <D.55012>; else goto <D.55013>;
          <D.55012>:
          D.55014 = this->D.22312._vptr.basic_ostream;
          D.55015 = D.55014 + 18446744073709551592;
          D.55016 = MEM[(long int *)D.55015];
          iftmp.29 = (sizetype) D.55016;
          goto <D.55017>;
          <D.55013>:
          iftmp.29 = 88;
          <D.55017>:
          D.55018 = this + iftmp.29;
          if (1 == 0) goto <D.55020>; else goto <D.55021>;
          <D.55020>:
          iftmp.30 = MEM[(const void * *)0B + 24B];
          goto <D.55022>;
          <D.55021>:
          iftmp.30 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.55022>:
          D.55018->D.19008._vptr.ios_base = iftmp.30;
          D.55023 = std::operator| (__mode, 16);
          D.55024 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.55024, D.55023);
          try
            {
              D.55025 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.55027>; else goto <D.55028>;
              <D.55027>:
              D.55014 = this->D.22312._vptr.basic_ostream;
              D.55015 = D.55014 + 18446744073709551592;
              D.55016 = MEM[(long int *)D.55015];
              iftmp.31 = (sizetype) D.55016;
              goto <D.55029>;
              <D.55028>:
              iftmp.31 = 88;
              <D.55029>:
              D.55030 = this + iftmp.31;
              std::basic_ios<char>::init (D.55030, D.55025);
            }
          catch
            {
              D.55024 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.55024);
            }
        }
      catch
        {
          if (1 == 0) goto <D.55032>; else goto <D.55033>;
          <D.55032>:
          iftmp.32 = 8B;
          goto <D.55034>;
          <D.55033>:
          iftmp.32 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.55034>:
          D.55005 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.55005, iftmp.32);
        }
    }
  catch
    {
      if (1 != 0) goto <D.55035>; else goto <D.55036>;
      <D.55035>:
      D.54999 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.54999);
      goto <D.55037>;
      <D.55036>:
      <D.55037>:
    }
}


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

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


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.55044;
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.55053;
  int (*__vtbl_ptr_type) () * D.55054;
  long int D.55055;
  struct basic_ios * D.55057;
  int (*__vtbl_ptr_type) () * iftmp.35;
  sizetype iftmp.36;
  struct basic_ios * D.55066;

  if (0 != 0) goto <D.55042>; else goto <D.55043>;
  <D.55042>:
  D.55044 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.55044);
  goto <D.55045>;
  <D.55043>:
  <D.55045>:
  try
    {
      if (0 == 0) goto <D.55047>; else goto <D.55048>;
      <D.55047>:
      iftmp.33 = *__vtt_parm;
      goto <D.55049>;
      <D.55048>:
      iftmp.33 = &MEM[(void *)&_ZTVSo + 24B];
      <D.55049>:
      this->_vptr.basic_ostream = iftmp.33;
      if (0 == 0) goto <D.55051>; else goto <D.55052>;
      <D.55051>:
      D.55053 = this->_vptr.basic_ostream;
      D.55054 = D.55053 + 18446744073709551592;
      D.55055 = MEM[(long int *)D.55054];
      iftmp.34 = (sizetype) D.55055;
      goto <D.55056>;
      <D.55052>:
      iftmp.34 = 8;
      <D.55056>:
      D.55057 = this + iftmp.34;
      if (0 == 0) goto <D.55059>; else goto <D.55060>;
      <D.55059>:
      iftmp.35 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.55061>;
      <D.55060>:
      iftmp.35 = &MEM[(void *)&_ZTVSo + 64B];
      <D.55061>:
      D.55057->D.19008._vptr.ios_base = iftmp.35;
      if (0 == 0) goto <D.55063>; else goto <D.55064>;
      <D.55063>:
      D.55053 = this->_vptr.basic_ostream;
      D.55054 = D.55053 + 18446744073709551592;
      D.55055 = MEM[(long int *)D.55054];
      iftmp.36 = (sizetype) D.55055;
      goto <D.55065>;
      <D.55064>:
      iftmp.36 = 8;
      <D.55065>:
      D.55066 = this + iftmp.36;
      std::basic_ios<char>::init (D.55066, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.55067>; else goto <D.55068>;
      <D.55067>:
      D.55044 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.55044);
      goto <D.55069>;
      <D.55068>:
      <D.55069>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.55071;
  int __a.37;
  int __b.38;
  int D.55074;

  __a.37 = (int) __a;
  __b.38 = (int) __b;
  D.55074 = __a.37 | __b.38;
  D.55071 = (_Ios_Openmode) D.55074;
  return D.55071;
}


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.55076;
  struct __string_type * D.55077;

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

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


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

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

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


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.53569;
  struct _Rep & D.55080;
  char * D.55081;
  struct _Alloc_hider * D.55082;

  std::allocator<char>::allocator (&D.53569);
  try
    {
      D.55080 = std::basic_string<char>::_S_empty_rep ();
      D.55081 = std::basic_string<char>::_Rep::_M_refdata (D.55080);
      D.55082 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.55082, D.55081, &D.53569);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.53569);
      D.53569 = {CLOBBER};
    }
  try
    {

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


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

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


_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.55088;
  void * D.55089;

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


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


