int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.44252;
  int D.44255;
  int iftmp.1;
  bool D.44257;
  const struct slot D.41051;
  struct track_obj_functor1 D.41038;
  struct Functor1 D.40152;
  struct basic_string D.41054;
  const int D.41053;
  const struct string D.41057;
  struct allocator D.41056;
  struct basic_string D.41059;
  const int D.41058;
  const struct string D.41062;
  struct allocator D.41061;
  void * psl2.2;
  void * pbar4.3;
  const struct string & D.41185;
  const struct string D.41184;
  struct allocator D.41183;
  void * pbook4.4;
  const struct slot D.42095;
  struct track_obj_functor2 D.42082;
  struct Functor2 D.41195;
  struct basic_string D.42133;
  const struct basic_string D.42132;
  struct allocator D.42131;
  const int D.42129;
  struct slot2 * D.44261;
  const struct string D.42136;
  struct allocator D.42135;
  struct book * pbook4.5;
  struct basic_string D.42157;
  const struct basic_string D.42156;
  struct allocator D.42155;
  const int D.42153;
  const struct string D.42160;
  struct allocator D.42159;
  struct slot * psl2.6;
  struct bar_group4 * pbar4.7;
  struct basic_ostream & D.44274;
  int iftmp.8;
  bool D.44276;

  {
    struct TestUtilities * util;
    struct slot sl1;
    struct slot * psl2;
    struct bar_group4 * pbar4;
    struct book * pbook4;

    try
      {
        util = TestUtilities::get_instance ();
        D.44252 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.44252;
        if (retval.0 != 0) goto <D.44253>; else goto <D.44254>;
        <D.44253>:
        D.44257 = TestUtilities::get_result_and_delete_instance ();
        if (D.44257 != 0) goto <D.44258>; else goto <D.44259>;
        <D.44258>:
        iftmp.1 = 0;
        goto <D.44260>;
        <D.44259>:
        iftmp.1 = 1;
        <D.44260>:
        D.44255 = iftmp.1;
        return D.44255;
        <D.44254>:
        sigc::slot<std::basic_string<char>, int>::slot (&sl1);
        try
          {
            {
              struct bar_group4 bar4;

              try
                {
                  {anonymous}::bar_group4::bar_group4 (&bar4);
                  try
                    {
                      {anonymous}::Functor1::Functor1 (&D.40152, &bar4);
                      try
                        {
                          D.41038 = sigc::track_obj<{anonymous}::Functor1, {anonymous}::bar_group4> (&D.40152, &bar4); [return slot optimization]
                          try
                            {
                              sigc::slot<std::basic_string<char>, int>::slot<sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> > (&D.41051, &D.41038);
                              try
                                {
                                  sigc::slot<std::basic_string<char>, int>::operator= (&sl1, &D.41051);
                                }
                              finally
                                {
                                  sigc::slot<std::basic_string<char>, int>::~slot (&D.41051);
                                  D.41051 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.41038 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.40152 = {CLOBBER};
                        }
                      D.41053 = -2;
                      try
                        {
                          D.41054 = sigc::slot1<std::basic_string<char>, int>::operator() (&sl1.D.40074, &D.41053); [return slot optimization]
                          try
                            {
                              std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &D.41054);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.41054);
                              D.41054 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.41053 = {CLOBBER};
                        }
                      std::allocator<char>::allocator (&D.41056);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.41057, "negative", &D.41056);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.41057);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.41057);
                              D.41057 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.41056);
                          D.41056 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::bar_group4::~bar_group4 (&bar4);
                    }
                }
              finally
                {
                  bar4 = {CLOBBER};
                }
            }
            D.41058 = -2;
            try
              {
                D.41059 = sigc::slot1<std::basic_string<char>, int>::operator() (&sl1.D.40074, &D.41058); [return slot optimization]
                try
                  {
                    std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &D.41059);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.41059);
                    D.41059 = {CLOBBER};
                  }
              }
            finally
              {
                D.41058 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.41061);
            try
              {
                std::basic_string<char>::basic_string (&D.41062, "", &D.41061);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.41062);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.41062);
                    D.41062 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.41061);
                D.41061 = {CLOBBER};
              }
            psl2.2 = operator new (16);
            try
              {
                sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::slot (psl2.2);
              }
            catch
              {
                operator delete (psl2.2);
              }
            psl2 = psl2.2;
            pbar4.3 = operator new (8);
            try
              {
                {anonymous}::bar_group4::bar_group4 (pbar4.3);
              }
            catch
              {
                operator delete (pbar4.3);
              }
            pbar4 = pbar4.3;
            std::allocator<char>::allocator (&D.41183);
            try
              {
                std::basic_string<char>::basic_string (&D.41184, "A Book", &D.41183);
                try
                  {
                    D.41185 = &D.41184;
                    pbook4.4 = operator new (16);
                    try
                      {
                        {anonymous}::book::book (pbook4.4, D.41185);
                      }
                    catch
                      {
                        operator delete (pbook4.4);
                      }
                    pbook4 = pbook4.4;
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.41184);
                    D.41184 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.41183);
                D.41183 = {CLOBBER};
              }
            {anonymous}::Functor2::Functor2 (&D.41195, pbar4, pbook4);
            try
              {
                D.42082 = sigc::track_obj<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> (&D.41195, pbar4, pbook4); [return slot optimization]
                try
                  {
                    sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::slot<sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&D.42095, &D.42082);
                    try
                      {
                        sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::operator= (psl2, &D.42095);
                      }
                    finally
                      {
                        sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::~slot (&D.42095);
                        D.42095 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.42082 = {CLOBBER};
                  }
              }
            finally
              {
                D.41195 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.42131);
            try
              {
                std::basic_string<char>::basic_string (&D.42132, "Book title: ", &D.42131);
                try
                  {
                    D.42129 = 0;
                    try
                      {
                        D.44261 = &psl2->D.41166;
                        D.42133 = sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::operator() (D.44261, &D.42129, &D.42132); [return slot optimization]
                        try
                          {
                            std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &D.42133);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.42133);
                            D.42133 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.42129 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42132);
                    D.42132 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42131);
                D.42131 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.42135);
            try
              {
                std::basic_string<char>::basic_string (&D.42136, "zero, Book title: A Book", &D.42135);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.42136);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42136);
                    D.42136 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42135);
                D.42135 = {CLOBBER};
              }
            pbook4.5 = pbook4;
            if (pbook4.5 != 0B) goto <D.44263>; else goto <D.44264>;
            <D.44263>:
            {anonymous}::book::~book (pbook4.5);
            operator delete (pbook4.5);
            goto <D.44265>;
            <D.44264>:
            <D.44265>:
            pbook4 = 0B;
            std::allocator<char>::allocator (&D.42155);
            try
              {
                std::basic_string<char>::basic_string (&D.42156, "Book title: ", &D.42155);
                try
                  {
                    D.42153 = 0;
                    try
                      {
                        D.44261 = &psl2->D.41166;
                        D.42157 = sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::operator() (D.44261, &D.42153, &D.42156); [return slot optimization]
                        try
                          {
                            std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &D.42157);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.42157);
                            D.42157 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.42153 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42156);
                    D.42156 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42155);
                D.42155 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.42159);
            try
              {
                std::basic_string<char>::basic_string (&D.42160, "", &D.42159);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.42160);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42160);
                    D.42160 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42159);
                D.42159 = {CLOBBER};
              }
            psl2.6 = psl2;
            if (psl2.6 != 0B) goto <D.44267>; else goto <D.44268>;
            <D.44267>:
            sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::~slot (psl2.6);
            operator delete (psl2.6);
            goto <D.44269>;
            <D.44268>:
            <D.44269>:
            psl2 = 0B;
            pbar4.7 = pbar4;
            if (pbar4.7 != 0B) goto <D.44271>; else goto <D.44272>;
            <D.44271>:
            {anonymous}::bar_group4::~bar_group4 (pbar4.7);
            operator delete (pbar4.7);
            goto <D.44273>;
            <D.44272>:
            <D.44273>:
            pbar4 = 0B;
            D.44274 = std::operator<< <std::char_traits<char> > (&cout, "The compiler capabilities don\'t allow test of C++11 lambda expressions.");
            std::basic_ostream<char>::operator<< (D.44274, endl);
            D.44276 = TestUtilities::get_result_and_delete_instance ();
            if (D.44276 != 0) goto <D.44277>; else goto <D.44278>;
            <D.44277>:
            iftmp.8 = 0;
            goto <D.44279>;
            <D.44278>:
            iftmp.8 = 1;
            <D.44279>:
            D.44255 = iftmp.8;
            return D.44255;
          }
        finally
          {
            sigc::slot<std::basic_string<char>, int>::~slot (&sl1);
          }
      }
    finally
      {
        sl1 = {CLOBBER};
      }
  }
  D.44255 = 0;
  return D.44255;
}


