int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.52326;
  int D.52329;
  int iftmp.1;
  bool D.52331;
  struct pointer_functor1 D.48887;
  const struct string D.49066;
  struct allocator D.49065;
  const struct string D.49070;
  struct allocator D.49069;
  const struct slot D.50092;
  struct bind_functor D.50013;
  struct reference_wrapper D.52335;
  const struct string D.50096;
  struct allocator D.50095;
  const struct string D.50099;
  struct allocator D.50098;
  int iftmp.2;
  bool D.52337;

  {
    struct TestUtilities * util;
    struct slot slot_full;
    struct slot slot_bound;

    try
      {
        util = TestUtilities::get_instance ();
        D.52326 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.52326;
        if (retval.0 != 0) goto <D.52327>; else goto <D.52328>;
        <D.52327>:
        D.52331 = TestUtilities::get_result_and_delete_instance ();
        if (D.52331 != 0) goto <D.52332>; else goto <D.52333>;
        <D.52332>:
        iftmp.1 = 0;
        goto <D.52334>;
        <D.52333>:
        iftmp.1 = 1;
        <D.52334>:
        D.52329 = iftmp.1;
        return D.52329;
        <D.52328>:
        D.48887 = sigc::ptr_fun<{anonymous}::Param&, void> (handler);
        try
          {
            sigc::slot<void, {anonymous}::Param&>::slot<sigc::pointer_functor1<{anonymous}::Param&, void> > (&slot_full, &D.48887);
          }
        finally
          {
            try
              {

              }
            catch
              {
                sigc::slot<void, {anonymous}::Param&>::~slot (&slot_full);
              }
            D.48887 = {CLOBBER};
          }
        try
          {
            sigc::slot<void>::slot (&slot_bound);
            try
              {
                sigc::slot0<void>::operator() (&slot_bound.D.49030);
                std::allocator<char>::allocator (&D.49065);
                try
                  {
                    std::basic_string<char>::basic_string (&D.49066, "", &D.49065);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.49066);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.49066);
                        D.49066 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.49065);
                    D.49065 = {CLOBBER};
                  }
                {
                  struct Param param;

                  try
                    {
                      std::allocator<char>::allocator (&D.49069);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.49070, "murrayc", &D.49069);
                          try
                            {
                              {anonymous}::Param::Param (&param, &D.49070);
                            }
                          finally
                            {
                              try
                                {
                                  std::basic_string<char>::~basic_string (&D.49070);
                                }
                              catch
                                {
                                  {anonymous}::Param::~Param (&param);
                                }
                              D.49070 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          try
                            {
                              std::allocator<char>::~allocator (&D.49069);
                            }
                          catch
                            {
                              {anonymous}::Param::~Param (&param);
                            }
                          D.49069 = {CLOBBER};
                        }
                      try
                        {
                          D.52335 = sigc::ref<{anonymous}::Param> (&param);
                          D.50013 = sigc::bind<-1, sigc::reference_wrapper<{anonymous}::Param>, sigc::slot<void, {anonymous}::Param&> > (&slot_full, D.52335); [return slot optimization]
                          try
                            {
                              sigc::slot<void>::slot<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.50092, &D.50013);
                              try
                                {
                                  sigc::slot<void>::operator= (&slot_bound, &D.50092);
                                }
                              finally
                                {
                                  sigc::slot<void>::~slot (&D.50092);
                                  D.50092 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (&D.50013);
                              D.50013 = {CLOBBER};
                            }
                          std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Calling slot when param exists:");
                          sigc::slot0<void>::operator() (&slot_bound.D.49030);
                          std::allocator<char>::allocator (&D.50095);
                          try
                            {
                              std::basic_string<char>::basic_string (&D.50096, "Calling slot when param exists:  handler(param): param.name_=murrayc", &D.50095);
                              try
                                {
                                  TestUtilities::check_result (util, &result_stream, &D.50096);
                                }
                              finally
                                {
                                  std::basic_string<char>::~basic_string (&D.50096);
                                  D.50096 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              std::allocator<char>::~allocator (&D.50095);
                              D.50095 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          {anonymous}::Param::~Param (&param);
                        }
                    }
                  finally
                    {
                      param = {CLOBBER};
                    }
                }
                std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Calling slot when param does not exist:");
                sigc::slot0<void>::operator() (&slot_bound.D.49030);
                std::allocator<char>::allocator (&D.50098);
                try
                  {
                    std::basic_string<char>::basic_string (&D.50099, "Calling slot when param does not exist:", &D.50098);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.50099);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.50099);
                        D.50099 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.50098);
                    D.50098 = {CLOBBER};
                  }
                D.52337 = TestUtilities::get_result_and_delete_instance ();
                if (D.52337 != 0) goto <D.52338>; else goto <D.52339>;
                <D.52338>:
                iftmp.2 = 0;
                goto <D.52340>;
                <D.52339>:
                iftmp.2 = 1;
                <D.52340>:
                D.52329 = iftmp.2;
                return D.52329;
              }
            finally
              {
                sigc::slot<void>::~slot (&slot_bound);
              }
          }
        finally
          {
            sigc::slot<void, {anonymous}::Param&>::~slot (&slot_full);
          }
      }
    finally
      {
        slot_full = {CLOBBER};
        slot_bound = {CLOBBER};
      }
  }
  D.52329 = 0;
  return D.52329;
}


