int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.37510;
  int D.37513;
  int iftmp.1;
  bool D.37515;
  struct foo D.35350;
  const int D.35402;
  const struct string D.35405;
  struct allocator D.35404;
  const struct slot D.35410;
  struct foo D.35406;
  const int D.35412;
  const struct string D.35415;
  struct allocator D.35414;
  struct foo D.35519;
  const char D.35571;
  const struct string D.35574;
  struct allocator D.35573;
  struct foo D.35678;
  struct allocator D.35732;
  const struct string D.35735;
  struct allocator D.35734;
  const struct string D.35743;
  struct allocator D.35742;
  const int D.35745;
  const struct string D.35748;
  struct allocator D.35747;
  int iftmp.2;
  bool D.37520;

  {
    struct TestUtilities * util;
    struct slot s1;
    struct slot s2;
    struct slot sl1;
    struct string str;
    struct slot sl2;
    struct slot s1_clone;

    try
      {
        util = TestUtilities::get_instance ();
        D.37510 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.37510;
        if (retval.0 != 0) goto <D.37511>; else goto <D.37512>;
        <D.37511>:
        D.37515 = TestUtilities::get_result_and_delete_instance ();
        if (D.37515 != 0) goto <D.37516>; else goto <D.37517>;
        <D.37516>:
        iftmp.1 = 0;
        goto <D.37518>;
        <D.37517>:
        iftmp.1 = 1;
        <D.37518>:
        D.37513 = iftmp.1;
        return D.37513;
        <D.37512>:
        try
          {
            sigc::slot<void, int>::slot<{anonymous}::foo> (&s1, &D.35350);
          }
        finally
          {
            try
              {

              }
            catch
              {
                sigc::slot<void, int>::~slot (&s1);
              }
            D.35350 = {CLOBBER};
          }
        try
          {
            D.35402 = 1;
            try
              {
                sigc::slot1<void, int>::operator() (&s1.D.35348, &D.35402);
              }
            finally
              {
                D.35402 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.35404);
            try
              {
                std::basic_string<char>::basic_string (&D.35405, "foo(int 1)", &D.35404);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35405);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35405);
                    D.35405 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35404);
                D.35404 = {CLOBBER};
              }
            try
              {
                sigc::slot<void, int>::slot<{anonymous}::foo> (&D.35410, &D.35406);
                try
                  {
                    sigc::slot<void, int>::operator= (&s1, &D.35410);
                  }
                finally
                  {
                    sigc::slot<void, int>::~slot (&D.35410);
                    D.35410 = {CLOBBER};
                  }
              }
            finally
              {
                D.35406 = {CLOBBER};
              }
            D.35412 = 2;
            try
              {
                sigc::slot1<void, int>::operator() (&s1.D.35348, &D.35412);
              }
            finally
              {
                D.35412 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.35414);
            try
              {
                std::basic_string<char>::basic_string (&D.35415, "foo(int 2)", &D.35414);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35415);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35415);
                    D.35415 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35414);
                D.35414 = {CLOBBER};
              }
            try
              {
                sigc::slot<void, char>::slot<{anonymous}::foo> (&s2, &D.35519);
              }
            finally
              {
                try
                  {

                  }
                catch
                  {
                    sigc::slot<void, char>::~slot (&s2);
                  }
                D.35519 = {CLOBBER};
              }
            try
              {
                D.35571 = 3;
                try
                  {
                    sigc::slot1<void, char>::operator() (&s2.D.35517, &D.35571);
                  }
                finally
                  {
                    D.35571 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.35573);
                try
                  {
                    std::basic_string<char>::basic_string (&D.35574, "foo(int 3)", &D.35573);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.35574);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.35574);
                        D.35574 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.35573);
                    D.35573 = {CLOBBER};
                  }
                try
                  {
                    sigc::slot<void, std::basic_string<char>&>::slot<{anonymous}::foo> (&sl1, &D.35678);
                  }
                finally
                  {
                    try
                      {

                      }
                    catch
                      {
                        sigc::slot<void, std::basic_string<char>&>::~slot (&sl1);
                      }
                    D.35678 = {CLOBBER};
                  }
                try
                  {
                    std::allocator<char>::allocator (&D.35732);
                    try
                      {
                        std::basic_string<char>::basic_string (&str, "guest book", &D.35732);
                      }
                    finally
                      {
                        try
                          {
                            std::allocator<char>::~allocator (&D.35732);
                          }
                        catch
                          {
                            std::basic_string<char>::~basic_string (&str);
                          }
                        D.35732 = {CLOBBER};
                      }
                    try
                      {
                        sigc::slot1<void, std::basic_string<char>&>::operator() (&sl1.D.35676, &str);
                        std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &str);
                        std::allocator<char>::allocator (&D.35734);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.35735, "foo(string \'guest book\') foo was here", &D.35734);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.35735);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.35735);
                                D.35735 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.35734);
                            D.35734 = {CLOBBER};
                          }
                        std::basic_string<char>::operator= (&str, "guest book");
                        sigc::slot<void, std::basic_string<char>&>::slot (&sl2);
                        try
                          {
                            sigc::slot<void, std::basic_string<char>&>::operator= (&sl2, &sl1);
                            sigc::slot<void, std::basic_string<char>&>::operator= (&sl1, &sl2);
                            sigc::slot1<void, std::basic_string<char>&>::operator() (&sl1.D.35676, &str);
                            std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &str);
                            std::allocator<char>::allocator (&D.35742);
                            try
                              {
                                std::basic_string<char>::basic_string (&D.35743, "foo(string \'guest book\') foo was here", &D.35742);
                                try
                                  {
                                    TestUtilities::check_result (util, &result_stream, &D.35743);
                                  }
                                finally
                                  {
                                    std::basic_string<char>::~basic_string (&D.35743);
                                    D.35743 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                std::allocator<char>::~allocator (&D.35742);
                                D.35742 = {CLOBBER};
                              }
                            sigc::slot<void, int>::slot (&s1_clone, &s1);
                            try
                              {
                                D.35745 = 4;
                                try
                                  {
                                    sigc::slot1<void, int>::operator() (&s1_clone.D.35348, &D.35745);
                                  }
                                finally
                                  {
                                    D.35745 = {CLOBBER};
                                  }
                                std::allocator<char>::allocator (&D.35747);
                                try
                                  {
                                    std::basic_string<char>::basic_string (&D.35748, "foo(int 4)", &D.35747);
                                    try
                                      {
                                        TestUtilities::check_result (util, &result_stream, &D.35748);
                                      }
                                    finally
                                      {
                                        std::basic_string<char>::~basic_string (&D.35748);
                                        D.35748 = {CLOBBER};
                                      }
                                  }
                                finally
                                  {
                                    std::allocator<char>::~allocator (&D.35747);
                                    D.35747 = {CLOBBER};
                                  }
                                D.37520 = TestUtilities::get_result_and_delete_instance ();
                                if (D.37520 != 0) goto <D.37521>; else goto <D.37522>;
                                <D.37521>:
                                iftmp.2 = 0;
                                goto <D.37523>;
                                <D.37522>:
                                iftmp.2 = 1;
                                <D.37523>:
                                D.37513 = iftmp.2;
                                return D.37513;
                              }
                            finally
                              {
                                sigc::slot<void, int>::~slot (&s1_clone);
                              }
                          }
                        finally
                          {
                            sigc::slot<void, std::basic_string<char>&>::~slot (&sl2);
                          }
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&str);
                      }
                  }
                finally
                  {
                    sigc::slot<void, std::basic_string<char>&>::~slot (&sl1);
                  }
              }
            finally
              {
                sigc::slot<void, char>::~slot (&s2);
              }
          }
        finally
          {
            sigc::slot<void, int>::~slot (&s1);
          }
      }
    finally
      {
        s1 = {CLOBBER};
        s2 = {CLOBBER};
        sl1 = {CLOBBER};
        str = {CLOBBER};
        sl2 = {CLOBBER};
        s1_clone = {CLOBBER};
      }
  }
  D.37513 = 0;
  return D.37513;
}


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 = {anonymous}::foo; T_return = void; T_arg1 = int] (struct slot * const this, const struct foo & _A_func)
{
  struct slot1 * D.37566;

  D.37566 = &this->D.35348;
  sigc::slot1<void, int>::slot1<{anonymous}::foo> (D.37566, _A_func);
  try
    {

    }
  catch
    {
      D.37566 = &this->D.35348;
      sigc::slot1<void, int>::~slot1 (D.37566);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = {anonymous}::foo; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct foo & _A_func)
{
  void * D.36530;
  struct slot_base * D.37567;
  struct rep_type * D.37568;
  void * (*<T1711>) (void *) D.37569;

  D.36530 = operator new (56);
  try
    {
      sigc::internal::typed_slot_rep<{anonymous}::foo>::typed_slot_rep (D.36530, _A_func);
    }
  catch
    {
      operator delete (D.36530);
    }
  D.37567 = &this->D.35306;
  sigc::slot_base::slot_base (D.37567, D.36530);
  try
    {
      D.37568 = this->D.35306.rep_;
      D.37569 = sigc::internal::slot_call1<{anonymous}::foo, void, int>::address ();
      D.37568->call_ = D.37569;
    }
  catch
    {
      D.37567 = &this->D.35306;
      sigc::slot_base::~slot_base (D.37567);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = {anonymous}::foo] (struct typed_slot_rep * const this, const struct foo & functor)
{
  struct slot_rep * D.37572;
  struct adaptor_type * D.37573;
  struct slot_do_bind D.36704;

  D.37572 = &this->D.36518;
  sigc::internal::slot_rep::slot_rep (D.37572, 0B, destroy, dup);
  try
    {
      D.37573 = &this->functor_;
      sigc::adaptor_functor<{anonymous}::foo>::adaptor_functor (D.37573, functor);
      D.37573 = &this->functor_;
      D.37572 = &this->D.36518;
      sigc::internal::slot_do_bind::slot_do_bind (&D.36704, D.37572);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<{anonymous}::foo> > (&D.36704, D.37573);
        }
      finally
        {
          D.36704 = {CLOBBER};
        }
    }
  catch
    {
      D.37572 = &this->D.36518;
      sigc::internal::slot_rep::~slot_rep (D.37572);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = {anonymous}::foo] (void * data)
{
  void * D.37576;
  void * D.36788;
  struct slot_rep * a_rep;

  a_rep = data;
  D.36788 = operator new (56);
  try
    {
      sigc::internal::typed_slot_rep<{anonymous}::foo>::typed_slot_rep (D.36788, a_rep);
    }
  catch
    {
      operator delete (D.36788);
    }
  D.37576 = D.36788;
  return D.37576;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = {anonymous}::foo] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.37580;
  struct slot_rep * D.37581;
  struct adaptor_type * D.37582;
  struct slot_do_bind D.37315;

  D.37580 = cl->D.36518.call_;
  D.37581 = &this->D.36518;
  sigc::internal::slot_rep::slot_rep (D.37581, D.37580, destroy, dup);
  try
    {
      D.37582 = &this->functor_;
      D.37581 = &this->D.36518;
      sigc::internal::slot_do_bind::slot_do_bind (&D.37315, D.37581);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<{anonymous}::foo> > (&D.37315, D.37582);
        }
      finally
        {
          D.37315 = {CLOBBER};
        }
    }
  catch
    {
      D.37581 = &this->D.36518;
      sigc::internal::slot_rep::~slot_rep (D.37581);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = {anonymous}::foo] (void * data)
{
  struct adaptor_type * D.37585;
  struct slot_do_unbind D.36773;
  void * D.37586;
  struct self * self_;

  self_ = data;
  self_->D.36518.call_ = 0B;
  self_->D.36518.destroy_ = 0B;
  D.37585 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.36773, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<{anonymous}::foo> > (&D.36773, D.37585);
    }
  finally
    {
      D.36773 = {CLOBBER};
    }
  D.37586 = 0B;
  return D.37586;
}


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

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


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = {anonymous}::foo; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct foo & _A_type)
{
  sigc::internal::with_type_pointer<false, {anonymous}::foo, 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 = {anonymous}::foo; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct foo & D.37413, const struct limit_derived_target & D.37414)
{
  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.37591;

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


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


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


sigc::functor_base::functor_base() (struct functor_base * const 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<{anonymous}::foo>] (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<{anonymous}::foo> > (&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<{anonymous}::foo>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<{anonymous}::foo> >::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 = {anonymous}::foo] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct foo * D.37593;

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


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


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


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

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


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

  D.37597 = this->destroy_;
  if (D.37597 != 0B) goto <D.37598>; else goto <D.37599>;
  <D.37598>:
  D.37597 = this->destroy_;
  D.37597 (this);
  goto <D.37600>;
  <D.37599>:
  <D.37600>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = {anonymous}::foo; T_return = void; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.37601;

  D.37601 = call_it;
  return D.37601;
}


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 = {anonymous}::foo; T_return = void; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  struct adaptor_type * D.37603;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.37603 = &typed_rep->functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<const int&> (D.37603, a_1);
  return;
}


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

  D.37605 = *_A_arg1;
  D.37606 = &this->functor_;
  {anonymous}::foo::operator() (D.37606, D.37605);
  return;
}