std::basic_ostream<_CharT, _Traits>& std::endl(std::basic_ostream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os)
{
  struct basic_ostream & D.44327;
  int (*__vtbl_ptr_type) () * D.44328;
  int (*__vtbl_ptr_type) () * D.44329;
  long int D.44330;
  sizetype D.44331;
  struct basic_ios * D.44332;
  char D.44333;
  int D.44334;
  struct basic_ostream & D.44335;

  D.44328 = __os->_vptr.basic_ostream;
  D.44329 = D.44328 + 18446744073709551592;
  D.44330 = MEM[(long int *)D.44329];
  D.44331 = (sizetype) D.44330;
  D.44332 = __os + D.44331;
  D.44333 = std::basic_ios<char>::widen (D.44332, 10);
  D.44334 = (int) D.44333;
  D.44335 = std::basic_ostream<char>::put (__os, D.44334);
  D.44327 = std::flush<char, std::char_traits<char> > (D.44335);
  return D.44327;
}


std::basic_ios<_CharT, _Traits>::char_type std::basic_ios<_CharT, _Traits>::widen(char) const [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ios<_CharT, _Traits>::char_type = char] (const struct basic_ios * const this, char __c)
{
  char_type D.44340;
  int D.44341;
  const struct __ctype_type * D.44342;
  const struct ctype & D.44343;

  D.44341 = (int) __c;
  D.44342 = this->_M_ctype;
  D.44343 = std::__check_facet<std::ctype<char> > (D.44342);
  D.44340 = std::ctype<char>::widen (D.44343, D.44341);
  return D.44340;
}


const _Facet& std::__check_facet(const _Facet*) [with _Facet = std::ctype<char>] (const struct ctype * __f)
{
  const struct ctype & D.44349;

  if (__f == 0B) goto <D.44347>; else goto <D.44348>;
  <D.44347>:
  std::__throw_bad_cast ();
  <D.44348>:
  D.44349 = __f;
  return D.44349;
}


std::ctype<char>::char_type std::ctype<char>::widen(char) const (const struct ctype * const this, char __c)
{
  char D.44351;
  char_type D.44354;
  unsigned char __c.9;
  int D.44356;
  int (*__vtbl_ptr_type) () * D.44357;
  int (*__vtbl_ptr_type) () * D.44358;
  int (*__vtbl_ptr_type) () D.44359;
  int D.44360;

  D.44351 = this->_M_widen_ok;
  if (D.44351 != 0) goto <D.44352>; else goto <D.44353>;
  <D.44352>:
  __c.9 = (unsigned char) __c;
  D.44356 = (int) __c.9;
  D.44354 = this->_M_widen[D.44356];
  return D.44354;
  <D.44353>:
  std::ctype<char>::_M_widen_init (this);
  D.44357 = this->D.15977._vptr.facet;
  D.44358 = D.44357 + 48;
  D.44359 = *D.44358;
  D.44360 = (int) __c;
  D.44354 = OBJ_TYPE_REF(D.44359;(const struct ctype)this->6) (this, D.44360);
  return D.44354;
}


virtual std::ctype<char>::char_type std::ctype<char>::do_widen(char) const (const struct ctype * const this, char __c)
{
  char_type D.44363;

  D.44363 = __c;
  return D.44363;
}


std::basic_ostream<_CharT, _Traits>& std::flush(std::basic_ostream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os)
{
  struct basic_ostream & D.44365;

  D.44365 = std::basic_ostream<char>::flush (__os);
  return D.44365;
}


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

  D.44368 = &this->D.40074;
  sigc::slot1<std::basic_string<char>, int>::slot1 (D.44368);
  try
    {

    }
  catch
    {
      D.44368 = &this->D.40074;
      sigc::slot1<std::basic_string<char>, int>::~slot1 (D.44368);
    }
}


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

  D.44369 = &this->D.40032;
  sigc::slot_base::slot_base (D.44369);
  try
    {

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


{anonymous}::Functor1::Functor1(const {anonymous}::bar_group4&) (struct Functor1 * const this, const struct bar_group4 & bar)
{
  sigc::functor_base::functor_base (this);
  this->bar_ = bar;
}


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

}


sigc::track_obj_functor1<T_functor, T_obj1> sigc::track_obj(const T_functor&, const T_obj1&) [with T_functor = {anonymous}::Functor1; T_obj1 = {anonymous}::bar_group4] (const struct Functor1 & _A_func, const struct bar_group4 & _A_obj1)
{
  sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>::track_obj_functor1 (&<retval>, _A_func, _A_obj1);
  return <retval>;
}


