int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.36639;
  int D.36642;
  int iftmp.1;
  bool D.36644;
  struct pointer_functor0 D.35354;
  const struct string D.35398;
  struct allocator D.35397;
  const struct string D.35401;
  struct allocator D.35400;
  const struct slot D.35406;
  struct pointer_functor0 D.35402;
  const struct string D.35410;
  struct allocator D.35409;
  int iftmp.2;
  bool D.36649;

  {
    struct TestUtilities * util;
    struct slot theSlot;

    try
      {
        util = TestUtilities::get_instance ();
        D.36639 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.36639;
        if (retval.0 != 0) goto <D.36640>; else goto <D.36641>;
        <D.36640>:
        D.36644 = TestUtilities::get_result_and_delete_instance ();
        if (D.36644 != 0) goto <D.36645>; else goto <D.36646>;
        <D.36645>:
        iftmp.1 = 0;
        goto <D.36647>;
        <D.36646>:
        iftmp.1 = 1;
        <D.36647>:
        D.36642 = iftmp.1;
        return D.36642;
        <D.36641>:
        D.35354 = sigc::ptr_fun<void> (Foo);
        try
          {
            sigc::slot<void>::slot<sigc::pointer_functor0<void> > (&theSlot, &D.35354);
          }
        finally
          {
            try
              {

              }
            catch
              {
                sigc::slot<void>::~slot (&theSlot);
              }
            D.35354 = {CLOBBER};
          }
        try
          {
            sigc::slot0<void>::operator() (&theSlot.D.35327);
            std::allocator<char>::allocator (&D.35397);
            try
              {
                std::basic_string<char>::basic_string (&D.35398, "Foo", &D.35397);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35398);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35398);
                    D.35398 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35397);
                D.35397 = {CLOBBER};
              }
            sigc::slot_base::disconnect (&theSlot.D.35327.D.35285);
            sigc::slot0<void>::operator() (&theSlot.D.35327);
            std::allocator<char>::allocator (&D.35400);
            try
              {
                std::basic_string<char>::basic_string (&D.35401, "", &D.35400);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35401);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35401);
                    D.35401 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35400);
                D.35400 = {CLOBBER};
              }
            D.35402 = sigc::ptr_fun<void> (Bar);
            try
              {
                sigc::slot<void>::slot<sigc::pointer_functor0<void> > (&D.35406, &D.35402);
                try
                  {
                    sigc::slot<void>::operator= (&theSlot, &D.35406);
                  }
                finally
                  {
                    sigc::slot<void>::~slot (&D.35406);
                    D.35406 = {CLOBBER};
                  }
              }
            finally
              {
                D.35402 = {CLOBBER};
              }
            sigc::slot0<void>::operator() (&theSlot.D.35327);
            std::allocator<char>::allocator (&D.35409);
            try
              {
                std::basic_string<char>::basic_string (&D.35410, "Bar", &D.35409);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35410);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35410);
                    D.35410 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35409);
                D.35409 = {CLOBBER};
              }
            D.36649 = TestUtilities::get_result_and_delete_instance ();
            if (D.36649 != 0) goto <D.36650>; else goto <D.36651>;
            <D.36650>:
            iftmp.2 = 0;
            goto <D.36652>;
            <D.36651>:
            iftmp.2 = 1;
            <D.36652>:
            D.36642 = iftmp.2;
            return D.36642;
          }
        finally
          {
            sigc::slot<void>::~slot (&theSlot);
          }
      }
    finally
      {
        theSlot = {CLOBBER};
      }
  }
  D.36642 = 0;
  return D.36642;
}