void {anonymous}::handler({anonymous}::Param&) (struct Param & param)
{
  struct string * D.52367;
  struct basic_ostream & D.52368;

  D.52367 = &param->name_;
  D.52368 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "  handler(param): param.name_=");
  std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.52368, D.52367);
}


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

  D.52371 = std::basic_string<char>::size (__str);
  D.52372 = (long int) D.52371;
  D.52373 = std::basic_string<char>::data (__str);
  D.52370 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.52373, D.52372);
  return D.52370;
}


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

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


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.52382;
  char * D.52383;

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


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

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


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

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = {anonymous}::Param&; T_return = void] (void (*<T8b70>) (struct Param &) _A_func)
{
  struct pointer_functor1 D.52391;
  struct pointer_functor1 D.50307;

  sigc::pointer_functor1<{anonymous}::Param&, void>::pointer_functor1 (&D.50307, _A_func);
  try
    {
      D.52391 = D.50307;
      return D.52391;
    }
  finally
    {
      D.50307 = {CLOBBER};
    }
}


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


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

}


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

  D.52394 = &this->D.48859;
  sigc::slot1<void, {anonymous}::Param&>::slot1<sigc::pointer_functor1<{anonymous}::Param&, void> > (D.52394, _A_func);
  try
    {

    }
  catch
    {
      D.52394 = &this->D.48859;
      sigc::slot1<void, {anonymous}::Param&>::~slot1 (D.52394);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>; T_return = void; T_arg1 = {anonymous}::Param&] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.51058;
  struct slot_base * D.52395;
  struct rep_type * D.52396;
  void * (*<T1711>) (void *) D.52397;

  D.51058 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<{anonymous}::Param&, void> >::typed_slot_rep (D.51058, _A_func);
    }
  catch
    {
      operator delete (D.51058);
    }
  D.52395 = &this->D.48817;
  sigc::slot_base::slot_base (D.52395, D.51058);
  try
    {
      D.52396 = this->D.48817.rep_;
      D.52397 = sigc::internal::slot_call1<sigc::pointer_functor1<{anonymous}::Param&, void>, void, {anonymous}::Param&>::address ();
      D.52396->call_ = D.52397;
    }
  catch
    {
      D.52395 = &this->D.48817;
      sigc::slot_base::~slot_base (D.52395);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>] (struct typed_slot_rep * const this, const struct pointer_functor1 & functor)
{
  struct slot_rep * D.52400;
  struct adaptor_type * D.52401;
  struct slot_do_bind D.51342;

  D.52400 = &this->D.51046;
  sigc::internal::slot_rep::slot_rep (D.52400, 0B, destroy, dup);
  try
    {
      D.52401 = &this->functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<{anonymous}::Param&, void> >::adaptor_functor (D.52401, functor);
      D.52401 = &this->functor_;
      D.52400 = &this->D.51046;
      sigc::internal::slot_do_bind::slot_do_bind (&D.51342, D.52400);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<{anonymous}::Param&, void> > > (&D.51342, D.52401);
        }
      finally
        {
          D.51342 = {CLOBBER};
        }
    }
  catch
    {
      D.52400 = &this->D.51046;
      sigc::internal::slot_rep::~slot_rep (D.52400);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>] (void * data)
{
  void * D.52404;
  void * D.51482;
  struct slot_rep * a_rep;

  a_rep = data;
  D.51482 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<{anonymous}::Param&, void> >::typed_slot_rep (D.51482, a_rep);
    }
  catch
    {
      operator delete (D.51482);
    }
  D.52404 = D.51482;
  return D.52404;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.52408;
  struct slot_rep * D.52409;
  struct adaptor_type * D.52410;
  struct slot_do_bind D.51739;

  D.52408 = cl->D.51046.call_;
  D.52409 = &this->D.51046;
  sigc::internal::slot_rep::slot_rep (D.52409, D.52408, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.52410 = &this->functor_;
      D.52409 = &this->D.51046;
      sigc::internal::slot_do_bind::slot_do_bind (&D.51739, D.52409);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<{anonymous}::Param&, void> > > (&D.51739, D.52410);
        }
      finally
        {
          D.51739 = {CLOBBER};
        }
    }
  catch
    {
      D.52409 = &this->D.51046;
      sigc::internal::slot_rep::~slot_rep (D.52409);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>] (void * data)
{
  struct adaptor_type * D.52413;
  struct slot_do_unbind D.51467;
  void * D.52414;
  struct self * self_;

  self_ = data;
  self_->D.51046.call_ = 0B;
  self_->D.51046.destroy_ = 0B;
  D.52413 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.51467, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor1<{anonymous}::Param&, void> > > (&D.51467, D.52413);
    }
  finally
    {
      D.51467 = {CLOBBER};
    }
  D.52414 = 0B;
  return D.52414;
}


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


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

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


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


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


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

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


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<{anonymous}::Param&, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.52094, const struct limit_derived_target & D.52095)
{
  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.52419;

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


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


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


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


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

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


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


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


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

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


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<{anonymous}::Param&, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.52046, const struct limit_derived_target & D.52047)
{
  GIMPLE_NOP
}


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

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


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

  D.52425 = this->destroy_;
  if (D.52425 != 0B) goto <D.52426>; else goto <D.52427>;
  <D.52426>:
  D.52425 = this->destroy_;
  D.52425 (this);
  goto <D.52428>;
  <D.52427>:
  <D.52428>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<{anonymous}::Param&, void>; T_return = void; T_arg1 = {anonymous}::Param&; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.52429;

  D.52429 = call_it;
  return D.52429;
}


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

  typed_rep = rep;
  D.52431 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<{anonymous}::Param&, void> >::operator()<{anonymous}::Param&> (D.52431, a_1);
  return;
}


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

  D.52433 = &this->functor_;
  sigc::pointer_functor1<{anonymous}::Param&, void>::operator() (D.52433, _A_arg1);
  return;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = {anonymous}::Param&; T_return = void; typename sigc::type_trait<T_base>::take = {anonymous}::Param&] (const struct pointer_functor1 * const this, struct Param & _A_a1)
{
  void (*<T8b70>) (struct Param &) D.52435;

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


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

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

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


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

  D.52438 = &this->D.48988;
  sigc::slot_base::slot_base (D.52438);
  try
    {

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


{anonymous}::Param::Param(const string&) (struct Param * const this, const struct string & name)
{
  struct trackable * D.52439;
  struct string * D.52440;

  D.52439 = &this->D.48744;
  sigc::trackable::trackable (D.52439);
  try
    {
      D.52440 = &this->name_;
      std::basic_string<char>::basic_string (D.52440, name);
      try
        {

        }
      catch
        {
          D.52440 = &this->name_;
          std::basic_string<char>::~basic_string (D.52440);
        }
    }
  catch
    {
      D.52439 = &this->D.48744;
      sigc::trackable::~trackable (D.52439);
    }
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::Param] (struct Param & v)
{
  struct reference_wrapper D.52442;
  struct reference_wrapper D.50347;

  sigc::reference_wrapper<{anonymous}::Param>::reference_wrapper (&D.50347, v);
  try
    {
      D.52442 = D.50347;
      return D.52442;
    }
  finally
    {
      D.50347 = {CLOBBER};
    }
}


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


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = -1; T_bound1 = sigc::reference_wrapper<{anonymous}::Param>; T_functor = sigc::slot<void, {anonymous}::Param&>] (const struct slot & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::slot<void, {anonymous}::Param&>; T_type1 = sigc::reference_wrapper<{anonymous}::Param>; typename sigc::type_trait<T_base>::take = const sigc::slot<void, {anonymous}::Param&>&; typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<{anonymous}::Param>&] (struct bind_functor * const this, const struct slot & _A_func, const struct reference_wrapper & _A_bound1)
{
  struct adapts * D.52447;
  struct bound_argument * D.52448;

  D.52447 = &this->D.50010;
  sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::adapts (D.52447, _A_func);
  try
    {
      D.52448 = &this->bound1_;
      sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Param> >::bound_argument (D.52448, _A_bound1);
    }
  catch
    {
      D.52447 = &this->D.50010;
      sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::~adapts (D.52447);
    }
}


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

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

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


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

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

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


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

  D.52452 = &this->D.48859;
  sigc::slot1<void, {anonymous}::Param&>::slot1 (D.52452, src);
  try
    {

    }
  catch
    {
      D.52452 = &this->D.48859;
      sigc::slot1<void, {anonymous}::Param&>::~slot1 (D.52452);
    }
}


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

  D.52453 = &src->D.48817;
  D.52454 = &this->D.48817;
  sigc::slot_base::slot_base (D.52454, D.52453);
  try
    {

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


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

  D.52455 = sigc::unwrap<{anonymous}::Param> (_A_argument);
  D.52456 = &this->visited_;
  sigc::limit_reference<{anonymous}::Param, true>::limit_reference (D.52456, D.52455);
}


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

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


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

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


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

  D.52462 = &_A_target->D.48744;
  this->visited = D.52462;
  this->invoked = _A_target;
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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

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

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot0 * const this, const struct bind_functor & _A_func)
{
  void * D.51153;
  struct slot_base * D.52468;
  struct rep_type * D.52469;
  void * (*<T1711>) (void *) D.52470;

  D.51153 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.51153, _A_func);
    }
  catch
    {
      operator delete (D.51153);
    }
  D.52468 = &this->D.48988;
  sigc::slot_base::slot_base (D.52468, D.51153);
  try
    {
      D.52469 = this->D.48988.rep_;
      D.52470 = sigc::internal::slot_call0<sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void>::address ();
      D.52469->call_ = D.52470;
    }
  catch
    {
      D.52468 = &this->D.48988;
      sigc::slot_base::~slot_base (D.52468);
    }
}


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

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


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

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


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, 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.52482;
  struct slot_rep * D.52483;
  const struct adaptor_type * D.52484;
  struct adaptor_type * D.52485;
  struct slot_do_bind D.51771;

  D.52482 = cl->D.51142.call_;
  D.52483 = &this->D.51142;
  sigc::internal::slot_rep::slot_rep (D.52483, D.52482, destroy, dup);
  try
    {
      D.52484 = &cl->functor_;
      D.52485 = &this->functor_;
      sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (D.52485, D.52484);
      try
        {
          D.52485 = &this->functor_;
          D.52483 = &this->D.51142;
          sigc::internal::slot_do_bind::slot_do_bind (&D.51771, D.52483);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51771, D.52485);
            }
          finally
            {
              D.51771 = {CLOBBER};
            }
        }
      catch
        {
          D.52485 = &this->functor_;
          sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.52485);
        }
    }
  catch
    {
      D.52483 = &this->D.51142;
      sigc::internal::slot_rep::~slot_rep (D.52483);
    }
}


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

  self_ = data;
  self_->D.51142.call_ = 0B;
  self_->D.51142.destroy_ = 0B;
  D.52489 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.51657, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51657, D.52489);
    }
  finally
    {
      D.51657 = {CLOBBER};
    }
  D.52489 = &self_->functor_;
  sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~bind_functor (D.52489);
  D.52490 = 0B;
  return D.52490;
}


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

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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::slot<void, {anonymous}::Param&>; T_type1 = sigc::reference_wrapper<{anonymous}::Param>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52494;
  const struct bound_argument * D.52495;

  D.52494 = &_A_target->D.50010.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> > > (_A_action, D.52494);
  D.52495 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Param> > > (_A_action, D.52495);
}


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


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

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


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::slot<void, {anonymous}::Param&>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct slot & D.52164, const struct limit_derived_target & D.52165)
{
  GIMPLE_NOP
}


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


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

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


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

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


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


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = {anonymous}::Param; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.52500;

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


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

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


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


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


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


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_unbind * D.52503;

  D.52503 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.52503, _A_type);
}