sigc::track_obj_functor1<T_functor, T_obj1>::track_obj_functor1(const T_functor&, const T_obj1&) [with T_functor = {anonymous}::Functor1; T_obj1 = {anonymous}::bar_group4] (struct track_obj_functor1 * const this, const struct Functor1 & _A_func, const struct bar_group4 & _A_obj1)
{
  struct adapts * D.44372;
  struct const_limit_reference * D.44373;

  D.44372 = &this->D.41035;
  sigc::adapts<{anonymous}::Functor1>::adapts (D.44372, _A_func);
  D.44373 = &this->obj1_;
  sigc::const_limit_reference<{anonymous}::bar_group4, true>::const_limit_reference (D.44373, _A_obj1);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.44374 = &this->functor_;
  sigc::adaptor_functor<{anonymous}::Functor1>::adaptor_functor (D.44374, _A_functor);
}


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


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


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

  D.44375 = &_A_target->D.39892;
  this->visited = D.44375;
  this->invoked = _A_target;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>; T_return = std::basic_string<char>; T_arg1 = int] (struct slot * const this, const struct track_obj_functor1 & _A_func)
{
  struct slot1 * D.44376;

  D.44376 = &this->D.40074;
  sigc::slot1<std::basic_string<char>, int>::slot1<sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> > (D.44376, _A_func);
  try
    {

    }
  catch
    {
      D.44376 = &this->D.40074;
      sigc::slot1<std::basic_string<char>, int>::~slot1 (D.44376);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>; T_return = std::basic_string<char>; T_arg1 = int] (struct slot1 * const this, const struct track_obj_functor1 & _A_func)
{
  void * D.42653;
  struct slot_base * D.44377;
  struct rep_type * D.44378;
  void * (*<T1711>) (void *) D.44379;

  D.42653 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> >::typed_slot_rep (D.42653, _A_func);
    }
  catch
    {
      operator delete (D.42653);
    }
  D.44377 = &this->D.40032;
  sigc::slot_base::slot_base (D.44377, D.42653);
  try
    {
      D.44378 = this->D.40032.rep_;
      D.44379 = sigc::internal::slot_call1<sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>, std::basic_string<char>, int>::address ();
      D.44378->call_ = D.44379;
    }
  catch
    {
      D.44377 = &this->D.40032;
      sigc::slot_base::~slot_base (D.44377);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>] (struct typed_slot_rep * const this, const struct track_obj_functor1 & functor)
{
  struct slot_rep * D.44382;
  struct adaptor_type * D.44383;
  struct slot_do_bind D.42971;

  D.44382 = &this->D.42641;
  sigc::internal::slot_rep::slot_rep (D.44382, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.44383 = &this->functor_;
      D.44382 = &this->D.42641;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42971, D.44382);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> > (&D.42971, D.44383);
        }
      finally
        {
          D.42971 = {CLOBBER};
        }
    }
  catch
    {
      D.44382 = &this->D.42641;
      sigc::internal::slot_rep::~slot_rep (D.44382);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>] (void * data)
{
  void * D.44386;
  void * D.43102;
  struct slot_rep * a_rep;

  a_rep = data;
  D.43102 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> >::typed_slot_rep (D.43102, a_rep);
    }
  catch
    {
      operator delete (D.43102);
    }
  D.44386 = D.43102;
  return D.44386;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.44390;
  struct slot_rep * D.44391;
  struct adaptor_type * D.44392;
  struct slot_do_bind D.43528;

  D.44390 = cl->D.42641.call_;
  D.44391 = &this->D.42641;
  sigc::internal::slot_rep::slot_rep (D.44391, D.44390, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.44392 = &this->functor_;
      D.44391 = &this->D.42641;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43528, D.44391);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> > (&D.43528, D.44392);
        }
      finally
        {
          D.43528 = {CLOBBER};
        }
    }
  catch
    {
      D.44391 = &this->D.42641;
      sigc::internal::slot_rep::~slot_rep (D.44391);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>] (void * data)
{
  struct adaptor_type * D.44395;
  struct slot_do_unbind D.43087;
  void * D.44396;
  struct self * self_;

  self_ = data;
  self_->D.42641.call_ = 0B;
  self_->D.42641.destroy_ = 0B;
  D.44395 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.43087, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4> > (&D.43087, D.44395);
    }
  finally
    {
      D.43087 = {CLOBBER};
    }
  D.44396 = 0B;
  return D.44396;
}


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


static void sigc::visitor<sigc::track_obj_functor1<T_functor, T_obj1> >::do_visit_each(const T_action&, const sigc::track_obj_functor1<T_functor, T_obj1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = {anonymous}::Functor1; T_obj1 = {anonymous}::bar_group4] (const struct limit_derived_target & _A_action, const struct track_obj_functor1 & _A_target)
{
  struct adaptor_type * D.44400;
  const struct const_limit_reference * D.44401;

  D.44400 = &_A_target->D.41035.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<{anonymous}::Functor1> > (_A_action, D.44400);
  D.44401 = &_A_target->obj1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::const_limit_reference<{anonymous}::bar_group4, true> > (_A_action, D.44401);
}


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

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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::const_limit_reference<{anonymous}::bar_group4, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<{anonymous}::bar_group4, 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::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_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}::bar_group4; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.44403;

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


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

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


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

  D.44406 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.44406, _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.44407;

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


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

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


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


static void sigc::visitor<sigc::track_obj_functor1<T_functor, T_obj1> >::do_visit_each(const T_action&, const sigc::track_obj_functor1<T_functor, T_obj1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = {anonymous}::Functor1; T_obj1 = {anonymous}::bar_group4] (const struct limit_derived_target & _A_action, const struct track_obj_functor1 & _A_target)
{
  struct adaptor_type * D.44410;
  const struct const_limit_reference * D.44411;

  D.44410 = &_A_target->D.41035.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<{anonymous}::Functor1> > (_A_action, D.44410);
  D.44411 = &_A_target->obj1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::const_limit_reference<{anonymous}::bar_group4, true> > (_A_action, D.44411);
}


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

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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::const_limit_reference<{anonymous}::bar_group4, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<{anonymous}::bar_group4, 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::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_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}::bar_group4; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.44413;

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


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

  D.44414 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.44414, _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.44415;

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


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

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


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

  D.44419 = this->destroy_;
  if (D.44419 != 0B) goto <D.44420>; else goto <D.44421>;
  <D.44420>:
  D.44419 = this->destroy_;
  D.44419 (this);
  goto <D.44422>;
  <D.44421>:
  <D.44422>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>; T_return = std::basic_string<char>; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.44423;

  D.44423 = call_it;
  return D.44423;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>; T_return = std::basic_string<char>; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  struct adaptor_type * D.44426;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.44426 = &typed_rep->functor_;
  *<retval> = sigc::track_obj_functor1<{anonymous}::Functor1, {anonymous}::bar_group4>::operator()<const int&> (D.44426, a_1); [return slot optimization]
  return <retval>;
}


typename sigc::track_obj_functor1<T_functor, T_obj1>::deduce_result_type<T_arg1>::type sigc::track_obj_functor1<T_functor, T_obj1>::operator()(T_arg1) [with T_arg1 = const int&; T_functor = {anonymous}::Functor1; T_obj1 = {anonymous}::bar_group4; typename sigc::track_obj_functor1<T_functor, T_obj1>::deduce_result_type<T_arg1>::type = std::basic_string<char>] (struct track_obj_functor1 * const this, const int & _A_arg1)
{
  struct adaptor_type * D.44429;

  D.44429 = &this->D.41035.functor_;
  *<retval> = sigc::adaptor_functor<{anonymous}::Functor1>::operator()<const int&> (D.44429, _A_arg1); [return slot optimization]
  return <retval>;
}


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}::Functor1; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = std::basic_string<char>] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  int D.44432;
  struct Functor1 * D.44433;

  D.44432 = *_A_arg1;
  D.44433 = &this->functor_;
  *<retval> = {anonymous}::Functor1::operator() (D.44433, D.44432); [return slot optimization]
  return <retval>;
}


std::string {anonymous}::Functor1::operator()(int) (struct Functor1 * const this, int i)
{
  struct allocator D.39934;
  const char * iftmp.10;
  const char * iftmp.11;

  std::allocator<char>::allocator (&D.39934);
  try
    {
      if (i >= 0) goto <D.44437>; else goto <D.44438>;
      <D.44437>:
      if (i > 0) goto <D.44440>; else goto <D.44441>;
      <D.44440>:
      iftmp.11 = "positive";
      goto <D.44442>;
      <D.44441>:
      iftmp.11 = "zero";
      <D.44442>:
      iftmp.10 = iftmp.11;
      goto <D.44443>;
      <D.44438>:
      iftmp.10 = "negative";
      <D.44443>:
      std::basic_string<char>::basic_string (<retval>, iftmp.10, &D.39934);
      return <retval>;
    }
  finally
    {
      std::allocator<char>::~allocator (&D.39934);
      D.39934 = {CLOBBER};
    }
}


