int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.36844;
  int D.36847;
  int iftmp.1;
  bool D.36849;
  const struct slot D.35528;
  struct bound_mem_functor0 D.35515;
  struct 
{
  void my_class::<T6628> (struct my_class *) * __pfn;
  long int __delta;
} D.36853;
  const struct string D.35532;
  struct allocator D.35531;
  const struct string D.35535;
  struct allocator D.35534;
  int iftmp.2;
  bool D.36855;

  {
    struct TestUtilities * util;
    struct slot sl;

    try
      {
        util = TestUtilities::get_instance ();
        D.36844 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.36844;
        if (retval.0 != 0) goto <D.36845>; else goto <D.36846>;
        <D.36845>:
        D.36849 = TestUtilities::get_result_and_delete_instance ();
        if (D.36849 != 0) goto <D.36850>; else goto <D.36851>;
        <D.36850>:
        iftmp.1 = 0;
        goto <D.36852>;
        <D.36851>:
        iftmp.1 = 1;
        <D.36852>:
        D.36847 = iftmp.1;
        return D.36847;
        <D.36846>:
        sigc::slot<void>::slot (&sl);
        try
          {
            {
              struct my_class t;

              try
                {
                  {anonymous}::my_class::my_class (&t);
                  try
                    {
                      t.i = 10;
                      D.36853.__pfn = foo;
                      D.36853.__delta = 0;
                      D.35515 = sigc::mem_fun0<void, {anonymous}::my_class, {anonymous}::my_class> (&t, D.36853); [return slot optimization]
                      try
                        {
                          sigc::slot<void>::slot<sigc::bound_mem_functor0<void, {anonymous}::my_class> > (&D.35528, &D.35515);
                          try
                            {
                              sigc::slot<void>::operator= (&sl, &D.35528);
                            }
                          finally
                            {
                              sigc::slot<void>::~slot (&D.35528);
                              D.35528 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.35515 = {CLOBBER};
                        }
                      sigc::slot0<void>::operator() (&sl.D.35332);
                      std::allocator<char>::allocator (&D.35531);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.35532, "10", &D.35531);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.35532);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.35532);
                              D.35532 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.35531);
                          D.35531 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::my_class::~my_class (&t);
                    }
                }
              finally
                {
                  t = {CLOBBER};
                }
            }
            sigc::slot0<void>::operator() (&sl.D.35332);
            std::allocator<char>::allocator (&D.35534);
            try
              {
                std::basic_string<char>::basic_string (&D.35535, "", &D.35534);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.35535);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.35535);
                    D.35535 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.35534);
                D.35534 = {CLOBBER};
              }
            D.36855 = TestUtilities::get_result_and_delete_instance ();
            if (D.36855 != 0) goto <D.36856>; else goto <D.36857>;
            <D.36856>:
            iftmp.2 = 0;
            goto <D.36858>;
            <D.36857>:
            iftmp.2 = 1;
            <D.36858>:
            D.36847 = iftmp.2;
            return D.36847;
          }
        finally
          {
            sigc::slot<void>::~slot (&sl);
          }
      }
    finally
      {
        sl = {CLOBBER};
      }
  }
  D.36847 = 0;
  return D.36847;
}