void {anonymous}::Bar() ()
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Bar");
}


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.36674;
  int (*__vtbl_ptr_type) () * D.36675;
  long int D.36676;
  sizetype D.36677;
  struct basic_ios * D.36678;
  long unsigned int D.36680;
  long int D.36681;
  struct basic_ostream & D.36682;

  if (__s == 0B) goto <D.36672>; else goto <D.36673>;
  <D.36672>:
  D.36674 = __out->_vptr.basic_ostream;
  D.36675 = D.36674 + 18446744073709551592;
  D.36676 = MEM[(long int *)D.36675];
  D.36677 = (sizetype) D.36676;
  D.36678 = __out + D.36677;
  std::basic_ios<char>::setstate (D.36678, 1);
  goto <D.36679>;
  <D.36673>:
  D.36680 = std::char_traits<char>::length (__s);
  D.36681 = (long int) D.36680;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.36681);
  <D.36679>:
  D.36682 = __out;
  return D.36682;
}


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.36684;
  _Ios_Iostate D.36685;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.36692 = __a.3 | __b.4;
  D.36689 = (_Ios_Iostate) D.36692;
  return D.36689;
}


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

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


void {anonymous}::Foo() ()
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Foo");
}


sigc::pointer_functor0<T_return> sigc::ptr_fun(T_return (*)()) [with T_return = void] (void (*<Ted6>) (void) _A_func)
{
  struct pointer_functor0 D.36696;
  struct pointer_functor0 D.35512;

  sigc::pointer_functor0<void>::pointer_functor0 (&D.35512, _A_func);
  try
    {
      D.36696 = D.35512;
      return D.36696;
    }
  finally
    {
      D.35512 = {CLOBBER};
    }
}


sigc::pointer_functor0<T_return>::pointer_functor0(sigc::pointer_functor0<T_return>::function_type) [with T_return = void; sigc::pointer_functor0<T_return>::function_type = void (*)()] (struct pointer_functor0 * const this, void (*function_type) (void) _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, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor0<void>; T_return = void] (struct slot * const this, const struct pointer_functor0 & _A_func)
{
  struct slot0 * D.36699;

  D.36699 = &this->D.35327;
  sigc::slot0<void>::slot0<sigc::pointer_functor0<void> > (D.36699, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::pointer_functor0<void>; T_return = void] (struct slot0 * const this, const struct pointer_functor0 & _A_func)
{
  void * D.36161;
  struct slot_base * D.36700;
  struct rep_type * D.36701;
  void * (*<T1711>) (void *) D.36702;

  D.36161 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor0<void> >::typed_slot_rep (D.36161, _A_func);
    }
  catch
    {
      operator delete (D.36161);
    }
  D.36700 = &this->D.35285;
  sigc::slot_base::slot_base (D.36700, D.36161);
  try
    {
      D.36701 = this->D.35285.rep_;
      D.36702 = sigc::internal::slot_call0<sigc::pointer_functor0<void>, void>::address ();
      D.36701->call_ = D.36702;
    }
  catch
    {
      D.36700 = &this->D.35285;
      sigc::slot_base::~slot_base (D.36700);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::pointer_functor0<void>] (struct typed_slot_rep * const this, const struct pointer_functor0 & functor)
{
  struct slot_rep * D.36705;
  struct adaptor_type * D.36706;
  struct slot_do_bind D.36298;

  D.36705 = &this->D.36144;
  sigc::internal::slot_rep::slot_rep (D.36705, 0B, destroy, dup);
  try
    {
      D.36706 = &this->functor_;
      sigc::adaptor_functor<sigc::pointer_functor0<void> >::adaptor_functor (D.36706, functor);
      D.36706 = &this->functor_;
      D.36705 = &this->D.36144;
      sigc::internal::slot_do_bind::slot_do_bind (&D.36298, D.36705);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor0<void> > > (&D.36298, D.36706);
        }
      finally
        {
          D.36298 = {CLOBBER};
        }
    }
  catch
    {
      D.36705 = &this->D.36144;
      sigc::internal::slot_rep::~slot_rep (D.36705);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::pointer_functor0<void>] (void * data)
{
  void * D.36709;
  void * D.36381;
  struct slot_rep * a_rep;

  a_rep = data;
  D.36381 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor0<void> >::typed_slot_rep (D.36381, a_rep);
    }
  catch
    {
      operator delete (D.36381);
    }
  D.36709 = D.36381;
  return D.36709;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor0<void>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.36713;
  struct slot_rep * D.36714;
  struct adaptor_type * D.36715;
  struct slot_do_bind D.36506;

  D.36713 = cl->D.36144.call_;
  D.36714 = &this->D.36144;
  sigc::internal::slot_rep::slot_rep (D.36714, D.36713, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.36715 = &this->functor_;
      D.36714 = &this->D.36144;
      sigc::internal::slot_do_bind::slot_do_bind (&D.36506, D.36714);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor0<void> > > (&D.36506, D.36715);
        }
      finally
        {
          D.36506 = {CLOBBER};
        }
    }
  catch
    {
      D.36714 = &this->D.36144;
      sigc::internal::slot_rep::~slot_rep (D.36714);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::pointer_functor0<void>] (void * data)
{
  struct adaptor_type * D.36718;
  struct slot_do_unbind D.36366;
  void * D.36719;
  struct self * self_;

  self_ = data;
  self_->D.36144.call_ = 0B;
  self_->D.36144.destroy_ = 0B;
  D.36718 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.36366, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor0<void> > > (&D.36366, D.36718);
    }
  finally
    {
      D.36366 = {CLOBBER};
    }
  D.36719 = 0B;
  return D.36719;
}


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

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


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_functor0<void>] (const struct limit_derived_target & _A_action, const struct pointer_functor0 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor0<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_functor0<void>] (const struct limit_derived_target & _A_action, const struct pointer_functor0 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::pointer_functor0<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_functor0<void>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct pointer_functor0 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor0<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_functor0<void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor0 & D.36613, const struct limit_derived_target & D.36614)
{
  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.36724;

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


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


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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::pointer_functor0<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_functor0<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_functor0<void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor0<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_functor0<void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor0 * D.36726;

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


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_functor0<void>] (const struct limit_derived_target & _A_action, const struct pointer_functor0 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor0<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_functor0<void>] (const struct limit_derived_target & _A_action, const struct pointer_functor0 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::pointer_functor0<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_functor0<void>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct pointer_functor0 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor0<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_functor0<void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor0 & D.36604, const struct limit_derived_target & D.36605)
{
  GIMPLE_NOP
}


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

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


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

  D.36730 = this->destroy_;
  if (D.36730 != 0B) goto <D.36731>; else goto <D.36732>;
  <D.36731>:
  D.36730 = this->destroy_;
  D.36730 (this);
  goto <D.36733>;
  <D.36732>:
  <D.36733>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::pointer_functor0<void>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.36734;

  D.36734 = call_it;
  return D.36734;
}


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

  typed_rep = rep;
  D.36736 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::pointer_functor0<void> >::operator() (D.36736);
  return;
}


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

  D.36738 = &this->functor_;
  sigc::pointer_functor0<void>::operator() (D.36738);
  return;
}