sigc::slot<std::basic_string<char>, int>& sigc::slot<std::basic_string<char>, int>::operator=(const sigc::slot<std::basic_string<char>, int>&) (struct slot * const this, const struct slot & D.41040)
{
  const struct slot1 * D.44447;
  struct slot1 * D.44448;
  struct slot & D.44449;

  D.44447 = &D.41040->D.40074;
  D.44448 = &this->D.40074;
  sigc::slot1<std::basic_string<char>, int>::operator= (D.44448, D.44447);
  D.44449 = this;
  return D.44449;
}


sigc::slot1<T_return, T_arg1>& sigc::slot1<T_return, T_arg1>::operator=(const sigc::slot1<T_return, T_arg1>&) [with T_return = std::basic_string<char>; T_arg1 = int] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.44451;
  struct slot_base * D.44452;
  struct slot1 & D.44453;

  D.44451 = &src->D.40032;
  D.44452 = &this->D.40032;
  sigc::slot_base::operator= (D.44452, D.44451);
  D.44453 = this;
  return D.44453;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = std::basic_string<char>; T_arg1 = int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const int&] (const struct slot1 * const this, const int & _A_a1)
{
  bool retval.12;
  bool iftmp.13;
  const struct slot_base * D.44460;
  bool D.44461;
  bool D.44462;
  bool D.44464;
  bool D.44465;
  struct rep_type * D.44469;
  void * (*<T1711>) (void *) D.44470;

  D.44460 = &this->D.40032;
  D.44461 = sigc::slot_base::empty (D.44460);
  D.44462 = ~D.44461;
  if (D.44462 != 0) goto <D.44463>; else goto <D.44458>;
  <D.44463>:
  D.44460 = &this->D.40032;
  D.44464 = sigc::slot_base::blocked (D.44460);
  D.44465 = ~D.44464;
  if (D.44465 != 0) goto <D.44466>; else goto <D.44458>;
  <D.44466>:
  iftmp.13 = 1;
  goto <D.44459>;
  <D.44458>:
  iftmp.13 = 0;
  <D.44459>:
  retval.12 = iftmp.13;
  if (retval.12 != 0) goto <D.44467>; else goto <D.44468>;
  <D.44467>:
  D.44469 = this->D.40032.rep_;
  D.44470 = D.44469->call_;
  D.44469 = this->D.40032.rep_;
  *<retval> = D.44470 (D.44469, _A_a1); [return slot optimization]
  return <retval>;
  <D.44468>:
  std::basic_string<char>::basic_string (<retval>);
  return <retval>;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.44472;
  bool iftmp.14;
  struct rep_type * D.44477;
  void * (*<T1711>) (void *) D.44479;

  D.44477 = this->rep_;
  if (D.44477 == 0B) goto <D.44474>; else goto <D.44478>;
  <D.44478>:
  D.44477 = this->rep_;
  D.44479 = D.44477->call_;
  if (D.44479 == 0B) goto <D.44474>; else goto <D.44475>;
  <D.44474>:
  iftmp.14 = 1;
  goto <D.44476>;
  <D.44475>:
  iftmp.14 = 0;
  <D.44476>:
  D.44472 = iftmp.14;
  return D.44472;
}


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

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


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.42667;
  struct _Rep & D.44483;
  char * D.44484;
  struct _Alloc_hider * D.44485;

  std::allocator<char>::allocator (&D.42667);
  try
    {
      D.44483 = std::basic_string<char>::_S_empty_rep ();
      D.44484 = std::basic_string<char>::_Rep::_M_refdata (D.44483);
      D.44485 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.44485, D.44484, &D.42667);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.42667);
      D.42667 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.44493;
  void * D.44494;

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


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


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

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


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

  try
    {
      {

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


sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot() [with T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>] (struct slot * const this)
{
  struct slot2 * D.44498;

  D.44498 = &this->D.41166;
  sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::slot2 (D.44498);
  try
    {

    }
  catch
    {
      D.44498 = &this->D.41166;
      sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::~slot2 (D.44498);
    }
}


sigc::slot2<T_return, T_arg1, T_arg2>::slot2() [with T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>] (struct slot2 * const this)
{
  struct slot_base * D.44499;

  D.44499 = &this->D.41124;
  sigc::slot_base::slot_base (D.44499);
  try
    {

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


{anonymous}::bar_group4::bar_group4() (struct bar_group4 * const this)
{
  struct trackable * D.44500;

  D.44500 = &this->D.39892;
  sigc::trackable::trackable (D.44500);
  try
    {

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


{anonymous}::book::book(const string&) (struct book * const this, const struct string & name)
{
  struct trackable * D.44501;
  struct string * D.44502;

  D.44501 = &this->D.39882;
  sigc::trackable::trackable (D.44501);
  try
    {
      D.44502 = &this->name_;
      std::basic_string<char>::basic_string (D.44502, name);
      try
        {

        }
      catch
        {
          D.44502 = &this->name_;
          std::basic_string<char>::~basic_string (D.44502);
        }
    }
  catch
    {
      D.44501 = &this->D.39882;
      sigc::trackable::~trackable (D.44501);
    }
}


{anonymous}::Functor2::Functor2(const {anonymous}::bar_group4&, const {anonymous}::book&) (struct Functor2 * const this, const struct bar_group4 & bar, const struct book & aBook)
{
  sigc::functor_base::functor_base (this);
  this->bar_ = bar;
  this->aBook_ = aBook;
}


sigc::track_obj_functor2<T_functor, T_obj1, T_obj2> sigc::track_obj(const T_functor&, const T_obj1&, const T_obj2&) [with T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4; T_obj2 = {anonymous}::book] (const struct Functor2 & _A_func, const struct bar_group4 & _A_obj1, const struct book & _A_obj2)
{
  sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>::track_obj_functor2 (&<retval>, _A_func, _A_obj1, _A_obj2);
  return <retval>;
}


sigc::track_obj_functor2<T_functor, T_obj1, T_obj2>::track_obj_functor2(const T_functor&, const T_obj1&, const T_obj2&) [with T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4; T_obj2 = {anonymous}::book] (struct track_obj_functor2 * const this, const struct Functor2 & _A_func, const struct bar_group4 & _A_obj1, const struct book & _A_obj2)
{
  struct track_obj_functor1 * D.44506;
  struct const_limit_reference * D.44507;

  D.44506 = &this->D.42079;
  sigc::track_obj_functor1<{anonymous}::Functor2, {anonymous}::bar_group4>::track_obj_functor1 (D.44506, _A_func, _A_obj1);
  D.44507 = &this->obj2_;
  sigc::const_limit_reference<{anonymous}::book, true>::const_limit_reference (D.44507, _A_obj2);
}


sigc::track_obj_functor1<T_functor, T_obj1>::track_obj_functor1(const T_functor&, const T_obj1&) [with T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4] (struct track_obj_functor1 * const this, const struct Functor2 & _A_func, const struct bar_group4 & _A_obj1)
{
  struct adapts * D.44508;
  struct const_limit_reference * D.44509;

  D.44508 = &this->D.42023;
  sigc::adapts<{anonymous}::Functor2>::adapts (D.44508, _A_func);
  D.44509 = &this->obj1_;
  sigc::const_limit_reference<{anonymous}::bar_group4, true>::const_limit_reference (D.44509, _A_obj1);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.44510 = &this->functor_;
  sigc::adaptor_functor<{anonymous}::Functor2>::adaptor_functor (D.44510, _A_functor);
}


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


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

  D.44511 = &_A_target->D.39882;
  this->visited = D.44511;
  this->invoked = _A_target;
}


sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>; T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>] (struct slot * const this, const struct track_obj_functor2 & _A_func)
{
  struct slot2 * D.44512;

  D.44512 = &this->D.41166;
  sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::slot2<sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (D.44512, _A_func);
  try
    {

    }
  catch
    {
      D.44512 = &this->D.41166;
      sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::~slot2 (D.44512);
    }
}


sigc::slot2<T_return, T_arg1, T_arg2>::slot2(const T_functor&) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>; T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>] (struct slot2 * const this, const struct track_obj_functor2 & _A_func)
{
  void * D.42768;
  struct slot_base * D.44513;
  struct rep_type * D.44514;
  void * (*<T1711>) (void *) D.44515;

  D.42768 = operator new (112);
  try
    {
      sigc::internal::typed_slot_rep<sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> >::typed_slot_rep (D.42768, _A_func);
    }
  catch
    {
      operator delete (D.42768);
    }
  D.44513 = &this->D.41124;
  sigc::slot_base::slot_base (D.44513, D.42768);
  try
    {
      D.44514 = this->D.41124.rep_;
      D.44515 = sigc::internal::slot_call2<sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>, std::basic_string<char>, int, std::basic_string<char> >::address ();
      D.44514->call_ = D.44515;
    }
  catch
    {
      D.44513 = &this->D.41124;
      sigc::slot_base::~slot_base (D.44513);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (struct typed_slot_rep * const this, const struct track_obj_functor2 & functor)
{
  struct slot_rep * D.44518;
  struct adaptor_type * D.44519;
  struct slot_do_bind D.43000;

  D.44518 = &this->D.42755;
  sigc::internal::slot_rep::slot_rep (D.44518, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.44519 = &this->functor_;
      D.44518 = &this->D.42755;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43000, D.44518);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&D.43000, D.44519);
        }
      finally
        {
          D.43000 = {CLOBBER};
        }
    }
  catch
    {
      D.44518 = &this->D.42755;
      sigc::internal::slot_rep::~slot_rep (D.44518);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (void * data)
{
  void * D.44522;
  void * D.43329;
  struct slot_rep * a_rep;

  a_rep = data;
  D.43329 = operator new (112);
  try
    {
      sigc::internal::typed_slot_rep<sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> >::typed_slot_rep (D.43329, a_rep);
    }
  catch
    {
      operator delete (D.43329);
    }
  D.44522 = D.43329;
  return D.44522;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.44526;
  struct slot_rep * D.44527;
  struct adaptor_type * D.44528;
  struct slot_do_bind D.43662;

  D.44526 = cl->D.42755.call_;
  D.44527 = &this->D.42755;
  sigc::internal::slot_rep::slot_rep (D.44527, D.44526, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.44528 = &this->functor_;
      D.44527 = &this->D.42755;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43662, D.44527);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&D.43662, D.44528);
        }
      finally
        {
          D.43662 = {CLOBBER};
        }
    }
  catch
    {
      D.44527 = &this->D.42755;
      sigc::internal::slot_rep::~slot_rep (D.44527);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (void * data)
{
  struct adaptor_type * D.44531;
  struct slot_do_unbind D.43314;
  void * D.44532;
  struct self * self_;

  self_ = data;
  self_->D.42755.call_ = 0B;
  self_->D.42755.destroy_ = 0B;
  D.44531 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.43314, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&D.43314, D.44531);
    }
  finally
    {
      D.43314 = {CLOBBER};
    }
  D.44532 = 0B;
  return D.44532;
}


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::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (const struct slot_do_unbind & _A_action, const struct track_obj_functor2 & _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::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


static void sigc::visitor<sigc::track_obj_functor2<T_functor, T_obj1, T_obj2> >::do_visit_each(const T_action&, const sigc::track_obj_functor2<T_functor, T_obj1, T_obj2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4; T_obj2 = {anonymous}::book] (const struct limit_derived_target & _A_action, const struct track_obj_functor2 & _A_target)
{
  struct adaptor_type * D.44536;
  const struct const_limit_reference * D.44537;
  const struct const_limit_reference * D.44538;

  D.44536 = &_A_target->D.42079.D.42023.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<{anonymous}::Functor2> > (_A_action, D.44536);
  D.44537 = &_A_target->D.42079.obj1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::const_limit_reference<{anonymous}::bar_group4, true> > (_A_action, D.44537);
  D.44538 = &_A_target->obj2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::const_limit_reference<{anonymous}::book, true> > (_A_action, D.44538);
}


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

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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::const_limit_reference<{anonymous}::book, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<{anonymous}::book, 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::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_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}::book; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.44540;

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


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

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


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::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>] (const struct slot_do_bind & _A_action, const struct track_obj_functor2 & _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::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


static void sigc::visitor<sigc::track_obj_functor2<T_functor, T_obj1, T_obj2> >::do_visit_each(const T_action&, const sigc::track_obj_functor2<T_functor, T_obj1, T_obj2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4; T_obj2 = {anonymous}::book] (const struct limit_derived_target & _A_action, const struct track_obj_functor2 & _A_target)
{
  struct adaptor_type * D.44544;
  const struct const_limit_reference * D.44545;
  const struct const_limit_reference * D.44546;

  D.44544 = &_A_target->D.42079.D.42023.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<{anonymous}::Functor2> > (_A_action, D.44544);
  D.44545 = &_A_target->D.42079.obj1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::const_limit_reference<{anonymous}::bar_group4, true> > (_A_action, D.44545);
  D.44546 = &_A_target->obj2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::const_limit_reference<{anonymous}::book, true> > (_A_action, D.44546);
}


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

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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::const_limit_reference<{anonymous}::book, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<{anonymous}::book, 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::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_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}::book; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.44548;

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