void sigc::internal::slot_do_unbind::operator()(const sigc::trackable*) const (const struct slot_do_unbind * const this, const struct trackable * t)
{
  struct slot_rep * D.52504;

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


sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(const sigc::bind_functor<-1, sigc::slot<void, {anonymous}::Param&>, sigc::reference_wrapper<{anonymous}::Param>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) (struct bind_functor * const this, const struct bind_functor & D.50408)
{
  const struct adapts * D.52505;
  struct adapts * D.52506;

  D.52505 = &D.50408->D.50010;
  D.52506 = &this->D.50010;
  sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::adapts (D.52506, D.52505);
  try
    {
      this->bound1_ = D.50408->bound1_;
    }
  catch
    {
      D.52506 = &this->D.50010;
      sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::~adapts (D.52506);
    }
}


sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::adapts(const sigc::adapts<sigc::slot<void, {anonymous}::Param&> >&) (struct adapts * const this, const struct adapts & D.50390)
{
  struct adaptor_type * D.52507;
  struct adaptor_type * D.52508;

  D.52507 = &D.50390->functor_;
  D.52508 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> >::adaptor_functor (D.52508, D.52507);
  try
    {

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


sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> >::adaptor_functor(const sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> >&) (struct adaptor_functor * const this, const struct adaptor_functor & D.50372)
{
  struct slot * D.52509;
  struct slot * D.52510;

  D.52509 = &D.50372->functor_;
  D.52510 = &this->functor_;
  sigc::slot<void, {anonymous}::Param&>::slot (D.52510, D.52509);
  try
    {

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


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

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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::slot<void, {anonymous}::Param&>; T_type1 = sigc::reference_wrapper<{anonymous}::Param>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52512;
  const struct bound_argument * D.52513;

  D.52512 = &_A_target->D.50010.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> > > (_A_action, D.52512);
  D.52513 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Param> > > (_A_action, D.52513);
}


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


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

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


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


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


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


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::slot<void, {anonymous}::Param&>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct slot & D.52140, const struct limit_derived_target & D.52141)
{
  GIMPLE_NOP
}


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


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

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


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


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = {anonymous}::Param; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.52516;

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


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


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


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


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_bind * D.52517;

  D.52517 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.52517, _A_type);
}


void sigc::internal::slot_do_bind::operator()(const sigc::trackable*) const (const struct slot_do_bind * const this, const struct trackable * t)
{
  struct slot_rep * D.52518;

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


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

  D.52519 = call_it;
  return D.52519;
}


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

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


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

  D.52523 = &this->bound1_;
  D.52524 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::Param> >::invoke (D.52523);
  D.52525 = &this->D.50010.functor_;
  sigc::adaptor_functor<sigc::slot<void, {anonymous}::Param&> >::operator()<{anonymous}::Param&> (D.52525, D.52524);
  return;
}


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

  D.52529 = &this->visited_;
  D.52528 = sigc::limit_reference<{anonymous}::Param, true>::invoke (D.52529);
  return D.52528;
}


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

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


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

  D.52533 = &this->functor_.D.48859;
  sigc::slot1<void, {anonymous}::Param&>::operator() (D.52533, _A_arg1);
  return;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = {anonymous}::Param&; sigc::slot1<T_return, T_arg1>::arg1_type_ = {anonymous}::Param&] (const struct slot1 * const this, struct Param & _A_a1)
{
  bool retval.3;
  bool iftmp.4;
  const struct slot_base * D.52539;
  bool D.52540;
  bool D.52541;
  bool D.52543;
  bool D.52544;
  struct rep_type * D.52548;
  void * (*<T1711>) (void *) D.52549;

  D.52539 = &this->D.48817;
  D.52540 = sigc::slot_base::empty (D.52539);
  D.52541 = ~D.52540;
  if (D.52541 != 0) goto <D.52542>; else goto <D.52537>;
  <D.52542>:
  D.52539 = &this->D.48817;
  D.52543 = sigc::slot_base::blocked (D.52539);
  D.52544 = ~D.52543;
  if (D.52544 != 0) goto <D.52545>; else goto <D.52537>;
  <D.52545>:
  iftmp.4 = 1;
  goto <D.52538>;
  <D.52537>:
  iftmp.4 = 0;
  <D.52538>:
  retval.3 = iftmp.4;
  if (retval.3 != 0) goto <D.52546>; else goto <D.52547>;
  <D.52546>:
  D.52548 = this->D.48817.rep_;
  D.52549 = D.52548->call_;
  D.52548 = this->D.48817.rep_;
  D.52549 (D.52548, _A_a1);
  return;
  <D.52547>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.52551;
  bool iftmp.5;
  struct rep_type * D.52556;
  void * (*<T1711>) (void *) D.52558;

  D.52556 = this->rep_;
  if (D.52556 == 0B) goto <D.52553>; else goto <D.52557>;
  <D.52557>:
  D.52556 = this->rep_;
  D.52558 = D.52556->call_;
  if (D.52558 == 0B) goto <D.52553>; else goto <D.52554>;
  <D.52553>:
  iftmp.5 = 1;
  goto <D.52555>;
  <D.52554>:
  iftmp.5 = 0;
  <D.52555>:
  D.52551 = iftmp.5;
  return D.52551;
}


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

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


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.50081)
{
  const struct slot0 * D.52562;
  struct slot0 * D.52563;
  struct slot & D.52564;

  D.52562 = &D.50081->D.49030;
  D.52563 = &this->D.49030;
  sigc::slot0<void>::operator= (D.52563, D.52562);
  D.52564 = this;
  return D.52564;
}


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

  D.52566 = &src->D.48988;
  D.52567 = &this->D.48988;
  sigc::slot_base::operator= (D.52567, D.52566);
  D.52568 = this;
  return D.52568;
}