T_return sigc::pointer_functor0<T_return>::operator()() const [with T_return = void] (const struct pointer_functor0 * const this)
{
  void (*<Ted6>) (void) D.36740;

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


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.35404)
{
  const struct slot0 * D.36742;
  struct slot0 * D.36743;
  struct slot & D.36744;

  D.36742 = &D.35404->D.35327;
  D.36743 = &this->D.35327;
  sigc::slot0<void>::operator= (D.36743, D.36742);
  D.36744 = this;
  return D.36744;
}


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.36746;
  struct slot_base * D.36747;
  struct slot0 & D.36748;

  D.36746 = &src->D.35285;
  D.36747 = &this->D.35285;
  sigc::slot_base::operator= (D.36747, D.36746);
  D.36748 = this;
  return D.36748;
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.5;
  bool iftmp.6;
  const struct slot_base * D.36754;
  bool D.36755;
  bool D.36756;
  bool D.36758;
  bool D.36759;
  struct rep_type * D.36763;
  void * (*<T1711>) (void *) D.36764;

  D.36754 = &this->D.35285;
  D.36755 = sigc::slot_base::empty (D.36754);
  D.36756 = ~D.36755;
  if (D.36756 != 0) goto <D.36757>; else goto <D.36752>;
  <D.36757>:
  D.36754 = &this->D.35285;
  D.36758 = sigc::slot_base::blocked (D.36754);
  D.36759 = ~D.36758;
  if (D.36759 != 0) goto <D.36760>; else goto <D.36752>;
  <D.36760>:
  iftmp.6 = 1;
  goto <D.36753>;
  <D.36752>:
  iftmp.6 = 0;
  <D.36753>:
  retval.5 = iftmp.6;
  if (retval.5 != 0) goto <D.36761>; else goto <D.36762>;
  <D.36761>:
  D.36763 = this->D.35285.rep_;
  D.36764 = D.36763->call_;
  D.36763 = this->D.35285.rep_;
  D.36764 (D.36763);
  return;
  <D.36762>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.36766;
  bool iftmp.7;
  struct rep_type * D.36771;
  void * (*<T1711>) (void *) D.36773;

  D.36771 = this->rep_;
  if (D.36771 == 0B) goto <D.36768>; else goto <D.36772>;
  <D.36772>:
  D.36771 = this->rep_;
  D.36773 = D.36771->call_;
  if (D.36773 == 0B) goto <D.36768>; else goto <D.36769>;
  <D.36768>:
  iftmp.7 = 1;
  goto <D.36770>;
  <D.36769>:
  iftmp.7 = 0;
  <D.36770>:
  D.36766 = iftmp.7;
  return D.36766;
}


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

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


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

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

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


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

  try
    {
      {

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


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.35563;
  struct _Rep * D.36779;
  struct _Alloc_hider * D.36780;

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


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

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

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


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

  try
    {
      {

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


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.36790;
  char * D.36791;

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


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

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


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.8;
  struct _Rep & D.36797;
  bool D.36798;
  long int D.36799;
  long int D.36800;
  bool retval.9;
  _Atomic_word * D.36804;
  int D.36805;

  D.36797 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.36798 = D.36797 != this;
  D.36799 = (long int) D.36798;
  D.36800 = __builtin_expect (D.36799, 0);
  retval.8 = D.36800 != 0;
  if (retval.8 != 0) goto <D.36801>; else goto <D.36802>;
  <D.36801>:
  D.36804 = &this->D.11865._M_refcount;
  D.36805 = __gnu_cxx::__exchange_and_add_dispatch (D.36804, -1);
  retval.9 = D.36805 <= 0;
  if (retval.9 != 0) goto <D.36806>; else goto <D.36807>;
  <D.36806>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.36808>;
  <D.36807>:
  <D.36808>:
  goto <D.36809>;
  <D.36802>:
  <D.36809>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.10;
  int D.36814;
  _Atomic_word D.36817;

  D.36814 = __gthread_active_p ();
  retval.10 = D.36814 != 0;
  if (retval.10 != 0) goto <D.36815>; else goto <D.36816>;
  <D.36815>:
  D.36817 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.36817;
  <D.36816>:
  D.36817 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.36817;
}


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

  D.36820 = __gthrw___pthread_key_create != 0B;
  D.36819 = (int) D.36820;
  return D.36819;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.36822;
  unsigned int __val.11;
  unsigned int D.36824;

  __val.11 = (unsigned int) __val;
  D.36824 = __atomic_fetch_add_4 (__mem, __val.11, 4);
  D.36822 = (_Atomic_word) D.36824;
  return D.36822;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.36826;
  int D.36827;
  _Atomic_word D.36828;
  _Atomic_word __result;

  __result = *__mem;
  D.36826 = *__mem;
  D.36827 = D.36826 + __val;
  *__mem = D.36827;
  D.36828 = __result;
  return D.36828;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.36832 = &this->D.35327;
            sigc::slot0<void>::~slot0 (D.36832);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35393>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.36834 = &this->D.35285;
            sigc::slot_base::~slot_base (D.36834);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35388>:
}


(static initializers for test_slot_disconnect.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.36836>; else goto <D.36837>;
  <D.36836>:
  if (__priority == 65535) goto <D.36838>; else goto <D.36839>;
  <D.36838>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.36840>;
  <D.36839>:
  <D.36840>:
  goto <D.36841>;
  <D.36837>:
  <D.36841>:
}


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.12;
  const void * * D.36845;
  sizetype iftmp.13;
  int (*__vtbl_ptr_type) () * D.36850;
  int (*__vtbl_ptr_type) () * D.36851;
  long int D.36852;
  struct basic_ios * D.36854;
  int (*__vtbl_ptr_type) () * iftmp.14;
  struct __stringbuf_type * D.36859;
  const void * * iftmp.15;
  struct basic_ostream * D.36864;
  int D.36865;
  struct basic_ios * D.36868;
  int D.36870;

  {
    if (2 == 0) goto <D.36843>; else goto <D.36844>;
    <D.36843>:
    D.36845 = 0B;
    iftmp.12 = *D.36845;
    goto <D.36846>;
    <D.36844>:
    iftmp.12 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.36846>:
    this->D.22312._vptr.basic_ostream = iftmp.12;
    if (2 == 0) goto <D.36848>; else goto <D.36849>;
    <D.36848>:
    D.36850 = this->D.22312._vptr.basic_ostream;
    D.36851 = D.36850 + 18446744073709551592;
    D.36852 = MEM[(long int *)D.36851];
    iftmp.13 = (sizetype) D.36852;
    goto <D.36853>;
    <D.36849>:
    iftmp.13 = 88;
    <D.36853>:
    D.36854 = this + iftmp.13;
    if (2 == 0) goto <D.36856>; else goto <D.36857>;
    <D.36856>:
    iftmp.14 = MEM[(const void * *)0B + 24B];
    goto <D.36858>;
    <D.36857>:
    iftmp.14 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.36858>:
    D.36854->D.19008._vptr.ios_base = iftmp.14;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.36859 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.36859);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.36861>; else goto <D.36862>;
                <D.36861>:
                iftmp.15 = 8B;
                goto <D.36863>;
                <D.36862>:
                iftmp.15 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.36863>:
                D.36864 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.36864, iftmp.15);
              }
          }
        finally
          {
            D.36865 = 2;
            if (D.36865 != 0) goto <D.36866>; else goto <D.36867>;
            <D.36866>:
            D.36868 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.36868);
            goto <D.36869>;
            <D.36867>:
            <D.36869>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36633>:
  D.36870 = 0;
  if (D.36870 != 0) goto <D.36871>; else goto <D.36872>;
  <D.36871>:
  operator delete (this);
  goto <D.36873>;
  <D.36872>:
  <D.36873>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.36883;
  struct basic_streambuf * D.36884;
  int D.36885;

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

              }
            finally
              {
                D.36883 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.36883);
              }
          }
        finally
          {
            D.36884 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.36884);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35494>:
  D.36885 = 0;
  if (D.36885 != 0) goto <D.36886>; else goto <D.36887>;
  <D.36886>:
  operator delete (this);
  goto <D.36888>;
  <D.36887>:
  <D.36888>:
}


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

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

          }
        finally
          {
            D.36891 = &this->_M_buf_locale;
            std::locale::~locale (D.36891);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35629>:
  D.36892 = 0;
  if (D.36892 != 0) goto <D.36893>; else goto <D.36894>;
  <D.36893>:
  operator delete (this);
  goto <D.36895>;
  <D.36894>:
  <D.36895>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.35498>:
  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.16;
  sizetype iftmp.17;
  int (*__vtbl_ptr_type) () * D.36903;
  int (*__vtbl_ptr_type) () * D.36904;
  long int D.36905;
  struct basic_ios * D.36907;
  int (*__vtbl_ptr_type) () * iftmp.18;
  int D.36912;
  struct basic_ios * D.36915;
  int D.36917;

  {
    if (0 == 0) goto <D.36897>; else goto <D.36898>;
    <D.36897>:
    iftmp.16 = *__vtt_parm;
    goto <D.36899>;
    <D.36898>:
    iftmp.16 = &MEM[(void *)&_ZTVSo + 24B];
    <D.36899>:
    this->_vptr.basic_ostream = iftmp.16;
    if (0 == 0) goto <D.36901>; else goto <D.36902>;
    <D.36901>:
    D.36903 = this->_vptr.basic_ostream;
    D.36904 = D.36903 + 18446744073709551592;
    D.36905 = MEM[(long int *)D.36904];
    iftmp.17 = (sizetype) D.36905;
    goto <D.36906>;
    <D.36902>:
    iftmp.17 = 8;
    <D.36906>:
    D.36907 = this + iftmp.17;
    if (0 == 0) goto <D.36909>; else goto <D.36910>;
    <D.36909>:
    iftmp.18 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.36911>;
    <D.36910>:
    iftmp.18 = &MEM[(void *)&_ZTVSo + 64B];
    <D.36911>:
    D.36907->D.19008._vptr.ios_base = iftmp.18;
    try
      {
        try
          {

          }
        finally
          {
            D.36912 = 0;
            if (D.36912 != 0) goto <D.36913>; else goto <D.36914>;
            <D.36913>:
            D.36915 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.36915);
            goto <D.36916>;
            <D.36914>:
            <D.36916>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35614>:
  D.36917 = 0;
  if (D.36917 != 0) goto <D.36918>; else goto <D.36919>;
  <D.36918>:
  operator delete (this);
  goto <D.36920>;
  <D.36919>:
  <D.36920>:
}


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

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

          }
        finally
          {
            D.36922 = &this->D.19008;
            std::ios_base::~ios_base (D.36922);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35602>:
  D.36923 = 0;
  if (D.36923 != 0) goto <D.36924>; else goto <D.36925>;
  <D.36924>:
  operator delete (this);
  goto <D.36926>;
  <D.36925>:
  <D.36926>:
}


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.35606>:
  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.36930;
  const void * * iftmp.19;
  struct basic_ostream * D.36936;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * D.36940;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.36945;
  int (*__vtbl_ptr_type) () * D.36946;
  long int D.36947;
  struct basic_ios * D.36949;
  int (*__vtbl_ptr_type) () * iftmp.22;
  _Ios_Openmode D.36954;
  struct __stringbuf_type * D.36955;
  struct basic_streambuf * D.36956;
  sizetype iftmp.23;
  struct basic_ios * D.36961;
  const void * * iftmp.24;

  if (1 != 0) goto <D.36928>; else goto <D.36929>;
  <D.36928>:
  D.36930 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.36930);
  goto <D.36931>;
  <D.36929>:
  <D.36931>:
  try
    {
      if (1 == 0) goto <D.36933>; else goto <D.36934>;
      <D.36933>:
      iftmp.19 = 8B;
      goto <D.36935>;
      <D.36934>:
      iftmp.19 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.36935>:
      D.36936 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.36936, iftmp.19);
      try
        {
          if (1 == 0) goto <D.36938>; else goto <D.36939>;
          <D.36938>:
          D.36940 = 0B;
          iftmp.20 = *D.36940;
          goto <D.36941>;
          <D.36939>:
          iftmp.20 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.36941>:
          this->D.22312._vptr.basic_ostream = iftmp.20;
          if (1 == 0) goto <D.36943>; else goto <D.36944>;
          <D.36943>:
          D.36945 = this->D.22312._vptr.basic_ostream;
          D.36946 = D.36945 + 18446744073709551592;
          D.36947 = MEM[(long int *)D.36946];
          iftmp.21 = (sizetype) D.36947;
          goto <D.36948>;
          <D.36944>:
          iftmp.21 = 88;
          <D.36948>:
          D.36949 = this + iftmp.21;
          if (1 == 0) goto <D.36951>; else goto <D.36952>;
          <D.36951>:
          iftmp.22 = MEM[(const void * *)0B + 24B];
          goto <D.36953>;
          <D.36952>:
          iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.36953>:
          D.36949->D.19008._vptr.ios_base = iftmp.22;
          D.36954 = std::operator| (__mode, 16);
          D.36955 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.36955, D.36954);
          try
            {
              D.36956 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.36958>; else goto <D.36959>;
              <D.36958>:
              D.36945 = this->D.22312._vptr.basic_ostream;
              D.36946 = D.36945 + 18446744073709551592;
              D.36947 = MEM[(long int *)D.36946];
              iftmp.23 = (sizetype) D.36947;
              goto <D.36960>;
              <D.36959>:
              iftmp.23 = 88;
              <D.36960>:
              D.36961 = this + iftmp.23;
              std::basic_ios<char>::init (D.36961, D.36956);
            }
          catch
            {
              D.36955 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.36955);
            }
        }
      catch
        {
          if (1 == 0) goto <D.36963>; else goto <D.36964>;
          <D.36963>:
          iftmp.24 = 8B;
          goto <D.36965>;
          <D.36964>:
          iftmp.24 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.36965>:
          D.36936 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.36936, iftmp.24);
        }
    }
  catch
    {
      if (1 != 0) goto <D.36966>; else goto <D.36967>;
      <D.36966>:
      D.36930 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.36930);
      goto <D.36968>;
      <D.36967>:
      <D.36968>:
    }
}


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

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


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.36975;
  int (*__vtbl_ptr_type) () * iftmp.25;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.36984;
  int (*__vtbl_ptr_type) () * D.36985;
  long int D.36986;
  struct basic_ios * D.36988;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  struct basic_ios * D.36997;

  if (0 != 0) goto <D.36973>; else goto <D.36974>;
  <D.36973>:
  D.36975 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.36975);
  goto <D.36976>;
  <D.36974>:
  <D.36976>:
  try
    {
      if (0 == 0) goto <D.36978>; else goto <D.36979>;
      <D.36978>:
      iftmp.25 = *__vtt_parm;
      goto <D.36980>;
      <D.36979>:
      iftmp.25 = &MEM[(void *)&_ZTVSo + 24B];
      <D.36980>:
      this->_vptr.basic_ostream = iftmp.25;
      if (0 == 0) goto <D.36982>; else goto <D.36983>;
      <D.36982>:
      D.36984 = this->_vptr.basic_ostream;
      D.36985 = D.36984 + 18446744073709551592;
      D.36986 = MEM[(long int *)D.36985];
      iftmp.26 = (sizetype) D.36986;
      goto <D.36987>;
      <D.36983>:
      iftmp.26 = 8;
      <D.36987>:
      D.36988 = this + iftmp.26;
      if (0 == 0) goto <D.36990>; else goto <D.36991>;
      <D.36990>:
      iftmp.27 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.36992>;
      <D.36991>:
      iftmp.27 = &MEM[(void *)&_ZTVSo + 64B];
      <D.36992>:
      D.36988->D.19008._vptr.ios_base = iftmp.27;
      if (0 == 0) goto <D.36994>; else goto <D.36995>;
      <D.36994>:
      D.36984 = this->_vptr.basic_ostream;
      D.36985 = D.36984 + 18446744073709551592;
      D.36986 = MEM[(long int *)D.36985];
      iftmp.28 = (sizetype) D.36986;
      goto <D.36996>;
      <D.36995>:
      iftmp.28 = 8;
      <D.36996>:
      D.36997 = this + iftmp.28;
      std::basic_ios<char>::init (D.36997, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.36998>; else goto <D.36999>;
      <D.36998>:
      D.36975 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.36975);
      goto <D.37000>;
      <D.36999>:
      <D.37000>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.37002;
  int __a.29;
  int __b.30;
  int D.37005;

  __a.29 = (int) __a;
  __b.30 = (int) __b;
  D.37005 = __a.29 | __b.30;
  D.37002 = (_Ios_Openmode) D.37005;
  return D.37002;
}


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.37007;
  struct __string_type * D.37008;

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

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


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

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

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


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.36253;
  struct _Rep & D.37011;
  char * D.37012;
  struct _Alloc_hider * D.37013;

  std::allocator<char>::allocator (&D.36253);
  try
    {
      D.37011 = std::basic_string<char>::_S_empty_rep ();
      D.37012 = std::basic_string<char>::_Rep::_M_refdata (D.37011);
      D.37013 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.37013, D.37012, &D.36253);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.36253);
      D.36253 = {CLOBBER};
    }
  try
    {

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


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

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


_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.37019;
  void * D.37020;

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


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