static void* (* sigc::internal::slot_call2<T_functor, T_return, T_arg1, T_arg2>::address())(void*) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>; T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.44549;

  D.44549 = call_it;
  return D.44549;
}


static T_return sigc::internal::slot_call2<T_functor, T_return, T_arg1, T_arg2>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take, typename sigc::type_trait<T_arg4>::take) [with T_functor = sigc::track_obj_functor2<{anonymous}::Functor2, {anonymous}::bar_group4, {anonymous}::book>; T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>; typename sigc::type_trait<T_arg3>::take = const int&; typename sigc::type_trait<T_arg4>::take = const std::basic_string<char>&] (struct slot_rep * rep, const int & a_1, const struct basic_string & a_2)
{
  struct track_obj_functor1 * D.44552;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.44552 = &typed_rep->functor_.D.42079;
  *<retval> = sigc::track_obj_functor1<{anonymous}::Functor2, {anonymous}::bar_group4>::operator()<const int&, const std::basic_string<char>&> (D.44552, a_1, a_2); [return slot optimization]
  return <retval>;
}


typename sigc::track_obj_functor1<T_functor, T_obj1>::deduce_result_type<T_arg1, T_arg2>::type sigc::track_obj_functor1<T_functor, T_obj1>::operator()(T_arg1, T_arg2) [with T_arg1 = const int&; T_arg2 = const std::basic_string<char>&; T_functor = {anonymous}::Functor2; T_obj1 = {anonymous}::bar_group4; typename sigc::track_obj_functor1<T_functor, T_obj1>::deduce_result_type<T_arg1, T_arg2>::type = std::basic_string<char>] (struct track_obj_functor1 * const this, const int & _A_arg1, const struct basic_string & _A_arg2)
{
  struct adaptor_type * D.44555;

  D.44555 = &this->D.42023.functor_;
  *<retval> = sigc::adaptor_functor<{anonymous}::Functor2>::operator()<const int&, const std::basic_string<char>&> (D.44555, _A_arg1, _A_arg2); [return slot optimization]
  return <retval>;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = const int&; T_arg2 = const std::basic_string<char>&; T_functor = {anonymous}::Functor2; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = std::basic_string<char>] (const struct adaptor_functor * const this, const int & _A_arg1, const struct basic_string & _A_arg2)
{
  int D.44558;
  struct Functor2 * D.44559;

  D.44558 = *_A_arg1;
  D.44559 = &this->functor_;
  *<retval> = {anonymous}::Functor2::operator() (D.44559, D.44558, _A_arg2); [return slot optimization]
  return <retval>;
}