void {anonymous}::foo::operator()(int) (struct foo * const this, int i)
{
  struct basic_ostream & D.37608;
  struct basic_ostream & D.37609;

  D.37608 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.37609 = std::basic_ostream<char>::operator<< (D.37608, i);
  std::operator<< <std::char_traits<char> > (D.37609, ")");
}


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.37614;
  int (*__vtbl_ptr_type) () * D.37615;
  long int D.37616;
  sizetype D.37617;
  struct basic_ios * D.37618;
  long unsigned int D.37620;
  long int D.37621;
  struct basic_ostream & D.37622;

  if (__s == 0B) goto <D.37612>; else goto <D.37613>;
  <D.37612>:
  D.37614 = __out->_vptr.basic_ostream;
  D.37615 = D.37614 + 18446744073709551592;
  D.37616 = MEM[(long int *)D.37615];
  D.37617 = (sizetype) D.37616;
  D.37618 = __out + D.37617;
  std::basic_ios<char>::setstate (D.37618, 1);
  goto <D.37619>;
  <D.37613>:
  D.37620 = std::char_traits<char>::length (__s);
  D.37621 = (long int) D.37620;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.37621);
  <D.37619>:
  D.37622 = __out;
  return D.37622;
}


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.37624;
  _Ios_Iostate D.37625;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.37632 = __a.3 | __b.4;
  D.37629 = (_Ios_Iostate) D.37632;
  return D.37629;
}


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

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