void {anonymous}::my_class::foo() (struct my_class * const this)
{
  int D.36877;

  D.36877 = this->i;
  std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.36877);
}


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

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

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


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

  D.36879 = &this->D.35290;
  sigc::slot_base::slot_base (D.36879);
  try
    {

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


{anonymous}::my_class::my_class() (struct my_class * const this)
{
  struct trackable * D.36880;

  D.36880 = &this->D.35231;
  sigc::trackable::trackable (D.36880);
  try
    {

    }
  catch
    {
      D.36880 = &this->D.35231;
      sigc::trackable::~trackable (D.36880);
    }
}


sigc::bound_mem_functor0<T_return, T_obj> sigc::mem_fun0(T_obj*, T_return (T_obj2::*)()) [with T_return = void; T_obj = {anonymous}::my_class; T_obj2 = {anonymous}::my_class] (struct my_class * _A_obj, struct 
{
  void my_class::<T6628> (struct my_class *) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor0<void, {anonymous}::my_class>::bound_mem_functor0 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor0<T_return, T_obj>::bound_mem_functor0(T_obj*, sigc::bound_mem_functor0<T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::my_class; sigc::bound_mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::my_class::*)()] (struct bound_mem_functor0 * const this, struct my_class * _A_obj, struct function_type _A_func)
{
  struct mem_functor0 * D.36883;
  struct limit_reference * D.36884;

  D.36883 = &this->D.35512;
  sigc::mem_functor0<void, {anonymous}::my_class>::mem_functor0 (D.36883, _A_func);
  D.36884 = &this->obj_;
  sigc::limit_reference<{anonymous}::my_class, true>::limit_reference (D.36884, _A_obj);
}


sigc::mem_functor0<T_return, T_obj>::mem_functor0(sigc::mem_functor0<T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::my_class; sigc::mem_functor0<T_return, T_obj>::function_type = void ({anonymous}::my_class::*)()] (struct mem_functor0 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


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

}


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

  D.36885 = &_A_target->D.35231;
  this->visited = D.36885;
  this->invoked = _A_target;
}


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::bound_mem_functor0<void, {anonymous}::my_class>; T_return = void] (struct slot * const this, const struct bound_mem_functor0 & _A_func)
{
  struct slot0 * D.36886;

  D.36886 = &this->D.35332;
  sigc::slot0<void>::slot0<sigc::bound_mem_functor0<void, {anonymous}::my_class> > (D.36886, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>; T_return = void] (struct slot0 * const this, const struct bound_mem_functor0 & _A_func)
{
  void * D.36278;
  struct slot_base * D.36887;
  struct rep_type * D.36888;
  void * (*<T1711>) (void *) D.36889;

  D.36278 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor0<void, {anonymous}::my_class> >::typed_slot_rep (D.36278, _A_func);
    }
  catch
    {
      operator delete (D.36278);
    }
  D.36887 = &this->D.35290;
  sigc::slot_base::slot_base (D.36887, D.36278);
  try
    {
      D.36888 = this->D.35290.rep_;
      D.36889 = sigc::internal::slot_call0<sigc::bound_mem_functor0<void, {anonymous}::my_class>, void>::address ();
      D.36888->call_ = D.36889;
    }
  catch
    {
      D.36887 = &this->D.35290;
      sigc::slot_base::~slot_base (D.36887);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>] (struct typed_slot_rep * const this, const struct bound_mem_functor0 & functor)
{
  struct slot_rep * D.36892;
  struct adaptor_type * D.36893;
  struct slot_do_bind D.36438;

  D.36892 = &this->D.36267;
  sigc::internal::slot_rep::slot_rep (D.36892, 0B, destroy, dup);
  try
    {
      D.36893 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> >::adaptor_functor (D.36893, functor);
      D.36893 = &this->functor_;
      D.36892 = &this->D.36267;
      sigc::internal::slot_do_bind::slot_do_bind (&D.36438, D.36892);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> > > (&D.36438, D.36893);
        }
      finally
        {
          D.36438 = {CLOBBER};
        }
    }
  catch
    {
      D.36892 = &this->D.36267;
      sigc::internal::slot_rep::~slot_rep (D.36892);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>] (void * data)
{
  void * D.36896;
  void * D.36521;
  struct slot_rep * a_rep;

  a_rep = data;
  D.36521 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor0<void, {anonymous}::my_class> >::typed_slot_rep (D.36521, a_rep);
    }
  catch
    {
      operator delete (D.36521);
    }
  D.36896 = D.36521;
  return D.36896;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.36900;
  struct slot_rep * D.36901;
  struct adaptor_type * D.36902;
  struct slot_do_bind D.36646;

  D.36900 = cl->D.36267.call_;
  D.36901 = &this->D.36267;
  sigc::internal::slot_rep::slot_rep (D.36901, D.36900, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.36902 = &this->functor_;
      D.36901 = &this->D.36267;
      sigc::internal::slot_do_bind::slot_do_bind (&D.36646, D.36901);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> > > (&D.36646, D.36902);
        }
      finally
        {
          D.36646 = {CLOBBER};
        }
    }
  catch
    {
      D.36901 = &this->D.36267;
      sigc::internal::slot_rep::~slot_rep (D.36901);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>] (void * data)
{
  struct adaptor_type * D.36905;
  struct slot_do_unbind D.36506;
  void * D.36906;
  struct self * self_;

  self_ = data;
  self_->D.36267.call_ = 0B;
  self_->D.36267.destroy_ = 0B;
  D.36905 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.36506, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> > > (&D.36506, D.36905);
    }
  finally
    {
      D.36506 = {CLOBBER};
    }
  D.36906 = 0B;
  return D.36906;
}


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

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


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