std::string {anonymous}::Functor2::operator()(int, const string&) const (const struct Functor2 * const this, int i, const struct string & str)
{
  struct allocator D.39965;
  const char * iftmp.15;
  const char * iftmp.16;
  const struct book & D.44570;
  const struct string & D.44571;
  struct string result [value-expr: *<retval>];

  std::allocator<char>::allocator (&D.39965);
  try
    {
      if (i >= 0) goto <D.44563>; else goto <D.44564>;
      <D.44563>:
      if (i > 0) goto <D.44566>; else goto <D.44567>;
      <D.44566>:
      iftmp.16 = "positive, ";
      goto <D.44568>;
      <D.44567>:
      iftmp.16 = "zero, ";
      <D.44568>:
      iftmp.15 = iftmp.16;
      goto <D.44569>;
      <D.44564>:
      iftmp.15 = "negative, ";
      <D.44569>:
      std::basic_string<char>::basic_string (<retval>, iftmp.15, &D.39965);
    }
  finally
    {
      try
        {
          std::allocator<char>::~allocator (&D.39965);
        }
      catch
        {
          std::basic_string<char>::~basic_string (<retval>);
        }
      D.39965 = {CLOBBER};
    }
  try
    {
      std::basic_string<char>::operator+= (<retval>, str);
      D.44570 = this->aBook_;
      D.44571 = {anonymous}::book::operator const string& (D.44570);
      std::basic_string<char>::operator+= (<retval>, D.44571);
      return <retval>;
    }
  catch
    {
      std::basic_string<char>::~basic_string (<retval>);
    }
}


{anonymous}::book::operator const string&() const (const struct book * const this)
{
  const struct string & D.44575;

  D.44575 = &this->name_;
  return D.44575;
}


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

  D.44577 = std::basic_string<char>::append (this, __str);
  return D.44577;
}


sigc::slot<std::basic_string<char>, int, std::basic_string<char> >& sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::operator=(const sigc::slot<std::basic_string<char>, int, std::basic_string<char> >&) (struct slot * const this, const struct slot & D.42084)
{
  const struct slot2 * D.44580;
  struct slot2 * D.44581;
  struct slot & D.44582;

  D.44580 = &D.42084->D.41166;
  D.44581 = &this->D.41166;
  sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::operator= (D.44581, D.44580);
  D.44582 = this;
  return D.44582;
}


sigc::slot2<T_return, T_arg1, T_arg2>& sigc::slot2<T_return, T_arg1, T_arg2>::operator=(const sigc::slot2<T_return, T_arg1, T_arg2>&) [with T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>] (struct slot2 * const this, const struct slot2 & src)
{
  const struct slot_base * D.44584;
  struct slot_base * D.44585;
  struct slot2 & D.44586;

  D.44584 = &src->D.41124;
  D.44585 = &this->D.41124;
  sigc::slot_base::operator= (D.44585, D.44584);
  D.44586 = this;
  return D.44586;
}


{anonymous}::book::~book() (struct book * const this)
{
  struct string * D.44588;
  struct trackable * D.44589;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.44588 = &this->name_;
                std::basic_string<char>::~basic_string (D.44588);
              }
          }
        finally
          {
            D.44589 = &this->D.39882;
            sigc::trackable::~trackable (D.44589);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42150>:
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = std::basic_string<char>; T_arg1 = int; T_arg2 = std::basic_string<char>; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const int&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const std::basic_string<char>&] (const struct slot2 * const this, const int & _A_a1, const struct basic_string & _A_a2)
{
  bool retval.17;
  bool iftmp.18;
  const struct slot_base * D.44597;
  bool D.44598;
  bool D.44599;
  bool D.44601;
  bool D.44602;
  struct rep_type * D.44606;
  void * (*<T1711>) (void *) D.44607;

  D.44597 = &this->D.41124;
  D.44598 = sigc::slot_base::empty (D.44597);
  D.44599 = ~D.44598;
  if (D.44599 != 0) goto <D.44600>; else goto <D.44595>;
  <D.44600>:
  D.44597 = &this->D.41124;
  D.44601 = sigc::slot_base::blocked (D.44597);
  D.44602 = ~D.44601;
  if (D.44602 != 0) goto <D.44603>; else goto <D.44595>;
  <D.44603>:
  iftmp.18 = 1;
  goto <D.44596>;
  <D.44595>:
  iftmp.18 = 0;
  <D.44596>:
  retval.17 = iftmp.18;
  if (retval.17 != 0) goto <D.44604>; else goto <D.44605>;
  <D.44604>:
  D.44606 = this->D.41124.rep_;
  D.44607 = D.44606->call_;
  D.44606 = this->D.41124.rep_;
  *<retval> = D.44607 (D.44606, _A_a1, _A_a2); [return slot optimization]
  return <retval>;
  <D.44605>:
  std::basic_string<char>::basic_string (<retval>);
  return <retval>;
}


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.44609;
  long unsigned int D.44610;
  long int D.44611;
  const char * D.44612;

  D.44610 = std::basic_string<char>::size (__str);
  D.44611 = (long int) D.44610;
  D.44612 = std::basic_string<char>::data (__str);
  D.44609 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.44612, D.44611);
  return D.44609;
}


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.44617;
  struct _Rep * D.44618;

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


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.44621;
  char * D.44622;

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


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

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


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

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


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

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

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


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

  try
    {
      {

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


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.44634;
  int (*__vtbl_ptr_type) () * D.44635;
  long int D.44636;
  sizetype D.44637;
  struct basic_ios * D.44638;
  long unsigned int D.44640;
  long int D.44641;
  struct basic_ostream & D.44642;

  if (__s == 0B) goto <D.44632>; else goto <D.44633>;
  <D.44632>:
  D.44634 = __out->_vptr.basic_ostream;
  D.44635 = D.44634 + 18446744073709551592;
  D.44636 = MEM[(long int *)D.44635];
  D.44637 = (sizetype) D.44636;
  D.44638 = __out + D.44637;
  std::basic_ios<char>::setstate (D.44638, 1);
  goto <D.44639>;
  <D.44633>:
  D.44640 = std::char_traits<char>::length (__s);
  D.44641 = (long int) D.44640;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.44641);
  <D.44639>:
  D.44642 = __out;
  return D.44642;
}


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.44644;
  _Ios_Iostate D.44645;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.44649;
  int __a.19;
  int __b.20;
  int D.44652;

  __a.19 = (int) __a;
  __b.20 = (int) __b;
  D.44652 = __a.19 | __b.20;
  D.44649 = (_Ios_Iostate) D.44652;
  return D.44649;
}


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

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


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ostream_type& (*)(std::basic_ostream<_CharT, _Traits>::__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, struct __ostream_type & (*<T3460>) (struct __ostream_type &) __pf)
{
  struct __ostream_type & D.44656;

  D.44656 = __pf (this);
  return D.44656;
}