sigc::slot<void, int>& sigc::slot<void, int>::operator=(const sigc::slot<void, int>&) (struct slot * const this, const struct slot & D.35408)
{
  const struct slot1 * D.37636;
  struct slot1 * D.37637;
  struct slot & D.37638;

  D.37636 = &D.35408->D.35348;
  D.37637 = &this->D.35348;
  sigc::slot1<void, int>::operator= (D.37637, D.37636);
  D.37638 = this;
  return D.37638;
}


sigc::slot1<T_return, T_arg1>& sigc::slot1<T_return, T_arg1>::operator=(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = int] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.37640;
  struct slot_base * D.37641;
  struct slot1 & D.37642;

  D.37640 = &src->D.35306;
  D.37641 = &this->D.35306;
  sigc::slot_base::operator= (D.37641, D.37640);
  D.37642 = this;
  return D.37642;
}


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 = {anonymous}::foo; T_return = void; T_arg1 = char] (struct slot * const this, const struct foo & _A_func)
{
  struct slot1 * D.37644;

  D.37644 = &this->D.35517;
  sigc::slot1<void, char>::slot1<{anonymous}::foo> (D.37644, _A_func);
  try
    {

    }
  catch
    {
      D.37644 = &this->D.35517;
      sigc::slot1<void, char>::~slot1 (D.37644);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = {anonymous}::foo; T_return = void; T_arg1 = char] (struct slot1 * const this, const struct foo & _A_func)
{
  void * D.36568;
  struct slot_base * D.37645;
  struct rep_type * D.37646;
  void * (*<T1711>) (void *) D.37647;

  D.36568 = operator new (56);
  try
    {
      sigc::internal::typed_slot_rep<{anonymous}::foo>::typed_slot_rep (D.36568, _A_func);
    }
  catch
    {
      operator delete (D.36568);
    }
  D.37645 = &this->D.35475;
  sigc::slot_base::slot_base (D.37645, D.36568);
  try
    {
      D.37646 = this->D.35475.rep_;
      D.37647 = sigc::internal::slot_call1<{anonymous}::foo, void, char>::address ();
      D.37646->call_ = D.37647;
    }
  catch
    {
      D.37645 = &this->D.35475;
      sigc::slot_base::~slot_base (D.37645);
    }
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = {anonymous}::foo; T_return = void; T_arg1 = char; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.37650;

  D.37650 = call_it;
  return D.37650;
}


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 = {anonymous}::foo; T_return = void; T_arg1 = char; typename sigc::type_trait<T_arg3>::take = const char&] (struct slot_rep * rep, const char & a_1)
{
  struct adaptor_type * D.37652;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.37652 = &typed_rep->functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<const char&> (D.37652, a_1);
  return;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const char&; T_functor = {anonymous}::foo; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, const char & _A_arg1)
{
  char D.37654;
  int D.37655;
  struct foo * D.37656;

  D.37654 = *_A_arg1;
  D.37655 = (int) D.37654;
  D.37656 = &this->functor_;
  {anonymous}::foo::operator() (D.37656, D.37655);
  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 = char; sigc::slot1<T_return, T_arg1>::arg1_type_ = const char&] (const struct slot1 * const this, const char & _A_a1)
{
  bool retval.5;
  bool iftmp.6;
  const struct slot_base * D.37662;
  bool D.37663;
  bool D.37664;
  bool D.37666;
  bool D.37667;
  struct rep_type * D.37671;
  void * (*<T1711>) (void *) D.37672;

  D.37662 = &this->D.35475;
  D.37663 = sigc::slot_base::empty (D.37662);
  D.37664 = ~D.37663;
  if (D.37664 != 0) goto <D.37665>; else goto <D.37660>;
  <D.37665>:
  D.37662 = &this->D.35475;
  D.37666 = sigc::slot_base::blocked (D.37662);
  D.37667 = ~D.37666;
  if (D.37667 != 0) goto <D.37668>; else goto <D.37660>;
  <D.37668>:
  iftmp.6 = 1;
  goto <D.37661>;
  <D.37660>:
  iftmp.6 = 0;
  <D.37661>:
  retval.5 = iftmp.6;
  if (retval.5 != 0) goto <D.37669>; else goto <D.37670>;
  <D.37669>:
  D.37671 = this->D.35475.rep_;
  D.37672 = D.37671->call_;
  D.37671 = this->D.35475.rep_;
  D.37672 (D.37671, _A_a1);
  return;
  <D.37670>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.37674;
  bool iftmp.7;
  struct rep_type * D.37679;
  void * (*<T1711>) (void *) D.37681;

  D.37679 = this->rep_;
  if (D.37679 == 0B) goto <D.37676>; else goto <D.37680>;
  <D.37680>:
  D.37679 = this->rep_;
  D.37681 = D.37679->call_;
  if (D.37681 == 0B) goto <D.37676>; else goto <D.37677>;
  <D.37676>:
  iftmp.7 = 1;
  goto <D.37678>;
  <D.37677>:
  iftmp.7 = 0;
  <D.37678>:
  D.37674 = iftmp.7;
  return D.37674;
}


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

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


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 = {anonymous}::foo; T_return = void; T_arg1 = std::basic_string<char>&] (struct slot * const this, const struct foo & _A_func)
{
  struct slot1 * D.37685;

  D.37685 = &this->D.35676;
  sigc::slot1<void, std::basic_string<char>&>::slot1<{anonymous}::foo> (D.37685, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = {anonymous}::foo; T_return = void; T_arg1 = std::basic_string<char>&] (struct slot1 * const this, const struct foo & _A_func)
{
  void * D.36583;
  struct slot_base * D.37686;
  struct rep_type * D.37687;
  void * (*<T1711>) (void *) D.37688;

  D.36583 = operator new (56);
  try
    {
      sigc::internal::typed_slot_rep<{anonymous}::foo>::typed_slot_rep (D.36583, _A_func);
    }
  catch
    {
      operator delete (D.36583);
    }
  D.37686 = &this->D.35634;
  sigc::slot_base::slot_base (D.37686, D.36583);
  try
    {
      D.37687 = this->D.35634.rep_;
      D.37688 = sigc::internal::slot_call1<{anonymous}::foo, void, std::basic_string<char>&>::address ();
      D.37687->call_ = D.37688;
    }
  catch
    {
      D.37686 = &this->D.35634;
      sigc::slot_base::~slot_base (D.37686);
    }
}


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

  D.37691 = call_it;
  return D.37691;
}


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 = {anonymous}::foo; T_return = void; T_arg1 = std::basic_string<char>&; typename sigc::type_trait<T_arg3>::take = std::basic_string<char>&] (struct slot_rep * rep, struct basic_string & a_1)
{
  struct adaptor_type * D.37693;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.37693 = &typed_rep->functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<std::basic_string<char>&> (D.37693, 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 = std::basic_string<char>&; T_functor = {anonymous}::foo; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, struct basic_string & _A_arg1)
{
  struct foo * D.37695;

  D.37695 = &this->functor_;
  {anonymous}::foo::operator() (D.37695, _A_arg1);
  return;
}


void {anonymous}::foo::operator()(std::string&) (struct foo * const this, struct string & str)
{
  struct basic_ostream & D.37697;
  struct basic_ostream & D.37698;

  D.37697 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(string \'");
  D.37698 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.37697, str);
  std::operator<< <std::char_traits<char> > (D.37698, "\') ");
  std::basic_string<char>::operator= (str, "foo was here");
}


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

  D.37701 = std::basic_string<char>::assign (this, __s);
  return D.37701;
}