static void sigc::visitor<sigc::bound_mem_functor0<T_return, T_obj> >::do_visit_each(const T_action&, const sigc::bound_mem_functor0<T_return, T_obj>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_obj = {anonymous}::my_class] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.36911;

  D.36911 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<{anonymous}::my_class, true> > (_A_action, D.36911);
}


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


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

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


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

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


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


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


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


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

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


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

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


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

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


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>] (struct adaptor_functor * const this, const struct bound_mem_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::bound_mem_functor0<void, {anonymous}::my_class> >] (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::bound_mem_functor0<void, {anonymous}::my_class> > > (&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::bound_mem_functor0<void, {anonymous}::my_class> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> > >::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::bound_mem_functor0<void, {anonymous}::my_class>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor0 * D.36919;

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


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


static void sigc::visitor<sigc::bound_mem_functor0<T_return, T_obj> >::do_visit_each(const T_action&, const sigc::bound_mem_functor0<T_return, T_obj>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_obj = {anonymous}::my_class] (const struct limit_derived_target & _A_action, const struct bound_mem_functor0 & _A_target)
{
  const struct limit_reference * D.36920;

  D.36920 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<{anonymous}::my_class, true> > (_A_action, D.36920);
}


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


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

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


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


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


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


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

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


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

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


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

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


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

  D.36927 = this->destroy_;
  if (D.36927 != 0B) goto <D.36928>; else goto <D.36929>;
  <D.36928>:
  D.36927 = this->destroy_;
  D.36927 (this);
  goto <D.36930>;
  <D.36929>:
  <D.36930>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.36931;

  D.36931 = call_it;
  return D.36931;
}


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

  typed_rep = rep;
  D.36933 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor0<void, {anonymous}::my_class> >::operator() (D.36933);
  return;
}


sigc::adaptor_functor<T_functor>::result_type sigc::adaptor_functor<T_functor>::operator()() const [with T_functor = sigc::bound_mem_functor0<void, {anonymous}::my_class>; sigc::adaptor_functor<T_functor>::result_type = void] (const struct adaptor_functor * const this)
{
  struct bound_mem_functor0 * D.36935;

  D.36935 = &this->functor_;
  sigc::bound_mem_functor0<void, {anonymous}::my_class>::operator() (D.36935);
  return;
}