std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with _Traits = std::char_traits<char>] (struct basic_ostream & __out, const char * __s)
{
  int (*__vtbl_ptr_type) () * D.52572;
  int (*__vtbl_ptr_type) () * D.52573;
  long int D.52574;
  sizetype D.52575;
  struct basic_ios * D.52576;
  long unsigned int D.52578;
  long int D.52579;
  struct basic_ostream & D.52580;

  if (__s == 0B) goto <D.52570>; else goto <D.52571>;
  <D.52570>:
  D.52572 = __out->_vptr.basic_ostream;
  D.52573 = D.52572 + 18446744073709551592;
  D.52574 = MEM[(long int *)D.52573];
  D.52575 = (sizetype) D.52574;
  D.52576 = __out + D.52575;
  std::basic_ios<char>::setstate (D.52576, 1);
  goto <D.52577>;
  <D.52571>:
  D.52578 = std::char_traits<char>::length (__s);
  D.52579 = (long int) D.52578;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.52579);
  <D.52577>:
  D.52580 = __out;
  return D.52580;
}


void std::basic_ios<_CharT, _Traits>::setstate(std::ios_base::iostate) [with _CharT = char; _Traits = std::char_traits<char>; std::ios_base::iostate = std::_Ios_Iostate] (struct basic_ios * const this, iostate __state)
{
  _Ios_Iostate D.52582;
  _Ios_Iostate D.52583;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.52587;
  int __a.6;
  int __b.7;
  int D.52590;

  __a.6 = (int) __a;
  __b.7 = (int) __b;
  D.52590 = __a.6 | __b.7;
  D.52587 = (_Ios_Iostate) D.52590;
  return D.52587;
}


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

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


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.8;
  bool iftmp.9;
  const struct slot_base * D.52598;
  bool D.52599;
  bool D.52600;
  bool D.52602;
  bool D.52603;
  struct rep_type * D.52607;
  void * (*<T1711>) (void *) D.52608;

  D.52598 = &this->D.48988;
  D.52599 = sigc::slot_base::empty (D.52598);
  D.52600 = ~D.52599;
  if (D.52600 != 0) goto <D.52601>; else goto <D.52596>;
  <D.52601>:
  D.52598 = &this->D.48988;
  D.52602 = sigc::slot_base::blocked (D.52598);
  D.52603 = ~D.52602;
  if (D.52603 != 0) goto <D.52604>; else goto <D.52596>;
  <D.52604>:
  iftmp.9 = 1;
  goto <D.52597>;
  <D.52596>:
  iftmp.9 = 0;
  <D.52597>:
  retval.8 = iftmp.9;
  if (retval.8 != 0) goto <D.52605>; else goto <D.52606>;
  <D.52605>:
  D.52607 = this->D.48988.rep_;
  D.52608 = D.52607->call_;
  D.52607 = this->D.48988.rep_;
  D.52608 (D.52607);
  return;
  <D.52606>:
  return;
}


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

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

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


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

  try
    {
      {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52612 = &this->D.50010;
            sigc::adapts<sigc::slot<void, {anonymous}::Param&> >::~adapts (D.52612);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50077>:
}


{anonymous}::Param::~Param() (struct Param * const this)
{
  struct string * D.52614;
  struct trackable * D.52615;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.52614 = &this->name_;
                std::basic_string<char>::~basic_string (D.52614);
              }
          }
        finally
          {
            D.52615 = &this->D.48744;
            sigc::trackable::~trackable (D.52615);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49084>:
}


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.50291;
  struct _Rep * D.52618;
  struct _Alloc_hider * D.52619;

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


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

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

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


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

  try
    {
      {

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


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.10;
  struct _Rep & D.52630;
  bool D.52631;
  long int D.52632;
  long int D.52633;
  bool retval.11;
  _Atomic_word * D.52637;
  int D.52638;

  D.52630 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.52631 = D.52630 != this;
  D.52632 = (long int) D.52631;
  D.52633 = __builtin_expect (D.52632, 0);
  retval.10 = D.52633 != 0;
  if (retval.10 != 0) goto <D.52634>; else goto <D.52635>;
  <D.52634>:
  D.52637 = &this->D.11865._M_refcount;
  D.52638 = __gnu_cxx::__exchange_and_add_dispatch (D.52637, -1);
  retval.11 = D.52638 <= 0;
  if (retval.11 != 0) goto <D.52639>; else goto <D.52640>;
  <D.52639>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.52641>;
  <D.52640>:
  <D.52641>:
  goto <D.52642>;
  <D.52635>:
  <D.52642>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.12;
  int D.52647;
  _Atomic_word D.52650;

  D.52647 = __gthread_active_p ();
  retval.12 = D.52647 != 0;
  if (retval.12 != 0) goto <D.52648>; else goto <D.52649>;
  <D.52648>:
  D.52650 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.52650;
  <D.52649>:
  D.52650 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.52650;
}


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

  D.52653 = __gthrw___pthread_key_create != 0B;
  D.52652 = (int) D.52653;
  return D.52652;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.52655;
  unsigned int __val.13;
  unsigned int D.52657;

  __val.13 = (unsigned int) __val;
  D.52657 = __atomic_fetch_add_4 (__mem, __val.13, 4);
  D.52655 = (_Atomic_word) D.52657;
  return D.52655;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.52659;
  int D.52660;
  _Atomic_word D.52661;
  _Atomic_word __result;

  __result = *__mem;
  D.52659 = *__mem;
  D.52660 = D.52659 + __val;
  *__mem = D.52660;
  D.52661 = __result;
  return D.52661;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52665 = &this->D.49030;
            sigc::slot0<void>::~slot0 (D.52665);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49061>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52667 = &this->D.48988;
            sigc::slot_base::~slot_base (D.52667);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49056>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52669 = &this->D.48859;
            sigc::slot1<void, {anonymous}::Param&>::~slot1 (D.52669);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48927>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52671 = &this->D.48817;
            sigc::slot_base::~slot_base (D.52671);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48922>:
}