std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::assign(const _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, const char * __s)
{
  struct basic_string & D.37704;
  long unsigned int D.37705;

  D.37705 = std::char_traits<char>::length (__s);
  D.37704 = std::basic_string<char>::assign (this, __s, D.37705);
  return D.37704;
}


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

  D.37708 = &this->D.35676;
  sigc::slot1<void, std::basic_string<char>&>::slot1 (D.37708);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1() [with T_return = void; T_arg1 = std::basic_string<char>&] (struct slot1 * const this)
{
  struct slot_base * D.37709;

  D.37709 = &this->D.35634;
  sigc::slot_base::slot_base (D.37709);
  try
    {

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


sigc::slot<void, std::basic_string<char>&>& sigc::slot<void, std::basic_string<char>&>::operator=(const sigc::slot<void, std::basic_string<char>&>&) (struct slot * const this, const struct slot & D.35738)
{
  const struct slot1 * D.37710;
  struct slot1 * D.37711;
  struct slot & D.37712;

  D.37710 = &D.35738->D.35676;
  D.37711 = &this->D.35676;
  sigc::slot1<void, std::basic_string<char>&>::operator= (D.37711, D.37710);
  D.37712 = this;
  return D.37712;
}


sigc::slot1<T_return, T_arg1>& sigc::slot1<T_return, T_arg1>::operator=(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = std::basic_string<char>&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.37714;
  struct slot_base * D.37715;
  struct slot1 & D.37716;

  D.37714 = &src->D.35634;
  D.37715 = &this->D.35634;
  sigc::slot_base::operator= (D.37715, D.37714);
  D.37716 = this;
  return D.37716;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = std::basic_string<char>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = std::basic_string<char>&] (const struct slot1 * const this, struct basic_string & _A_a1)
{
  bool retval.8;
  bool iftmp.9;
  const struct slot_base * D.37722;
  bool D.37723;
  bool D.37724;
  bool D.37726;
  bool D.37727;
  struct rep_type * D.37731;
  void * (*<T1711>) (void *) D.37732;

  D.37722 = &this->D.35634;
  D.37723 = sigc::slot_base::empty (D.37722);
  D.37724 = ~D.37723;
  if (D.37724 != 0) goto <D.37725>; else goto <D.37720>;
  <D.37725>:
  D.37722 = &this->D.35634;
  D.37726 = sigc::slot_base::blocked (D.37722);
  D.37727 = ~D.37726;
  if (D.37727 != 0) goto <D.37728>; else goto <D.37720>;
  <D.37728>:
  iftmp.9 = 1;
  goto <D.37721>;
  <D.37720>:
  iftmp.9 = 0;
  <D.37721>:
  retval.8 = iftmp.9;
  if (retval.8 != 0) goto <D.37729>; else goto <D.37730>;
  <D.37729>:
  D.37731 = this->D.35634.rep_;
  D.37732 = D.37731->call_;
  D.37731 = this->D.35634.rep_;
  D.37732 (D.37731, _A_a1);
  return;
  <D.37730>:
  return;
}


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.37734;
  long unsigned int D.37735;
  long int D.37736;
  const char * D.37737;

  D.37735 = std::basic_string<char>::size (__str);
  D.37736 = (long int) D.37735;
  D.37737 = std::basic_string<char>::data (__str);
  D.37734 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.37737, D.37736);
  return D.37734;
}


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.37742;
  struct _Rep * D.37743;

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


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.37746;
  char * D.37747;

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


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

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


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

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


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 = int] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.37755;

  D.37755 = &this->D.35348;
  sigc::slot1<void, int>::slot1 (D.37755, src);
  try
    {

    }
  catch
    {
      D.37755 = &this->D.35348;
      sigc::slot1<void, int>::~slot1 (D.37755);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = int] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.37756;
  struct slot_base * D.37757;

  D.37756 = &src->D.35306;
  D.37757 = &this->D.35306;
  sigc::slot_base::slot_base (D.37757, D.37756);
  try
    {

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


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const int&] (const struct slot1 * const this, const int & _A_a1)
{
  bool retval.10;
  bool iftmp.11;
  const struct slot_base * D.37762;
  bool D.37763;
  bool D.37764;
  bool D.37766;
  bool D.37767;
  struct rep_type * D.37771;
  void * (*<T1711>) (void *) D.37772;

  D.37762 = &this->D.35306;
  D.37763 = sigc::slot_base::empty (D.37762);
  D.37764 = ~D.37763;
  if (D.37764 != 0) goto <D.37765>; else goto <D.37760>;
  <D.37765>:
  D.37762 = &this->D.35306;
  D.37766 = sigc::slot_base::blocked (D.37762);
  D.37767 = ~D.37766;
  if (D.37767 != 0) goto <D.37768>; else goto <D.37760>;
  <D.37768>:
  iftmp.11 = 1;
  goto <D.37761>;
  <D.37760>:
  iftmp.11 = 0;
  <D.37761>:
  retval.10 = iftmp.11;
  if (retval.10 != 0) goto <D.37769>; else goto <D.37770>;
  <D.37769>:
  D.37771 = this->D.35306.rep_;
  D.37772 = D.37771->call_;
  D.37771 = this->D.35306.rep_;
  D.37772 (D.37771, _A_a1);
  return;
  <D.37770>:
  return;
}


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

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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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.35898;
  struct _Rep * D.37778;
  struct _Alloc_hider * D.37779;

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


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

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

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


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

  try
    {
      {

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


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.12;
  struct _Rep & D.37790;
  bool D.37791;
  long int D.37792;
  long int D.37793;
  bool retval.13;
  _Atomic_word * D.37797;
  int D.37798;

  D.37790 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.37791 = D.37790 != this;
  D.37792 = (long int) D.37791;
  D.37793 = __builtin_expect (D.37792, 0);
  retval.12 = D.37793 != 0;
  if (retval.12 != 0) goto <D.37794>; else goto <D.37795>;
  <D.37794>:
  D.37797 = &this->D.11865._M_refcount;
  D.37798 = __gnu_cxx::__exchange_and_add_dispatch (D.37797, -1);
  retval.13 = D.37798 <= 0;
  if (retval.13 != 0) goto <D.37799>; else goto <D.37800>;
  <D.37799>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.37801>;
  <D.37800>:
  <D.37801>:
  goto <D.37802>;
  <D.37795>:
  <D.37802>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.14;
  int D.37807;
  _Atomic_word D.37810;

  D.37807 = __gthread_active_p ();
  retval.14 = D.37807 != 0;
  if (retval.14 != 0) goto <D.37808>; else goto <D.37809>;
  <D.37808>:
  D.37810 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.37810;
  <D.37809>:
  D.37810 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.37810;
}


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

  D.37813 = __gthrw___pthread_key_create != 0B;
  D.37812 = (int) D.37813;
  return D.37812;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.37815;
  unsigned int __val.15;
  unsigned int D.37817;

  __val.15 = (unsigned int) __val;
  D.37817 = __atomic_fetch_add_4 (__mem, __val.15, 4);
  D.37815 = (_Atomic_word) D.37817;
  return D.37815;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.37819;
  int D.37820;
  _Atomic_word D.37821;
  _Atomic_word __result;

  __result = *__mem;
  D.37819 = *__mem;
  D.37820 = D.37819 + __val;
  *__mem = D.37820;
  D.37821 = __result;
  return D.37821;
}


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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37823 = &this->D.35676;
            sigc::slot1<void, std::basic_string<char>&>::~slot1 (D.37823);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35718>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37825 = &this->D.35634;
            sigc::slot_base::~slot_base (D.37825);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35713>:
}