{anonymous}::bar_group4::~bar_group4() (struct bar_group4 * const this)
{
  struct trackable * D.44659;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44659 = &this->D.39892;
            sigc::trackable::~trackable (D.44659);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40140>:
}


sigc::slot<std::basic_string<char>, int, std::basic_string<char> >::~slot() (struct slot * const this)
{
  struct slot2 * D.44661;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44661 = &this->D.41166;
            sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::~slot2 (D.44661);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42125>:
}


sigc::slot2<std::basic_string<char>, int, std::basic_string<char> >::~slot2() (struct slot2 * const this)
{
  struct slot_base * D.44663;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44663 = &this->D.41124;
            sigc::slot_base::~slot_base (D.44663);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42120>:
}


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.42352;
  struct _Rep * D.44665;
  struct _Alloc_hider * D.44666;

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


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

  D.44672 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.44672);
  return <retval>;
}


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.21;
  struct _Rep & D.44675;
  bool D.44676;
  long int D.44677;
  long int D.44678;
  bool retval.22;
  _Atomic_word * D.44682;
  int D.44683;

  D.44675 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.44676 = D.44675 != this;
  D.44677 = (long int) D.44676;
  D.44678 = __builtin_expect (D.44677, 0);
  retval.21 = D.44678 != 0;
  if (retval.21 != 0) goto <D.44679>; else goto <D.44680>;
  <D.44679>:
  D.44682 = &this->D.11865._M_refcount;
  D.44683 = __gnu_cxx::__exchange_and_add_dispatch (D.44682, -1);
  retval.22 = D.44683 <= 0;
  if (retval.22 != 0) goto <D.44684>; else goto <D.44685>;
  <D.44684>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.44686>;
  <D.44685>:
  <D.44686>:
  goto <D.44687>;
  <D.44680>:
  <D.44687>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.23;
  int D.44690;
  _Atomic_word D.44693;

  D.44690 = __gthread_active_p ();
  retval.23 = D.44690 != 0;
  if (retval.23 != 0) goto <D.44691>; else goto <D.44692>;
  <D.44691>:
  D.44693 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.44693;
  <D.44692>:
  D.44693 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.44693;
}


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

  D.44696 = __gthrw___pthread_key_create != 0B;
  D.44695 = (int) D.44696;
  return D.44695;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.44698;
  unsigned int __val.24;
  unsigned int D.44700;

  __val.24 = (unsigned int) __val;
  D.44700 = __atomic_fetch_add_4 (__mem, __val.24, 4);
  D.44698 = (_Atomic_word) D.44700;
  return D.44698;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.44702;
  int D.44703;
  _Atomic_word D.44704;
  _Atomic_word __result;

  __result = *__mem;
  D.44702 = *__mem;
  D.44703 = D.44702 + __val;
  *__mem = D.44703;
  D.44704 = __result;
  return D.44704;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44708 = &this->D.40074;
            sigc::slot1<std::basic_string<char>, int>::~slot1 (D.44708);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40105>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44710 = &this->D.40032;
            sigc::slot_base::~slot_base (D.44710);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40100>:
}