(static initializers for test_bind_ref.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.52673>; else goto <D.52674>;
  <D.52673>:
  if (__priority == 65535) goto <D.52675>; else goto <D.52676>;
  <D.52675>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.52677>;
  <D.52676>:
  <D.52677>:
  goto <D.52678>;
  <D.52674>:
  <D.52678>:
}


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.14;
  const void * * D.52682;
  sizetype iftmp.15;
  int (*__vtbl_ptr_type) () * D.52687;
  int (*__vtbl_ptr_type) () * D.52688;
  long int D.52689;
  struct basic_ios * D.52691;
  int (*__vtbl_ptr_type) () * iftmp.16;
  struct __stringbuf_type * D.52696;
  const void * * iftmp.17;
  struct basic_ostream * D.52701;
  int D.52702;
  struct basic_ios * D.52705;
  int D.52707;

  {
    if (2 == 0) goto <D.52680>; else goto <D.52681>;
    <D.52680>:
    D.52682 = 0B;
    iftmp.14 = *D.52682;
    goto <D.52683>;
    <D.52681>:
    iftmp.14 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.52683>:
    this->D.22312._vptr.basic_ostream = iftmp.14;
    if (2 == 0) goto <D.52685>; else goto <D.52686>;
    <D.52685>:
    D.52687 = this->D.22312._vptr.basic_ostream;
    D.52688 = D.52687 + 18446744073709551592;
    D.52689 = MEM[(long int *)D.52688];
    iftmp.15 = (sizetype) D.52689;
    goto <D.52690>;
    <D.52686>:
    iftmp.15 = 88;
    <D.52690>:
    D.52691 = this + iftmp.15;
    if (2 == 0) goto <D.52693>; else goto <D.52694>;
    <D.52693>:
    iftmp.16 = MEM[(const void * *)0B + 24B];
    goto <D.52695>;
    <D.52694>:
    iftmp.16 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.52695>:
    D.52691->D.19008._vptr.ios_base = iftmp.16;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.52696 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.52696);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.52698>; else goto <D.52699>;
                <D.52698>:
                iftmp.17 = 8B;
                goto <D.52700>;
                <D.52699>:
                iftmp.17 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.52700>:
                D.52701 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.52701, iftmp.17);
              }
          }
        finally
          {
            D.52702 = 2;
            if (D.52702 != 0) goto <D.52703>; else goto <D.52704>;
            <D.52703>:
            D.52705 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.52705);
            goto <D.52706>;
            <D.52704>:
            <D.52706>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.52222>:
  D.52707 = 0;
  if (D.52707 != 0) goto <D.52708>; else goto <D.52709>;
  <D.52708>:
  operator delete (this);
  goto <D.52710>;
  <D.52709>:
  <D.52710>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.52720;
  struct basic_streambuf * D.52721;
  int D.52722;

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

              }
            finally
              {
                D.52720 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.52720);
              }
          }
        finally
          {
            D.52721 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.52721);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50263>:
  D.52722 = 0;
  if (D.52722 != 0) goto <D.52723>; else goto <D.52724>;
  <D.52723>:
  operator delete (this);
  goto <D.52725>;
  <D.52724>:
  <D.52725>:
}


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

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

          }
        finally
          {
            D.52728 = &this->_M_buf_locale;
            std::locale::~locale (D.52728);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50530>:
  D.52729 = 0;
  if (D.52729 != 0) goto <D.52730>; else goto <D.52731>;
  <D.52730>:
  operator delete (this);
  goto <D.52732>;
  <D.52731>:
  <D.52732>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.50267>:
  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.18;
  sizetype iftmp.19;
  int (*__vtbl_ptr_type) () * D.52740;
  int (*__vtbl_ptr_type) () * D.52741;
  long int D.52742;
  struct basic_ios * D.52744;
  int (*__vtbl_ptr_type) () * iftmp.20;
  int D.52749;
  struct basic_ios * D.52752;
  int D.52754;

  {
    if (0 == 0) goto <D.52734>; else goto <D.52735>;
    <D.52734>:
    iftmp.18 = *__vtt_parm;
    goto <D.52736>;
    <D.52735>:
    iftmp.18 = &MEM[(void *)&_ZTVSo + 24B];
    <D.52736>:
    this->_vptr.basic_ostream = iftmp.18;
    if (0 == 0) goto <D.52738>; else goto <D.52739>;
    <D.52738>:
    D.52740 = this->_vptr.basic_ostream;
    D.52741 = D.52740 + 18446744073709551592;
    D.52742 = MEM[(long int *)D.52741];
    iftmp.19 = (sizetype) D.52742;
    goto <D.52743>;
    <D.52739>:
    iftmp.19 = 8;
    <D.52743>:
    D.52744 = this + iftmp.19;
    if (0 == 0) goto <D.52746>; else goto <D.52747>;
    <D.52746>:
    iftmp.20 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.52748>;
    <D.52747>:
    iftmp.20 = &MEM[(void *)&_ZTVSo + 64B];
    <D.52748>:
    D.52744->D.19008._vptr.ios_base = iftmp.20;
    try
      {
        try
          {

          }
        finally
          {
            D.52749 = 0;
            if (D.52749 != 0) goto <D.52750>; else goto <D.52751>;
            <D.52750>:
            D.52752 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.52752);
            goto <D.52753>;
            <D.52751>:
            <D.52753>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50515>:
  D.52754 = 0;
  if (D.52754 != 0) goto <D.52755>; else goto <D.52756>;
  <D.52755>:
  operator delete (this);
  goto <D.52757>;
  <D.52756>:
  <D.52757>:
}


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

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

          }
        finally
          {
            D.52759 = &this->D.19008;
            std::ios_base::~ios_base (D.52759);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50503>:
  D.52760 = 0;
  if (D.52760 != 0) goto <D.52761>; else goto <D.52762>;
  <D.52761>:
  operator delete (this);
  goto <D.52763>;
  <D.52762>:
  <D.52763>:
}


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.50507>:
  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.52767;
  const void * * iftmp.21;
  struct basic_ostream * D.52773;
  int (*__vtbl_ptr_type) () * iftmp.22;
  const void * * D.52777;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.52782;
  int (*__vtbl_ptr_type) () * D.52783;
  long int D.52784;
  struct basic_ios * D.52786;
  int (*__vtbl_ptr_type) () * iftmp.24;
  _Ios_Openmode D.52791;
  struct __stringbuf_type * D.52792;
  struct basic_streambuf * D.52793;
  sizetype iftmp.25;
  struct basic_ios * D.52798;
  const void * * iftmp.26;

  if (1 != 0) goto <D.52765>; else goto <D.52766>;
  <D.52765>:
  D.52767 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.52767);
  goto <D.52768>;
  <D.52766>:
  <D.52768>:
  try
    {
      if (1 == 0) goto <D.52770>; else goto <D.52771>;
      <D.52770>:
      iftmp.21 = 8B;
      goto <D.52772>;
      <D.52771>:
      iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.52772>:
      D.52773 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.52773, iftmp.21);
      try
        {
          if (1 == 0) goto <D.52775>; else goto <D.52776>;
          <D.52775>:
          D.52777 = 0B;
          iftmp.22 = *D.52777;
          goto <D.52778>;
          <D.52776>:
          iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.52778>:
          this->D.22312._vptr.basic_ostream = iftmp.22;
          if (1 == 0) goto <D.52780>; else goto <D.52781>;
          <D.52780>:
          D.52782 = this->D.22312._vptr.basic_ostream;
          D.52783 = D.52782 + 18446744073709551592;
          D.52784 = MEM[(long int *)D.52783];
          iftmp.23 = (sizetype) D.52784;
          goto <D.52785>;
          <D.52781>:
          iftmp.23 = 88;
          <D.52785>:
          D.52786 = this + iftmp.23;
          if (1 == 0) goto <D.52788>; else goto <D.52789>;
          <D.52788>:
          iftmp.24 = MEM[(const void * *)0B + 24B];
          goto <D.52790>;
          <D.52789>:
          iftmp.24 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.52790>:
          D.52786->D.19008._vptr.ios_base = iftmp.24;
          D.52791 = std::operator| (__mode, 16);
          D.52792 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.52792, D.52791);
          try
            {
              D.52793 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.52795>; else goto <D.52796>;
              <D.52795>:
              D.52782 = this->D.22312._vptr.basic_ostream;
              D.52783 = D.52782 + 18446744073709551592;
              D.52784 = MEM[(long int *)D.52783];
              iftmp.25 = (sizetype) D.52784;
              goto <D.52797>;
              <D.52796>:
              iftmp.25 = 88;
              <D.52797>:
              D.52798 = this + iftmp.25;
              std::basic_ios<char>::init (D.52798, D.52793);
            }
          catch
            {
              D.52792 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.52792);
            }
        }
      catch
        {
          if (1 == 0) goto <D.52800>; else goto <D.52801>;
          <D.52800>:
          iftmp.26 = 8B;
          goto <D.52802>;
          <D.52801>:
          iftmp.26 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.52802>:
          D.52773 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.52773, iftmp.26);
        }
    }
  catch
    {
      if (1 != 0) goto <D.52803>; else goto <D.52804>;
      <D.52803>:
      D.52767 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.52767);
      goto <D.52805>;
      <D.52804>:
      <D.52805>:
    }
}


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

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


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.52812;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  int (*__vtbl_ptr_type) () * D.52821;
  int (*__vtbl_ptr_type) () * D.52822;
  long int D.52823;
  struct basic_ios * D.52825;
  int (*__vtbl_ptr_type) () * iftmp.29;
  sizetype iftmp.30;
  struct basic_ios * D.52834;

  if (0 != 0) goto <D.52810>; else goto <D.52811>;
  <D.52810>:
  D.52812 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.52812);
  goto <D.52813>;
  <D.52811>:
  <D.52813>:
  try
    {
      if (0 == 0) goto <D.52815>; else goto <D.52816>;
      <D.52815>:
      iftmp.27 = *__vtt_parm;
      goto <D.52817>;
      <D.52816>:
      iftmp.27 = &MEM[(void *)&_ZTVSo + 24B];
      <D.52817>:
      this->_vptr.basic_ostream = iftmp.27;
      if (0 == 0) goto <D.52819>; else goto <D.52820>;
      <D.52819>:
      D.52821 = this->_vptr.basic_ostream;
      D.52822 = D.52821 + 18446744073709551592;
      D.52823 = MEM[(long int *)D.52822];
      iftmp.28 = (sizetype) D.52823;
      goto <D.52824>;
      <D.52820>:
      iftmp.28 = 8;
      <D.52824>:
      D.52825 = this + iftmp.28;
      if (0 == 0) goto <D.52827>; else goto <D.52828>;
      <D.52827>:
      iftmp.29 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.52829>;
      <D.52828>:
      iftmp.29 = &MEM[(void *)&_ZTVSo + 64B];
      <D.52829>:
      D.52825->D.19008._vptr.ios_base = iftmp.29;
      if (0 == 0) goto <D.52831>; else goto <D.52832>;
      <D.52831>:
      D.52821 = this->_vptr.basic_ostream;
      D.52822 = D.52821 + 18446744073709551592;
      D.52823 = MEM[(long int *)D.52822];
      iftmp.30 = (sizetype) D.52823;
      goto <D.52833>;
      <D.52832>:
      iftmp.30 = 8;
      <D.52833>:
      D.52834 = this + iftmp.30;
      std::basic_ios<char>::init (D.52834, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.52835>; else goto <D.52836>;
      <D.52835>:
      D.52812 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.52812);
      goto <D.52837>;
      <D.52836>:
      <D.52837>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.52839;
  int __a.31;
  int __b.32;
  int D.52842;

  __a.31 = (int) __a;
  __b.32 = (int) __b;
  D.52842 = __a.31 | __b.32;
  D.52839 = (_Ios_Openmode) D.52842;
  return D.52839;
}


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.52844;
  struct __string_type * D.52845;

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

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


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

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

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


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.51282;
  struct _Rep & D.52848;
  char * D.52849;
  struct _Alloc_hider * D.52850;

  std::allocator<char>::allocator (&D.51282);
  try
    {
      D.52848 = std::basic_string<char>::_S_empty_rep ();
      D.52849 = std::basic_string<char>::_Rep::_M_refdata (D.52848);
      D.52850 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.52850, D.52849, &D.51282);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.51282);
      D.51282 = {CLOBBER};
    }
  try
    {

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


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

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


_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.52856;
  void * D.52857;

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


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