sigc::slot<void, char>::~slot() (struct slot * const this)
{
  struct slot1 * D.37827;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37827 = &this->D.35517;
            sigc::slot1<void, char>::~slot1 (D.37827);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35559>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37829 = &this->D.35475;
            sigc::slot_base::~slot_base (D.37829);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35554>:
}


sigc::slot<void, int>::~slot() (struct slot * const this)
{
  struct slot1 * D.37831;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37831 = &this->D.35348;
            sigc::slot1<void, int>::~slot1 (D.37831);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35390>:
}


sigc::slot1<void, int>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.37833;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37833 = &this->D.35306;
            sigc::slot_base::~slot_base (D.37833);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35385>:
}


(static initializers for test_slot.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.37835>; else goto <D.37836>;
  <D.37835>:
  if (__priority == 65535) goto <D.37837>; else goto <D.37838>;
  <D.37837>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.37839>;
  <D.37838>:
  <D.37839>:
  goto <D.37840>;
  <D.37836>:
  <D.37840>:
}


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.16;
  const void * * D.37844;
  sizetype iftmp.17;
  int (*__vtbl_ptr_type) () * D.37849;
  int (*__vtbl_ptr_type) () * D.37850;
  long int D.37851;
  struct basic_ios * D.37853;
  int (*__vtbl_ptr_type) () * iftmp.18;
  struct __stringbuf_type * D.37858;
  const void * * iftmp.19;
  struct basic_ostream * D.37863;
  int D.37864;
  struct basic_ios * D.37867;
  int D.37869;

  {
    if (2 == 0) goto <D.37842>; else goto <D.37843>;
    <D.37842>:
    D.37844 = 0B;
    iftmp.16 = *D.37844;
    goto <D.37845>;
    <D.37843>:
    iftmp.16 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.37845>:
    this->D.22312._vptr.basic_ostream = iftmp.16;
    if (2 == 0) goto <D.37847>; else goto <D.37848>;
    <D.37847>:
    D.37849 = this->D.22312._vptr.basic_ostream;
    D.37850 = D.37849 + 18446744073709551592;
    D.37851 = MEM[(long int *)D.37850];
    iftmp.17 = (sizetype) D.37851;
    goto <D.37852>;
    <D.37848>:
    iftmp.17 = 88;
    <D.37852>:
    D.37853 = this + iftmp.17;
    if (2 == 0) goto <D.37855>; else goto <D.37856>;
    <D.37855>:
    iftmp.18 = MEM[(const void * *)0B + 24B];
    goto <D.37857>;
    <D.37856>:
    iftmp.18 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.37857>:
    D.37853->D.19008._vptr.ios_base = iftmp.18;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.37858 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.37858);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.37860>; else goto <D.37861>;
                <D.37860>:
                iftmp.19 = 8B;
                goto <D.37862>;
                <D.37861>:
                iftmp.19 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.37862>:
                D.37863 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.37863, iftmp.19);
              }
          }
        finally
          {
            D.37864 = 2;
            if (D.37864 != 0) goto <D.37865>; else goto <D.37866>;
            <D.37865>:
            D.37867 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.37867);
            goto <D.37868>;
            <D.37866>:
            <D.37868>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37431>:
  D.37869 = 0;
  if (D.37869 != 0) goto <D.37870>; else goto <D.37871>;
  <D.37870>:
  operator delete (this);
  goto <D.37872>;
  <D.37871>:
  <D.37872>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.37882;
  struct basic_streambuf * D.37883;
  int D.37884;

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

              }
            finally
              {
                D.37882 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.37882);
              }
          }
        finally
          {
            D.37883 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.37883);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35832>:
  D.37884 = 0;
  if (D.37884 != 0) goto <D.37885>; else goto <D.37886>;
  <D.37885>:
  operator delete (this);
  goto <D.37887>;
  <D.37886>:
  <D.37887>:
}


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

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

          }
        finally
          {
            D.37890 = &this->_M_buf_locale;
            std::locale::~locale (D.37890);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36018>:
  D.37891 = 0;
  if (D.37891 != 0) goto <D.37892>; else goto <D.37893>;
  <D.37892>:
  operator delete (this);
  goto <D.37894>;
  <D.37893>:
  <D.37894>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.35836>:
  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.20;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.37902;
  int (*__vtbl_ptr_type) () * D.37903;
  long int D.37904;
  struct basic_ios * D.37906;
  int (*__vtbl_ptr_type) () * iftmp.22;
  int D.37911;
  struct basic_ios * D.37914;
  int D.37916;

  {
    if (0 == 0) goto <D.37896>; else goto <D.37897>;
    <D.37896>:
    iftmp.20 = *__vtt_parm;
    goto <D.37898>;
    <D.37897>:
    iftmp.20 = &MEM[(void *)&_ZTVSo + 24B];
    <D.37898>:
    this->_vptr.basic_ostream = iftmp.20;
    if (0 == 0) goto <D.37900>; else goto <D.37901>;
    <D.37900>:
    D.37902 = this->_vptr.basic_ostream;
    D.37903 = D.37902 + 18446744073709551592;
    D.37904 = MEM[(long int *)D.37903];
    iftmp.21 = (sizetype) D.37904;
    goto <D.37905>;
    <D.37901>:
    iftmp.21 = 8;
    <D.37905>:
    D.37906 = this + iftmp.21;
    if (0 == 0) goto <D.37908>; else goto <D.37909>;
    <D.37908>:
    iftmp.22 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.37910>;
    <D.37909>:
    iftmp.22 = &MEM[(void *)&_ZTVSo + 64B];
    <D.37910>:
    D.37906->D.19008._vptr.ios_base = iftmp.22;
    try
      {
        try
          {

          }
        finally
          {
            D.37911 = 0;
            if (D.37911 != 0) goto <D.37912>; else goto <D.37913>;
            <D.37912>:
            D.37914 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.37914);
            goto <D.37915>;
            <D.37913>:
            <D.37915>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36003>:
  D.37916 = 0;
  if (D.37916 != 0) goto <D.37917>; else goto <D.37918>;
  <D.37917>:
  operator delete (this);
  goto <D.37919>;
  <D.37918>:
  <D.37919>:
}


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

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

          }
        finally
          {
            D.37921 = &this->D.19008;
            std::ios_base::~ios_base (D.37921);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35991>:
  D.37922 = 0;
  if (D.37922 != 0) goto <D.37923>; else goto <D.37924>;
  <D.37923>:
  operator delete (this);
  goto <D.37925>;
  <D.37924>:
  <D.37925>:
}


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.35995>:
  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.37929;
  const void * * iftmp.23;
  struct basic_ostream * D.37935;
  int (*__vtbl_ptr_type) () * iftmp.24;
  const void * * D.37939;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.37944;
  int (*__vtbl_ptr_type) () * D.37945;
  long int D.37946;
  struct basic_ios * D.37948;
  int (*__vtbl_ptr_type) () * iftmp.26;
  _Ios_Openmode D.37953;
  struct __stringbuf_type * D.37954;
  struct basic_streambuf * D.37955;
  sizetype iftmp.27;
  struct basic_ios * D.37960;
  const void * * iftmp.28;

  if (1 != 0) goto <D.37927>; else goto <D.37928>;
  <D.37927>:
  D.37929 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.37929);
  goto <D.37930>;
  <D.37928>:
  <D.37930>:
  try
    {
      if (1 == 0) goto <D.37932>; else goto <D.37933>;
      <D.37932>:
      iftmp.23 = 8B;
      goto <D.37934>;
      <D.37933>:
      iftmp.23 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.37934>:
      D.37935 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.37935, iftmp.23);
      try
        {
          if (1 == 0) goto <D.37937>; else goto <D.37938>;
          <D.37937>:
          D.37939 = 0B;
          iftmp.24 = *D.37939;
          goto <D.37940>;
          <D.37938>:
          iftmp.24 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.37940>:
          this->D.22312._vptr.basic_ostream = iftmp.24;
          if (1 == 0) goto <D.37942>; else goto <D.37943>;
          <D.37942>:
          D.37944 = this->D.22312._vptr.basic_ostream;
          D.37945 = D.37944 + 18446744073709551592;
          D.37946 = MEM[(long int *)D.37945];
          iftmp.25 = (sizetype) D.37946;
          goto <D.37947>;
          <D.37943>:
          iftmp.25 = 88;
          <D.37947>:
          D.37948 = this + iftmp.25;
          if (1 == 0) goto <D.37950>; else goto <D.37951>;
          <D.37950>:
          iftmp.26 = MEM[(const void * *)0B + 24B];
          goto <D.37952>;
          <D.37951>:
          iftmp.26 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.37952>:
          D.37948->D.19008._vptr.ios_base = iftmp.26;
          D.37953 = std::operator| (__mode, 16);
          D.37954 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.37954, D.37953);
          try
            {
              D.37955 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.37957>; else goto <D.37958>;
              <D.37957>:
              D.37944 = this->D.22312._vptr.basic_ostream;
              D.37945 = D.37944 + 18446744073709551592;
              D.37946 = MEM[(long int *)D.37945];
              iftmp.27 = (sizetype) D.37946;
              goto <D.37959>;
              <D.37958>:
              iftmp.27 = 88;
              <D.37959>:
              D.37960 = this + iftmp.27;
              std::basic_ios<char>::init (D.37960, D.37955);
            }
          catch
            {
              D.37954 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.37954);
            }
        }
      catch
        {
          if (1 == 0) goto <D.37962>; else goto <D.37963>;
          <D.37962>:
          iftmp.28 = 8B;
          goto <D.37964>;
          <D.37963>:
          iftmp.28 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.37964>:
          D.37935 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.37935, iftmp.28);
        }
    }
  catch
    {
      if (1 != 0) goto <D.37965>; else goto <D.37966>;
      <D.37965>:
      D.37929 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.37929);
      goto <D.37967>;
      <D.37966>:
      <D.37967>:
    }
}


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

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


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.37974;
  int (*__vtbl_ptr_type) () * iftmp.29;
  sizetype iftmp.30;
  int (*__vtbl_ptr_type) () * D.37983;
  int (*__vtbl_ptr_type) () * D.37984;
  long int D.37985;
  struct basic_ios * D.37987;
  int (*__vtbl_ptr_type) () * iftmp.31;
  sizetype iftmp.32;
  struct basic_ios * D.37996;

  if (0 != 0) goto <D.37972>; else goto <D.37973>;
  <D.37972>:
  D.37974 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.37974);
  goto <D.37975>;
  <D.37973>:
  <D.37975>:
  try
    {
      if (0 == 0) goto <D.37977>; else goto <D.37978>;
      <D.37977>:
      iftmp.29 = *__vtt_parm;
      goto <D.37979>;
      <D.37978>:
      iftmp.29 = &MEM[(void *)&_ZTVSo + 24B];
      <D.37979>:
      this->_vptr.basic_ostream = iftmp.29;
      if (0 == 0) goto <D.37981>; else goto <D.37982>;
      <D.37981>:
      D.37983 = this->_vptr.basic_ostream;
      D.37984 = D.37983 + 18446744073709551592;
      D.37985 = MEM[(long int *)D.37984];
      iftmp.30 = (sizetype) D.37985;
      goto <D.37986>;
      <D.37982>:
      iftmp.30 = 8;
      <D.37986>:
      D.37987 = this + iftmp.30;
      if (0 == 0) goto <D.37989>; else goto <D.37990>;
      <D.37989>:
      iftmp.31 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.37991>;
      <D.37990>:
      iftmp.31 = &MEM[(void *)&_ZTVSo + 64B];
      <D.37991>:
      D.37987->D.19008._vptr.ios_base = iftmp.31;
      if (0 == 0) goto <D.37993>; else goto <D.37994>;
      <D.37993>:
      D.37983 = this->_vptr.basic_ostream;
      D.37984 = D.37983 + 18446744073709551592;
      D.37985 = MEM[(long int *)D.37984];
      iftmp.32 = (sizetype) D.37985;
      goto <D.37995>;
      <D.37994>:
      iftmp.32 = 8;
      <D.37995>:
      D.37996 = this + iftmp.32;
      std::basic_ios<char>::init (D.37996, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.37997>; else goto <D.37998>;
      <D.37997>:
      D.37974 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.37974);
      goto <D.37999>;
      <D.37998>:
      <D.37999>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.38001;
  int __a.33;
  int __b.34;
  int D.38004;

  __a.33 = (int) __a;
  __b.34 = (int) __b;
  D.38004 = __a.33 | __b.34;
  D.38001 = (_Ios_Openmode) D.38004;
  return D.38001;
}


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.38006;
  struct __string_type * D.38007;

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

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


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

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

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


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.36658;
  struct _Rep & D.38010;
  char * D.38011;
  struct _Alloc_hider * D.38012;

  std::allocator<char>::allocator (&D.36658);
  try
    {
      D.38010 = std::basic_string<char>::_S_empty_rep ();
      D.38011 = std::basic_string<char>::_Rep::_M_refdata (D.38010);
      D.38012 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.38012, D.38011, &D.36658);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.36658);
      D.36658 = {CLOBBER};
    }
  try
    {

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


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

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


_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.38018;
  void * D.38019;

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


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