(static initializers for test_track_obj.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.44712>; else goto <D.44713>;
  <D.44712>:
  if (__priority == 65535) goto <D.44714>; else goto <D.44715>;
  <D.44714>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.44716>;
  <D.44715>:
  <D.44716>:
  goto <D.44717>;
  <D.44713>:
  <D.44717>:
}


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.25;
  const void * * D.44721;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.44726;
  int (*__vtbl_ptr_type) () * D.44727;
  long int D.44728;
  struct basic_ios * D.44730;
  int (*__vtbl_ptr_type) () * iftmp.27;
  struct __stringbuf_type * D.44735;
  const void * * iftmp.28;
  struct basic_ostream * D.44740;
  int D.44741;
  struct basic_ios * D.44744;
  int D.44746;

  {
    if (2 == 0) goto <D.44719>; else goto <D.44720>;
    <D.44719>:
    D.44721 = 0B;
    iftmp.25 = *D.44721;
    goto <D.44722>;
    <D.44720>:
    iftmp.25 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.44722>:
    this->D.22312._vptr.basic_ostream = iftmp.25;
    if (2 == 0) goto <D.44724>; else goto <D.44725>;
    <D.44724>:
    D.44726 = this->D.22312._vptr.basic_ostream;
    D.44727 = D.44726 + 18446744073709551592;
    D.44728 = MEM[(long int *)D.44727];
    iftmp.26 = (sizetype) D.44728;
    goto <D.44729>;
    <D.44725>:
    iftmp.26 = 88;
    <D.44729>:
    D.44730 = this + iftmp.26;
    if (2 == 0) goto <D.44732>; else goto <D.44733>;
    <D.44732>:
    iftmp.27 = MEM[(const void * *)0B + 24B];
    goto <D.44734>;
    <D.44733>:
    iftmp.27 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.44734>:
    D.44730->D.19008._vptr.ios_base = iftmp.27;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.44735 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.44735);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.44737>; else goto <D.44738>;
                <D.44737>:
                iftmp.28 = 8B;
                goto <D.44739>;
                <D.44738>:
                iftmp.28 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.44739>:
                D.44740 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.44740, iftmp.28);
              }
          }
        finally
          {
            D.44741 = 2;
            if (D.44741 != 0) goto <D.44742>; else goto <D.44743>;
            <D.44742>:
            D.44744 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.44744);
            goto <D.44745>;
            <D.44743>:
            <D.44745>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44100>:
  D.44746 = 0;
  if (D.44746 != 0) goto <D.44747>; else goto <D.44748>;
  <D.44747>:
  operator delete (this);
  goto <D.44749>;
  <D.44748>:
  <D.44749>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.44759;
  struct basic_streambuf * D.44760;
  int D.44761;

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

              }
            finally
              {
                D.44759 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.44759);
              }
          }
        finally
          {
            D.44760 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.44760);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42324>:
  D.44761 = 0;
  if (D.44761 != 0) goto <D.44762>; else goto <D.44763>;
  <D.44762>:
  operator delete (this);
  goto <D.44764>;
  <D.44763>:
  <D.44764>:
}


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

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

          }
        finally
          {
            D.44767 = &this->_M_buf_locale;
            std::locale::~locale (D.44767);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42529>:
  D.44768 = 0;
  if (D.44768 != 0) goto <D.44769>; else goto <D.44770>;
  <D.44769>:
  operator delete (this);
  goto <D.44771>;
  <D.44770>:
  <D.44771>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.42328>:
  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.29;
  sizetype iftmp.30;
  int (*__vtbl_ptr_type) () * D.44779;
  int (*__vtbl_ptr_type) () * D.44780;
  long int D.44781;
  struct basic_ios * D.44783;
  int (*__vtbl_ptr_type) () * iftmp.31;
  int D.44788;
  struct basic_ios * D.44791;
  int D.44793;

  {
    if (0 == 0) goto <D.44773>; else goto <D.44774>;
    <D.44773>:
    iftmp.29 = *__vtt_parm;
    goto <D.44775>;
    <D.44774>:
    iftmp.29 = &MEM[(void *)&_ZTVSo + 24B];
    <D.44775>:
    this->_vptr.basic_ostream = iftmp.29;
    if (0 == 0) goto <D.44777>; else goto <D.44778>;
    <D.44777>:
    D.44779 = this->_vptr.basic_ostream;
    D.44780 = D.44779 + 18446744073709551592;
    D.44781 = MEM[(long int *)D.44780];
    iftmp.30 = (sizetype) D.44781;
    goto <D.44782>;
    <D.44778>:
    iftmp.30 = 8;
    <D.44782>:
    D.44783 = this + iftmp.30;
    if (0 == 0) goto <D.44785>; else goto <D.44786>;
    <D.44785>:
    iftmp.31 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.44787>;
    <D.44786>:
    iftmp.31 = &MEM[(void *)&_ZTVSo + 64B];
    <D.44787>:
    D.44783->D.19008._vptr.ios_base = iftmp.31;
    try
      {
        try
          {

          }
        finally
          {
            D.44788 = 0;
            if (D.44788 != 0) goto <D.44789>; else goto <D.44790>;
            <D.44789>:
            D.44791 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.44791);
            goto <D.44792>;
            <D.44790>:
            <D.44792>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42514>:
  D.44793 = 0;
  if (D.44793 != 0) goto <D.44794>; else goto <D.44795>;
  <D.44794>:
  operator delete (this);
  goto <D.44796>;
  <D.44795>:
  <D.44796>:
}


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

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

          }
        finally
          {
            D.44798 = &this->D.19008;
            std::ios_base::~ios_base (D.44798);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42502>:
  D.44799 = 0;
  if (D.44799 != 0) goto <D.44800>; else goto <D.44801>;
  <D.44800>:
  operator delete (this);
  goto <D.44802>;
  <D.44801>:
  <D.44802>:
}


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.42506>:
  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.44806;
  const void * * iftmp.32;
  struct basic_ostream * D.44812;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * D.44816;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.44821;
  int (*__vtbl_ptr_type) () * D.44822;
  long int D.44823;
  struct basic_ios * D.44825;
  int (*__vtbl_ptr_type) () * iftmp.35;
  _Ios_Openmode D.44830;
  struct __stringbuf_type * D.44831;
  struct basic_streambuf * D.44832;
  sizetype iftmp.36;
  struct basic_ios * D.44837;
  const void * * iftmp.37;

  if (1 != 0) goto <D.44804>; else goto <D.44805>;
  <D.44804>:
  D.44806 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.44806);
  goto <D.44807>;
  <D.44805>:
  <D.44807>:
  try
    {
      if (1 == 0) goto <D.44809>; else goto <D.44810>;
      <D.44809>:
      iftmp.32 = 8B;
      goto <D.44811>;
      <D.44810>:
      iftmp.32 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.44811>:
      D.44812 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.44812, iftmp.32);
      try
        {
          if (1 == 0) goto <D.44814>; else goto <D.44815>;
          <D.44814>:
          D.44816 = 0B;
          iftmp.33 = *D.44816;
          goto <D.44817>;
          <D.44815>:
          iftmp.33 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.44817>:
          this->D.22312._vptr.basic_ostream = iftmp.33;
          if (1 == 0) goto <D.44819>; else goto <D.44820>;
          <D.44819>:
          D.44821 = this->D.22312._vptr.basic_ostream;
          D.44822 = D.44821 + 18446744073709551592;
          D.44823 = MEM[(long int *)D.44822];
          iftmp.34 = (sizetype) D.44823;
          goto <D.44824>;
          <D.44820>:
          iftmp.34 = 88;
          <D.44824>:
          D.44825 = this + iftmp.34;
          if (1 == 0) goto <D.44827>; else goto <D.44828>;
          <D.44827>:
          iftmp.35 = MEM[(const void * *)0B + 24B];
          goto <D.44829>;
          <D.44828>:
          iftmp.35 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.44829>:
          D.44825->D.19008._vptr.ios_base = iftmp.35;
          D.44830 = std::operator| (__mode, 16);
          D.44831 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.44831, D.44830);
          try
            {
              D.44832 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.44834>; else goto <D.44835>;
              <D.44834>:
              D.44821 = this->D.22312._vptr.basic_ostream;
              D.44822 = D.44821 + 18446744073709551592;
              D.44823 = MEM[(long int *)D.44822];
              iftmp.36 = (sizetype) D.44823;
              goto <D.44836>;
              <D.44835>:
              iftmp.36 = 88;
              <D.44836>:
              D.44837 = this + iftmp.36;
              std::basic_ios<char>::init (D.44837, D.44832);
            }
          catch
            {
              D.44831 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.44831);
            }
        }
      catch
        {
          if (1 == 0) goto <D.44839>; else goto <D.44840>;
          <D.44839>:
          iftmp.37 = 8B;
          goto <D.44841>;
          <D.44840>:
          iftmp.37 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.44841>:
          D.44812 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.44812, iftmp.37);
        }
    }
  catch
    {
      if (1 != 0) goto <D.44842>; else goto <D.44843>;
      <D.44842>:
      D.44806 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.44806);
      goto <D.44844>;
      <D.44843>:
      <D.44844>:
    }
}


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

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


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.44851;
  int (*__vtbl_ptr_type) () * iftmp.38;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.44860;
  int (*__vtbl_ptr_type) () * D.44861;
  long int D.44862;
  struct basic_ios * D.44864;
  int (*__vtbl_ptr_type) () * iftmp.40;
  sizetype iftmp.41;
  struct basic_ios * D.44873;

  if (0 != 0) goto <D.44849>; else goto <D.44850>;
  <D.44849>:
  D.44851 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.44851);
  goto <D.44852>;
  <D.44850>:
  <D.44852>:
  try
    {
      if (0 == 0) goto <D.44854>; else goto <D.44855>;
      <D.44854>:
      iftmp.38 = *__vtt_parm;
      goto <D.44856>;
      <D.44855>:
      iftmp.38 = &MEM[(void *)&_ZTVSo + 24B];
      <D.44856>:
      this->_vptr.basic_ostream = iftmp.38;
      if (0 == 0) goto <D.44858>; else goto <D.44859>;
      <D.44858>:
      D.44860 = this->_vptr.basic_ostream;
      D.44861 = D.44860 + 18446744073709551592;
      D.44862 = MEM[(long int *)D.44861];
      iftmp.39 = (sizetype) D.44862;
      goto <D.44863>;
      <D.44859>:
      iftmp.39 = 8;
      <D.44863>:
      D.44864 = this + iftmp.39;
      if (0 == 0) goto <D.44866>; else goto <D.44867>;
      <D.44866>:
      iftmp.40 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.44868>;
      <D.44867>:
      iftmp.40 = &MEM[(void *)&_ZTVSo + 64B];
      <D.44868>:
      D.44864->D.19008._vptr.ios_base = iftmp.40;
      if (0 == 0) goto <D.44870>; else goto <D.44871>;
      <D.44870>:
      D.44860 = this->_vptr.basic_ostream;
      D.44861 = D.44860 + 18446744073709551592;
      D.44862 = MEM[(long int *)D.44861];
      iftmp.41 = (sizetype) D.44862;
      goto <D.44872>;
      <D.44871>:
      iftmp.41 = 8;
      <D.44872>:
      D.44873 = this + iftmp.41;
      std::basic_ios<char>::init (D.44873, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.44874>; else goto <D.44875>;
      <D.44874>:
      D.44851 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.44851);
      goto <D.44876>;
      <D.44875>:
      <D.44876>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.44878;
  int __a.42;
  int __b.43;
  int D.44881;

  __a.42 = (int) __a;
  __b.43 = (int) __b;
  D.44881 = __a.42 | __b.43;
  D.44878 = (_Ios_Openmode) D.44881;
  return D.44878;
}


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.44883;
  struct __string_type * D.44884;

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

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


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

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

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