T_return sigc::bound_mem_functor0<T_return, T_obj>::operator()() const [with T_return = void; T_obj = {anonymous}::my_class] (const struct bound_mem_functor0 * const this)
{
  const struct limit_reference * D.36937;
  struct my_class & D.36938;
  void my_class::<T6628> (struct my_class *) * iftmp.3;
  void my_class::<T6628> (struct my_class *) * D.36940;
  long int D.36941;
  long int D.36942;
  long int D.36946;
  sizetype D.36947;
  struct my_class * D.36948;
  int (*__vtbl_ptr_type) () * D.36949;
  long int D.36950;
  sizetype D.36951;
  int (*__vtbl_ptr_type) () * D.36952;

  D.36937 = &this->obj_;
  D.36938 = sigc::limit_reference<{anonymous}::my_class, true>::invoke (D.36937);
  D.36940 = this->D.35512.func_ptr_.__pfn;
  D.36941 = (long int) D.36940;
  D.36942 = D.36941 & 1;
  if (D.36942 == 0) goto <D.36943>; else goto <D.36944>;
  <D.36943>:
  iftmp.3 = this->D.35512.func_ptr_.__pfn;
  goto <D.36945>;
  <D.36944>:
  D.36946 = this->D.35512.func_ptr_.__delta;
  D.36947 = (sizetype) D.36946;
  D.36948 = D.36938 + D.36947;
  D.36949 = MEM[(int (*__vtbl_ptr_type) () * *)D.36948];
  D.36940 = this->D.35512.func_ptr_.__pfn;
  D.36941 = (long int) D.36940;
  D.36950 = D.36941 + -1;
  D.36951 = (sizetype) D.36950;
  D.36952 = D.36949 + D.36951;
  iftmp.3 = *D.36952;
  <D.36945>:
  D.36946 = this->D.35512.func_ptr_.__delta;
  D.36947 = (sizetype) D.36946;
  D.36948 = D.36938 + D.36947;
  iftmp.3 (D.36948);
  return;
}


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

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


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.35517)
{
  const struct slot0 * D.36956;
  struct slot0 * D.36957;
  struct slot & D.36958;

  D.36956 = &D.35517->D.35332;
  D.36957 = &this->D.35332;
  sigc::slot0<void>::operator= (D.36957, D.36956);
  D.36958 = this;
  return D.36958;
}


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.36960;
  struct slot_base * D.36961;
  struct slot0 & D.36962;

  D.36960 = &src->D.35290;
  D.36961 = &this->D.35290;
  sigc::slot_base::operator= (D.36961, D.36960);
  D.36962 = this;
  return D.36962;
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.4;
  bool iftmp.5;
  const struct slot_base * D.36968;
  bool D.36969;
  bool D.36970;
  bool D.36972;
  bool D.36973;
  struct rep_type * D.36977;
  void * (*<T1711>) (void *) D.36978;

  D.36968 = &this->D.35290;
  D.36969 = sigc::slot_base::empty (D.36968);
  D.36970 = ~D.36969;
  if (D.36970 != 0) goto <D.36971>; else goto <D.36966>;
  <D.36971>:
  D.36968 = &this->D.35290;
  D.36972 = sigc::slot_base::blocked (D.36968);
  D.36973 = ~D.36972;
  if (D.36973 != 0) goto <D.36974>; else goto <D.36966>;
  <D.36974>:
  iftmp.5 = 1;
  goto <D.36967>;
  <D.36966>:
  iftmp.5 = 0;
  <D.36967>:
  retval.4 = iftmp.5;
  if (retval.4 != 0) goto <D.36975>; else goto <D.36976>;
  <D.36975>:
  D.36977 = this->D.35290.rep_;
  D.36978 = D.36977->call_;
  D.36977 = this->D.35290.rep_;
  D.36978 (D.36977);
  return;
  <D.36976>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.36980;
  bool iftmp.6;
  struct rep_type * D.36985;
  void * (*<T1711>) (void *) D.36987;

  D.36985 = this->rep_;
  if (D.36985 == 0B) goto <D.36982>; else goto <D.36986>;
  <D.36986>:
  D.36985 = this->rep_;
  D.36987 = D.36985->call_;
  if (D.36987 == 0B) goto <D.36982>; else goto <D.36983>;
  <D.36982>:
  iftmp.6 = 1;
  goto <D.36984>;
  <D.36983>:
  iftmp.6 = 0;
  <D.36984>:
  D.36980 = iftmp.6;
  return D.36980;
}


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

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


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

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

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


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

  try
    {
      {

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


{anonymous}::my_class::~my_class() (struct my_class * const this)
{
  struct trackable * D.36993;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.36993 = &this->D.35231;
            sigc::trackable::~trackable (D.36993);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35398>:
}


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.35685;
  struct _Rep * D.36995;
  struct _Alloc_hider * D.36996;

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


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

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

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


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

  try
    {
      {

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


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.37006;
  char * D.37007;

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


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

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


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.7;
  struct _Rep & D.37013;
  bool D.37014;
  long int D.37015;
  long int D.37016;
  bool retval.8;
  _Atomic_word * D.37020;
  int D.37021;

  D.37013 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.37014 = D.37013 != this;
  D.37015 = (long int) D.37014;
  D.37016 = __builtin_expect (D.37015, 0);
  retval.7 = D.37016 != 0;
  if (retval.7 != 0) goto <D.37017>; else goto <D.37018>;
  <D.37017>:
  D.37020 = &this->D.11865._M_refcount;
  D.37021 = __gnu_cxx::__exchange_and_add_dispatch (D.37020, -1);
  retval.8 = D.37021 <= 0;
  if (retval.8 != 0) goto <D.37022>; else goto <D.37023>;
  <D.37022>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.37024>;
  <D.37023>:
  <D.37024>:
  goto <D.37025>;
  <D.37018>:
  <D.37025>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.9;
  int D.37030;
  _Atomic_word D.37033;

  D.37030 = __gthread_active_p ();
  retval.9 = D.37030 != 0;
  if (retval.9 != 0) goto <D.37031>; else goto <D.37032>;
  <D.37031>:
  D.37033 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.37033;
  <D.37032>:
  D.37033 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.37033;
}


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

  D.37036 = __gthrw___pthread_key_create != 0B;
  D.37035 = (int) D.37036;
  return D.37035;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.37038;
  unsigned int __val.10;
  unsigned int D.37040;

  __val.10 = (unsigned int) __val;
  D.37040 = __atomic_fetch_add_4 (__mem, __val.10, 4);
  D.37038 = (_Atomic_word) D.37040;
  return D.37038;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.37042;
  int D.37043;
  _Atomic_word D.37044;
  _Atomic_word __result;

  __result = *__mem;
  D.37042 = *__mem;
  D.37043 = D.37042 + __val;
  *__mem = D.37043;
  D.37044 = __result;
  return D.37044;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37048 = &this->D.35332;
            sigc::slot0<void>::~slot0 (D.37048);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35363>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.37050 = &this->D.35290;
            sigc::slot_base::~slot_base (D.37050);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35358>:
}


(static initializers for test_trackable.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.37052>; else goto <D.37053>;
  <D.37052>:
  if (__priority == 65535) goto <D.37054>; else goto <D.37055>;
  <D.37054>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.37056>;
  <D.37055>:
  <D.37056>:
  goto <D.37057>;
  <D.37053>:
  <D.37057>:
}


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.11;
  const void * * D.37061;
  sizetype iftmp.12;
  int (*__vtbl_ptr_type) () * D.37066;
  int (*__vtbl_ptr_type) () * D.37067;
  long int D.37068;
  struct basic_ios * D.37070;
  int (*__vtbl_ptr_type) () * iftmp.13;
  struct __stringbuf_type * D.37075;
  const void * * iftmp.14;
  struct basic_ostream * D.37080;
  int D.37081;
  struct basic_ios * D.37084;
  int D.37086;

  {
    if (2 == 0) goto <D.37059>; else goto <D.37060>;
    <D.37059>:
    D.37061 = 0B;
    iftmp.11 = *D.37061;
    goto <D.37062>;
    <D.37060>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.37062>:
    this->D.22312._vptr.basic_ostream = iftmp.11;
    if (2 == 0) goto <D.37064>; else goto <D.37065>;
    <D.37064>:
    D.37066 = this->D.22312._vptr.basic_ostream;
    D.37067 = D.37066 + 18446744073709551592;
    D.37068 = MEM[(long int *)D.37067];
    iftmp.12 = (sizetype) D.37068;
    goto <D.37069>;
    <D.37065>:
    iftmp.12 = 88;
    <D.37069>:
    D.37070 = this + iftmp.12;
    if (2 == 0) goto <D.37072>; else goto <D.37073>;
    <D.37072>:
    iftmp.13 = MEM[(const void * *)0B + 24B];
    goto <D.37074>;
    <D.37073>:
    iftmp.13 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.37074>:
    D.37070->D.19008._vptr.ios_base = iftmp.13;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.37075 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.37075);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.37077>; else goto <D.37078>;
                <D.37077>:
                iftmp.14 = 8B;
                goto <D.37079>;
                <D.37078>:
                iftmp.14 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.37079>:
                D.37080 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.37080, iftmp.14);
              }
          }
        finally
          {
            D.37081 = 2;
            if (D.37081 != 0) goto <D.37082>; else goto <D.37083>;
            <D.37082>:
            D.37084 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.37084);
            goto <D.37085>;
            <D.37083>:
            <D.37085>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36814>:
  D.37086 = 0;
  if (D.37086 != 0) goto <D.37087>; else goto <D.37088>;
  <D.37087>:
  operator delete (this);
  goto <D.37089>;
  <D.37088>:
  <D.37089>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.37099;
  struct basic_streambuf * D.37100;
  int D.37101;

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

              }
            finally
              {
                D.37099 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.37099);
              }
          }
        finally
          {
            D.37100 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.37100);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35619>:
  D.37101 = 0;
  if (D.37101 != 0) goto <D.37102>; else goto <D.37103>;
  <D.37102>:
  operator delete (this);
  goto <D.37104>;
  <D.37103>:
  <D.37104>:
}


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

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

          }
        finally
          {
            D.37107 = &this->_M_buf_locale;
            std::locale::~locale (D.37107);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35750>:
  D.37108 = 0;
  if (D.37108 != 0) goto <D.37109>; else goto <D.37110>;
  <D.37109>:
  operator delete (this);
  goto <D.37111>;
  <D.37110>:
  <D.37111>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.35623>:
  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.15;
  sizetype iftmp.16;
  int (*__vtbl_ptr_type) () * D.37119;
  int (*__vtbl_ptr_type) () * D.37120;
  long int D.37121;
  struct basic_ios * D.37123;
  int (*__vtbl_ptr_type) () * iftmp.17;
  int D.37128;
  struct basic_ios * D.37131;
  int D.37133;

  {
    if (0 == 0) goto <D.37113>; else goto <D.37114>;
    <D.37113>:
    iftmp.15 = *__vtt_parm;
    goto <D.37115>;
    <D.37114>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 24B];
    <D.37115>:
    this->_vptr.basic_ostream = iftmp.15;
    if (0 == 0) goto <D.37117>; else goto <D.37118>;
    <D.37117>:
    D.37119 = this->_vptr.basic_ostream;
    D.37120 = D.37119 + 18446744073709551592;
    D.37121 = MEM[(long int *)D.37120];
    iftmp.16 = (sizetype) D.37121;
    goto <D.37122>;
    <D.37118>:
    iftmp.16 = 8;
    <D.37122>:
    D.37123 = this + iftmp.16;
    if (0 == 0) goto <D.37125>; else goto <D.37126>;
    <D.37125>:
    iftmp.17 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.37127>;
    <D.37126>:
    iftmp.17 = &MEM[(void *)&_ZTVSo + 64B];
    <D.37127>:
    D.37123->D.19008._vptr.ios_base = iftmp.17;
    try
      {
        try
          {

          }
        finally
          {
            D.37128 = 0;
            if (D.37128 != 0) goto <D.37129>; else goto <D.37130>;
            <D.37129>:
            D.37131 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.37131);
            goto <D.37132>;
            <D.37130>:
            <D.37132>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35735>:
  D.37133 = 0;
  if (D.37133 != 0) goto <D.37134>; else goto <D.37135>;
  <D.37134>:
  operator delete (this);
  goto <D.37136>;
  <D.37135>:
  <D.37136>:
}


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

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

          }
        finally
          {
            D.37138 = &this->D.19008;
            std::ios_base::~ios_base (D.37138);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35723>:
  D.37139 = 0;
  if (D.37139 != 0) goto <D.37140>; else goto <D.37141>;
  <D.37140>:
  operator delete (this);
  goto <D.37142>;
  <D.37141>:
  <D.37142>:
}


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.35727>:
  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.37146;
  const void * * iftmp.18;
  struct basic_ostream * D.37152;
  int (*__vtbl_ptr_type) () * iftmp.19;
  const void * * D.37156;
  sizetype iftmp.20;
  int (*__vtbl_ptr_type) () * D.37161;
  int (*__vtbl_ptr_type) () * D.37162;
  long int D.37163;
  struct basic_ios * D.37165;
  int (*__vtbl_ptr_type) () * iftmp.21;
  _Ios_Openmode D.37170;
  struct __stringbuf_type * D.37171;
  struct basic_streambuf * D.37172;
  sizetype iftmp.22;
  struct basic_ios * D.37177;
  const void * * iftmp.23;

  if (1 != 0) goto <D.37144>; else goto <D.37145>;
  <D.37144>:
  D.37146 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.37146);
  goto <D.37147>;
  <D.37145>:
  <D.37147>:
  try
    {
      if (1 == 0) goto <D.37149>; else goto <D.37150>;
      <D.37149>:
      iftmp.18 = 8B;
      goto <D.37151>;
      <D.37150>:
      iftmp.18 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.37151>:
      D.37152 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.37152, iftmp.18);
      try
        {
          if (1 == 0) goto <D.37154>; else goto <D.37155>;
          <D.37154>:
          D.37156 = 0B;
          iftmp.19 = *D.37156;
          goto <D.37157>;
          <D.37155>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.37157>:
          this->D.22312._vptr.basic_ostream = iftmp.19;
          if (1 == 0) goto <D.37159>; else goto <D.37160>;
          <D.37159>:
          D.37161 = this->D.22312._vptr.basic_ostream;
          D.37162 = D.37161 + 18446744073709551592;
          D.37163 = MEM[(long int *)D.37162];
          iftmp.20 = (sizetype) D.37163;
          goto <D.37164>;
          <D.37160>:
          iftmp.20 = 88;
          <D.37164>:
          D.37165 = this + iftmp.20;
          if (1 == 0) goto <D.37167>; else goto <D.37168>;
          <D.37167>:
          iftmp.21 = MEM[(const void * *)0B + 24B];
          goto <D.37169>;
          <D.37168>:
          iftmp.21 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.37169>:
          D.37165->D.19008._vptr.ios_base = iftmp.21;
          D.37170 = std::operator| (__mode, 16);
          D.37171 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.37171, D.37170);
          try
            {
              D.37172 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.37174>; else goto <D.37175>;
              <D.37174>:
              D.37161 = this->D.22312._vptr.basic_ostream;
              D.37162 = D.37161 + 18446744073709551592;
              D.37163 = MEM[(long int *)D.37162];
              iftmp.22 = (sizetype) D.37163;
              goto <D.37176>;
              <D.37175>:
              iftmp.22 = 88;
              <D.37176>:
              D.37177 = this + iftmp.22;
              std::basic_ios<char>::init (D.37177, D.37172);
            }
          catch
            {
              D.37171 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.37171);
            }
        }
      catch
        {
          if (1 == 0) goto <D.37179>; else goto <D.37180>;
          <D.37179>:
          iftmp.23 = 8B;
          goto <D.37181>;
          <D.37180>:
          iftmp.23 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.37181>:
          D.37152 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.37152, iftmp.23);
        }
    }
  catch
    {
      if (1 != 0) goto <D.37182>; else goto <D.37183>;
      <D.37182>:
      D.37146 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.37146);
      goto <D.37184>;
      <D.37183>:
      <D.37184>:
    }
}


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

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


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.37191;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.37200;
  int (*__vtbl_ptr_type) () * D.37201;
  long int D.37202;
  struct basic_ios * D.37204;
  int (*__vtbl_ptr_type) () * iftmp.26;
  sizetype iftmp.27;
  struct basic_ios * D.37213;

  if (0 != 0) goto <D.37189>; else goto <D.37190>;
  <D.37189>:
  D.37191 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.37191);
  goto <D.37192>;
  <D.37190>:
  <D.37192>:
  try
    {
      if (0 == 0) goto <D.37194>; else goto <D.37195>;
      <D.37194>:
      iftmp.24 = *__vtt_parm;
      goto <D.37196>;
      <D.37195>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 24B];
      <D.37196>:
      this->_vptr.basic_ostream = iftmp.24;
      if (0 == 0) goto <D.37198>; else goto <D.37199>;
      <D.37198>:
      D.37200 = this->_vptr.basic_ostream;
      D.37201 = D.37200 + 18446744073709551592;
      D.37202 = MEM[(long int *)D.37201];
      iftmp.25 = (sizetype) D.37202;
      goto <D.37203>;
      <D.37199>:
      iftmp.25 = 8;
      <D.37203>:
      D.37204 = this + iftmp.25;
      if (0 == 0) goto <D.37206>; else goto <D.37207>;
      <D.37206>:
      iftmp.26 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.37208>;
      <D.37207>:
      iftmp.26 = &MEM[(void *)&_ZTVSo + 64B];
      <D.37208>:
      D.37204->D.19008._vptr.ios_base = iftmp.26;
      if (0 == 0) goto <D.37210>; else goto <D.37211>;
      <D.37210>:
      D.37200 = this->_vptr.basic_ostream;
      D.37201 = D.37200 + 18446744073709551592;
      D.37202 = MEM[(long int *)D.37201];
      iftmp.27 = (sizetype) D.37202;
      goto <D.37212>;
      <D.37211>:
      iftmp.27 = 8;
      <D.37212>:
      D.37213 = this + iftmp.27;
      std::basic_ios<char>::init (D.37213, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.37214>; else goto <D.37215>;
      <D.37214>:
      D.37191 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.37191);
      goto <D.37216>;
      <D.37215>:
      <D.37216>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.37218;
  int __a.28;
  int __b.29;
  int D.37221;

  __a.28 = (int) __a;
  __b.29 = (int) __b;
  D.37221 = __a.28 | __b.29;
  D.37218 = (_Ios_Openmode) D.37221;
  return D.37218;
}


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.37223;
  struct __string_type * D.37224;

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

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


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

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

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


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.36370;
  struct _Rep & D.37227;
  char * D.37228;
  struct _Alloc_hider * D.37229;

  std::allocator<char>::allocator (&D.36370);
  try
    {
      D.37227 = std::basic_string<char>::_S_empty_rep ();
      D.37228 = std::basic_string<char>::_Rep::_M_refdata (D.37227);
      D.37229 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.37229, D.37228, &D.36370);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.36370);
      D.36370 = {CLOBBER};
    }
  try
    {

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


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

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


_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.37235;
  void * D.37236;

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


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


