int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.38592;
  int D.38595;
  int iftmp.1;
  bool D.38597;
  struct bind_return_functor D.36313;
  struct foo D.35565;
  int D.38601;
  const struct string D.36319;
  struct allocator D.36318;
  struct allocator D.36322;
  struct bind_return_functor D.36677;
  struct reference_wrapper D.38602;
  struct foo D.36324;
  struct basic_string & D.38603;
  const struct string D.36683;
  struct allocator D.36682;
  const struct slot D.37196;
  struct bind_return_functor D.37183;
  struct reference_wrapper D.38604;
  struct foo D.36838;
  struct bar D.37199;
  const int D.37198;
  int D.38605;
  const struct string D.37202;
  struct allocator D.37201;
  struct bar D.37204;
  const int D.37203;
  int D.38606;
  const struct string D.37207;
  struct allocator D.37206;
  int iftmp.2;
  bool D.38608;

  {
    struct TestUtilities * util;
    struct string str;
    struct slot sl;

    try
      {
        util = TestUtilities::get_instance ();
        D.38592 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.38592;
        if (retval.0 != 0) goto <D.38593>; else goto <D.38594>;
        <D.38593>:
        D.38597 = TestUtilities::get_result_and_delete_instance ();
        if (D.38597 != 0) goto <D.38598>; else goto <D.38599>;
        <D.38598>:
        iftmp.1 = 0;
        goto <D.38600>;
        <D.38599>:
        iftmp.1 = 1;
        <D.38600>:
        D.38595 = iftmp.1;
        return D.38595;
        <D.38594>:
        try
          {
            D.36313 = sigc::bind_return<int, {anonymous}::foo> (&D.35565, -12345);
            try
              {
                D.38601 = sigc::bind_return_functor<int, {anonymous}::foo>::operator()<int> (&D.36313, 5);
                std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38601);
              }
            finally
              {
                D.36313 = {CLOBBER};
              }
          }
        finally
          {
            D.35565 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.36318);
        try
          {
            std::basic_string<char>::basic_string (&D.36319, "foo(int 5) -12345", &D.36318);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.36319);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.36319);
                D.36319 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.36318);
            D.36318 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.36322);
        try
          {
            std::basic_string<char>::basic_string (&str, "guest book", &D.36322);
          }
        finally
          {
            try
              {
                std::allocator<char>::~allocator (&D.36322);
              }
            catch
              {
                std::basic_string<char>::~basic_string (&str);
              }
            D.36322 = {CLOBBER};
          }
        try
          {
            D.38602 = sigc::ref<std::basic_string<char> > (&str);
            try
              {
                D.36677 = sigc::bind_return<sigc::reference_wrapper<std::basic_string<char> >, {anonymous}::foo> (&D.36324, D.38602);
                try
                  {
                    D.38603 = sigc::bind_return_functor<sigc::reference_wrapper<std::basic_string<char> >, {anonymous}::foo>::operator()<int> (&D.36677, 6);
                    std::basic_string<char>::operator= (D.38603, "main");
                  }
                finally
                  {
                    D.36677 = {CLOBBER};
                  }
              }
            finally
              {
                D.36324 = {CLOBBER};
              }
            std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &str);
            std::allocator<char>::allocator (&D.36682);
            try
              {
                std::basic_string<char>::basic_string (&D.36683, "foo(int 6) main", &D.36682);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.36683);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.36683);
                    D.36683 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.36682);
                D.36682 = {CLOBBER};
              }
            sigc::slot<{anonymous}::bar, int>::slot (&sl);
            try
              {
                {
                  struct bar choco;

                  try
                    {
                      {anonymous}::bar::bar (&choco, -1);
                      try
                        {
                          D.38604 = sigc::ref<{anonymous}::bar> (&choco);
                          try
                            {
                              D.37183 = sigc::bind_return<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> (&D.36838, D.38604); [return slot optimization]
                              try
                                {
                                  sigc::slot<{anonymous}::bar, int>::slot<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&D.37196, &D.37183);
                                  try
                                    {
                                      sigc::slot<{anonymous}::bar, int>::operator= (&sl, &D.37196);
                                    }
                                  finally
                                    {
                                      sigc::slot<{anonymous}::bar, int>::~slot (&D.37196);
                                      D.37196 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.37183 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.36838 = {CLOBBER};
                            }
                          D.37198 = 7;
                          try
                            {
                              D.37199 = sigc::slot1<{anonymous}::bar, int>::operator() (&sl.D.36778, &D.37198); [return slot optimization]
                              try
                                {
                                  D.38605 = {anonymous}::bar::operator int (&D.37199);
                                  std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38605);
                                }
                              finally
                                {
                                  {anonymous}::bar::~bar (&D.37199);
                                  D.37199 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.37198 = {CLOBBER};
                            }
                          std::allocator<char>::allocator (&D.37201);
                          try
                            {
                              std::basic_string<char>::basic_string (&D.37202, "foo(int 7) -1", &D.37201);
                              try
                                {
                                  TestUtilities::check_result (util, &result_stream, &D.37202);
                                }
                              finally
                                {
                                  std::basic_string<char>::~basic_string (&D.37202);
                                  D.37202 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              std::allocator<char>::~allocator (&D.37201);
                              D.37201 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          {anonymous}::bar::~bar (&choco);
                        }
                    }
                  finally
                    {
                      choco = {CLOBBER};
                    }
                }
                D.37203 = 8;
                try
                  {
                    D.37204 = sigc::slot1<{anonymous}::bar, int>::operator() (&sl.D.36778, &D.37203); [return slot optimization]
                    try
                      {
                        D.38606 = {anonymous}::bar::operator int (&D.37204);
                        std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38606);
                      }
                    finally
                      {
                        {anonymous}::bar::~bar (&D.37204);
                        D.37204 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.37203 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.37206);
                try
                  {
                    std::basic_string<char>::basic_string (&D.37207, "0", &D.37206);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.37207);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.37207);
                        D.37207 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.37206);
                    D.37206 = {CLOBBER};
                  }
                D.38608 = TestUtilities::get_result_and_delete_instance ();
                if (D.38608 != 0) goto <D.38609>; else goto <D.38610>;
                <D.38609>:
                iftmp.2 = 0;
                goto <D.38611>;
                <D.38610>:
                iftmp.2 = 1;
                <D.38611>:
                D.38595 = iftmp.2;
                return D.38595;
              }
            finally
              {
                sigc::slot<{anonymous}::bar, int>::~slot (&sl);
              }
          }
        finally
          {
            std::basic_string<char>::~basic_string (&str);
          }
      }
    finally
      {
        str = {CLOBBER};
        sl = {CLOBBER};
      }
  }
  D.38595 = 0;
  return D.38595;
}


sigc::bind_return_functor<T_return, T_functor> sigc::bind_return(const T_functor&, T_return) [with T_return = int; T_functor = {anonymous}::foo] (const struct foo & _A_functor, int _A_ret_value)
{
  struct bind_return_functor D.38648;
  struct bind_return_functor D.37310;

  sigc::bind_return_functor<int, {anonymous}::foo>::bind_return_functor (&D.37310, _A_functor, &_A_ret_value);
  try
    {
      D.38648 = D.37310;
      return D.38648;
    }
  finally
    {
      D.37310 = {CLOBBER};
    }
}


sigc::bind_return_functor<T_return, T_functor>::bind_return_functor(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_base>::take) [with T_return = int; T_functor = {anonymous}::foo; typename sigc::type_trait<T_derived>::take = const {anonymous}::foo&; typename sigc::type_trait<T_base>::take = const int&] (struct bind_return_functor * const this, const struct foo & _A_functor, const int & _A_ret_value)
{
  struct adapts * D.38651;
  struct bound_argument * D.38652;

  D.38651 = &this->D.36310;
  sigc::adapts<{anonymous}::foo>::adapts (D.38651, _A_functor);
  D.38652 = &this->ret_value_;
  sigc::bound_argument<int>::bound_argument (D.38652, _A_ret_value);
}


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

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


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


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

}


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


sigc::bound_argument<T_type>::bound_argument(const T_type&) [with T_type = int] (struct bound_argument * const this, const int & _A_argument)
{
  int D.38654;

  D.38654 = *_A_argument;
  this->visited_ = D.38654;
}


typename sigc::unwrap_reference<T_type>::type sigc::bind_return_functor<T_return, T_functor>::operator()(T_arg1) [with T_arg1 = int; T_return = int; T_functor = {anonymous}::foo; typename sigc::unwrap_reference<T_type>::type = int] (struct bind_return_functor * const this, int _A_a1)
{
  struct adaptor_type * D.38655;
  type D.38656;
  struct bound_argument * D.38657;
  int & D.38658;

  D.38655 = &this->D.36310.functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<int&> (D.38655, &_A_a1);
  D.38657 = &this->ret_value_;
  D.38658 = sigc::bound_argument<int>::invoke (D.38657);
  D.38656 = *D.38658;
  return D.38656;
}


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

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


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

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


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.38669;
  int (*__vtbl_ptr_type) () * D.38670;
  long int D.38671;
  sizetype D.38672;
  struct basic_ios * D.38673;
  long unsigned int D.38675;
  long int D.38676;
  struct basic_ostream & D.38677;

  if (__s == 0B) goto <D.38667>; else goto <D.38668>;
  <D.38667>:
  D.38669 = __out->_vptr.basic_ostream;
  D.38670 = D.38669 + 18446744073709551592;
  D.38671 = MEM[(long int *)D.38670];
  D.38672 = (sizetype) D.38671;
  D.38673 = __out + D.38672;
  std::basic_ios<char>::setstate (D.38673, 1);
  goto <D.38674>;
  <D.38668>:
  D.38675 = std::char_traits<char>::length (__s);
  D.38676 = (long int) D.38675;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.38676);
  <D.38674>:
  D.38677 = __out;
  return D.38677;
}


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.38679;
  _Ios_Iostate D.38680;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.38687 = __a.3 | __b.4;
  D.38684 = (_Ios_Iostate) D.38687;
  return D.38684;
}


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

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


T_type& sigc::bound_argument<T_type>::invoke() [with T_type = int] (struct bound_argument * const this)
{
  int & D.38691;

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


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = std::basic_string<char>] (struct basic_string & v)
{
  struct reference_wrapper D.38693;
  struct reference_wrapper D.37469;

  sigc::reference_wrapper<std::basic_string<char> >::reference_wrapper (&D.37469, v);
  try
    {
      D.38693 = D.37469;
      return D.38693;
    }
  finally
    {
      D.37469 = {CLOBBER};
    }
}


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


sigc::bind_return_functor<T_return, T_functor> sigc::bind_return(const T_functor&, T_return) [with T_return = sigc::reference_wrapper<std::basic_string<char> >; T_functor = {anonymous}::foo] (const struct foo & _A_functor, struct reference_wrapper _A_ret_value)
{
  struct bind_return_functor D.38696;
  struct bind_return_functor D.37480;

  sigc::bind_return_functor<sigc::reference_wrapper<std::basic_string<char> >, {anonymous}::foo>::bind_return_functor (&D.37480, _A_functor, &_A_ret_value);
  try
    {
      D.38696 = D.37480;
      return D.38696;
    }
  finally
    {
      D.37480 = {CLOBBER};
    }
}


sigc::bind_return_functor<T_return, T_functor>::bind_return_functor(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_base>::take) [with T_return = sigc::reference_wrapper<std::basic_string<char> >; T_functor = {anonymous}::foo; typename sigc::type_trait<T_derived>::take = const {anonymous}::foo&; typename sigc::type_trait<T_base>::take = const sigc::reference_wrapper<std::basic_string<char> >&] (struct bind_return_functor * const this, const struct foo & _A_functor, const struct reference_wrapper & _A_ret_value)
{
  struct adapts * D.38699;
  struct bound_argument * D.38700;

  D.38699 = &this->D.36674;
  sigc::adapts<{anonymous}::foo>::adapts (D.38699, _A_functor);
  D.38700 = &this->ret_value_;
  sigc::bound_argument<sigc::reference_wrapper<std::basic_string<char> > >::bound_argument (D.38700, _A_ret_value);
}


sigc::bound_argument<sigc::reference_wrapper<T_type> >::bound_argument(const sigc::reference_wrapper<T_type>&) [with T_wrapped = std::basic_string<char>] (struct bound_argument * const this, const struct reference_wrapper & _A_argument)
{
  struct basic_string & D.38701;
  struct limit_reference * D.38702;

  D.38701 = sigc::unwrap<std::basic_string<char> > (_A_argument);
  D.38702 = &this->visited_;
  sigc::limit_reference<std::basic_string<char>, false>::limit_reference (D.38702, D.38701);
}


T_type& sigc::unwrap(const sigc::reference_wrapper<T_type>&) [with T_type = std::basic_string<char>] (const struct reference_wrapper & v)
{
  struct basic_string & D.38704;

  D.38704 = sigc::reference_wrapper<std::basic_string<char> >::operator std::basic_string<char>& (v);
  return D.38704;
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = std::basic_string<char>] (const struct reference_wrapper * const this)
{
  struct basic_string & D.38706;

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


sigc::limit_reference<T_type, I_derives_trackable>::limit_reference(T_type&) [with T_type = std::basic_string<char>; bool I_derives_trackable = false] (struct limit_reference * const this, struct basic_string & _A_target)
{
  this->visited = _A_target;
}


typename sigc::unwrap_reference<T_type>::type sigc::bind_return_functor<T_return, T_functor>::operator()(T_arg1) [with T_arg1 = int; T_return = sigc::reference_wrapper<std::basic_string<char> >; T_functor = {anonymous}::foo; typename sigc::unwrap_reference<T_type>::type = std::basic_string<char>&] (struct bind_return_functor * const this, int _A_a1)
{
  struct adaptor_type * D.38708;
  struct basic_string & D.38709;
  struct bound_argument * D.38710;

  D.38708 = &this->D.36674.functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<int&> (D.38708, &_A_a1);
  D.38710 = &this->ret_value_;
  D.38709 = sigc::bound_argument<sigc::reference_wrapper<std::basic_string<char> > >::invoke (D.38710);
  return D.38709;
}


T_wrapped& sigc::bound_argument<sigc::reference_wrapper<T_type> >::invoke() [with T_wrapped = std::basic_string<char>] (struct bound_argument * const this)
{
  struct basic_string & D.38713;
  struct limit_reference * D.38714;

  D.38714 = &this->visited_;
  D.38713 = sigc::limit_reference<std::basic_string<char>, false>::invoke (D.38714);
  return D.38713;
}


T_type& sigc::limit_reference<T_type, I_derives_trackable>::invoke() const [with T_type = std::basic_string<char>; bool I_derives_trackable = false] (const struct limit_reference * const this)
{
  struct basic_string & D.38716;

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


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

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


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

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


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.38725;
  long unsigned int D.38726;
  long int D.38727;
  const char * D.38728;

  D.38726 = std::basic_string<char>::size (__str);
  D.38727 = (long int) D.38726;
  D.38728 = std::basic_string<char>::data (__str);
  D.38725 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.38728, D.38727);
  return D.38725;
}


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.38733;
  struct _Rep * D.38734;

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


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.38737;
  char * D.38738;

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


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

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


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

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


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot() [with T_return = {anonymous}::bar; T_arg1 = int] (struct slot * const this)
{
  struct slot1 * D.38746;

  D.38746 = &this->D.36778;
  sigc::slot1<{anonymous}::bar, int>::slot1 (D.38746);
  try
    {

    }
  catch
    {
      D.38746 = &this->D.36778;
      sigc::slot1<{anonymous}::bar, int>::~slot1 (D.38746);
    }
}


sigc::slot1<T_return, T_arg1>::slot1() [with T_return = {anonymous}::bar; T_arg1 = int] (struct slot1 * const this)
{
  struct slot_base * D.38747;

  D.38747 = &this->D.36736;
  sigc::slot_base::slot_base (D.38747);
  try
    {

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


{anonymous}::bar::bar(int) (struct bar * const this, int i)
{
  struct trackable * D.38748;

  D.38748 = &this->D.35553;
  sigc::trackable::trackable (D.38748);
  try
    {
      this->i_ = i;
    }
  catch
    {
      D.38748 = &this->D.35553;
      sigc::trackable::~trackable (D.38748);
    }
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::bar] (struct bar & v)
{
  struct reference_wrapper D.38749;
  struct reference_wrapper D.37488;

  sigc::reference_wrapper<{anonymous}::bar>::reference_wrapper (&D.37488, v);
  try
    {
      D.38749 = D.37488;
      return D.38749;
    }
  finally
    {
      D.37488 = {CLOBBER};
    }
}


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


sigc::bind_return_functor<T_return, T_functor> sigc::bind_return(const T_functor&, T_return) [with T_return = sigc::reference_wrapper<{anonymous}::bar>; T_functor = {anonymous}::foo] (const struct foo & _A_functor, struct reference_wrapper _A_ret_value)
{
  sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>::bind_return_functor (&<retval>, _A_functor, &_A_ret_value);
  return <retval>;
}


sigc::bind_return_functor<T_return, T_functor>::bind_return_functor(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_base>::take) [with T_return = sigc::reference_wrapper<{anonymous}::bar>; T_functor = {anonymous}::foo; typename sigc::type_trait<T_derived>::take = const {anonymous}::foo&; typename sigc::type_trait<T_base>::take = const sigc::reference_wrapper<{anonymous}::bar>&] (struct bind_return_functor * const this, const struct foo & _A_functor, const struct reference_wrapper & _A_ret_value)
{
  struct adapts * D.38754;
  struct bound_argument * D.38755;

  D.38754 = &this->D.37180;
  sigc::adapts<{anonymous}::foo>::adapts (D.38754, _A_functor);
  D.38755 = &this->ret_value_;
  sigc::bound_argument<sigc::reference_wrapper<{anonymous}::bar> >::bound_argument (D.38755, _A_ret_value);
}


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

  D.38756 = sigc::unwrap<{anonymous}::bar> (_A_argument);
  D.38757 = &this->visited_;
  sigc::limit_reference<{anonymous}::bar, true>::limit_reference (D.38757, D.38756);
}


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

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


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

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


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

  D.38763 = &_A_target->D.35553;
  this->visited = D.38763;
  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::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>; T_return = {anonymous}::bar; T_arg1 = int] (struct slot * const this, const struct bind_return_functor & _A_func)
{
  struct slot1 * D.38764;

  D.38764 = &this->D.36778;
  sigc::slot1<{anonymous}::bar, int>::slot1<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (D.38764, _A_func);
  try
    {

    }
  catch
    {
      D.38764 = &this->D.36778;
      sigc::slot1<{anonymous}::bar, int>::~slot1 (D.38764);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>; T_return = {anonymous}::bar; T_arg1 = int] (struct slot1 * const this, const struct bind_return_functor & _A_func)
{
  void * D.37741;
  struct slot_base * D.38765;
  struct rep_type * D.38766;
  void * (*<T1711>) (void *) D.38767;

  D.37741 = operator new (72);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> >::typed_slot_rep (D.37741, _A_func);
    }
  catch
    {
      operator delete (D.37741);
    }
  D.38765 = &this->D.36736;
  sigc::slot_base::slot_base (D.38765, D.37741);
  try
    {
      D.38766 = this->D.36736.rep_;
      D.38767 = sigc::internal::slot_call1<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>, {anonymous}::bar, int>::address ();
      D.38766->call_ = D.38767;
    }
  catch
    {
      D.38765 = &this->D.36736;
      sigc::slot_base::~slot_base (D.38765);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (struct typed_slot_rep * const this, const struct bind_return_functor & functor)
{
  struct slot_rep * D.38770;
  struct adaptor_type * D.38771;
  struct slot_do_bind D.37941;

  D.38770 = &this->D.37729;
  sigc::internal::slot_rep::slot_rep (D.38770, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.38771 = &this->functor_;
      D.38770 = &this->D.37729;
      sigc::internal::slot_do_bind::slot_do_bind (&D.37941, D.38770);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&D.37941, D.38771);
        }
      finally
        {
          D.37941 = {CLOBBER};
        }
    }
  catch
    {
      D.38770 = &this->D.37729;
      sigc::internal::slot_rep::~slot_rep (D.38770);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (void * data)
{
  void * D.38774;
  void * D.38038;
  struct slot_rep * a_rep;

  a_rep = data;
  D.38038 = operator new (72);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> >::typed_slot_rep (D.38038, a_rep);
    }
  catch
    {
      operator delete (D.38038);
    }
  D.38774 = D.38038;
  return D.38774;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.38778;
  struct slot_rep * D.38779;
  struct adaptor_type * D.38780;
  struct slot_do_bind D.38136;

  D.38778 = cl->D.37729.call_;
  D.38779 = &this->D.37729;
  sigc::internal::slot_rep::slot_rep (D.38779, D.38778, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.38780 = &this->functor_;
      D.38779 = &this->D.37729;
      sigc::internal::slot_do_bind::slot_do_bind (&D.38136, D.38779);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&D.38136, D.38780);
        }
      finally
        {
          D.38136 = {CLOBBER};
        }
    }
  catch
    {
      D.38779 = &this->D.37729;
      sigc::internal::slot_rep::~slot_rep (D.38779);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (void * data)
{
  struct adaptor_type * D.38783;
  struct slot_do_unbind D.38023;
  void * D.38784;
  struct self * self_;

  self_ = data;
  self_->D.37729.call_ = 0B;
  self_->D.37729.destroy_ = 0B;
  D.38783 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.38023, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&D.38023, D.38783);
    }
  finally
    {
      D.38023 = {CLOBBER};
    }
  D.38784 = 0B;
  return D.38784;
}


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::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (const struct slot_do_unbind & _A_action, const struct bind_return_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::bind_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = sigc::reference_wrapper<{anonymous}::bar>; T_functor = {anonymous}::foo] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_target)
{
  const struct bound_argument * D.38788;
  struct adaptor_type * D.38789;

  D.38788 = &_A_target->ret_value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::bar> > > (_A_action, D.38788);
  D.38789 = &_A_target->D.37180.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<{anonymous}::foo> > (_A_action, D.38789);
}


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


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

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


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

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


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


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

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


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

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


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

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

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


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


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

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


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


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


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


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


sigc::internal::slot_rep::slot_rep(sigc::internal::hook, sigc::internal::hook, sigc::internal::hook) (struct slot_rep * const this, void * (*hook) (void *) call__, void * (*hook) (void *) destroy__, void * (*hook) (void *) dup__)
{
  struct trackable * D.38799;

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


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::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>] (const struct slot_do_bind & _A_action, const struct bind_return_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::bind_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = sigc::reference_wrapper<{anonymous}::bar>; T_functor = {anonymous}::foo] (const struct limit_derived_target & _A_action, const struct bind_return_functor & _A_target)
{
  const struct bound_argument * D.38801;
  struct adaptor_type * D.38802;

  D.38801 = &_A_target->ret_value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::bar> > > (_A_action, D.38801);
  D.38802 = &_A_target->D.37180.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<{anonymous}::foo> > (_A_action, D.38802);
}


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


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

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


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


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

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


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

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

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


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


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

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


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


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


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


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


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

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


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

  D.38811 = this->destroy_;
  if (D.38811 != 0B) goto <D.38812>; else goto <D.38813>;
  <D.38812>:
  D.38811 = this->destroy_;
  D.38811 (this);
  goto <D.38814>;
  <D.38813>:
  <D.38814>:
}


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

  D.38815 = call_it;
  return D.38815;
}


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

  typed_rep = rep;
  D.38818 = &typed_rep->functor_;
  D.38819 = sigc::bind_return_functor<sigc::reference_wrapper<{anonymous}::bar>, {anonymous}::foo>::operator()<const int&> (D.38818, a_1);
  {anonymous}::bar::bar (<retval>, D.38819);
  return <retval>;
}


typename sigc::unwrap_reference<T_type>::type sigc::bind_return_functor<T_return, T_functor>::operator()(T_arg1) [with T_arg1 = const int&; T_return = sigc::reference_wrapper<{anonymous}::bar>; T_functor = {anonymous}::foo; typename sigc::unwrap_reference<T_type>::type = {anonymous}::bar&] (struct bind_return_functor * const this, const int & _A_a1)
{
  struct adaptor_type * D.38822;
  struct bar & D.38823;
  struct bound_argument * D.38824;

  D.38822 = &this->D.37180.functor_;
  sigc::adaptor_functor<{anonymous}::foo>::operator()<const int&> (D.38822, _A_a1);
  D.38824 = &this->ret_value_;
  D.38823 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::bar> >::invoke (D.38824);
  return D.38823;
}


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

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


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

  D.38831 = &this->visited_;
  D.38830 = sigc::limit_reference<{anonymous}::bar, true>::invoke (D.38831);
  return D.38830;
}


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

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


{anonymous}::bar::bar(const {anonymous}::bar&) (struct bar * const this, const struct bar & D.36821)
{
  const struct trackable * D.38835;
  struct trackable * D.38836;
  int D.38837;

  D.38835 = &D.36821->D.35553;
  D.38836 = &this->D.35553;
  sigc::trackable::trackable (D.38836, D.38835);
  try
    {
      D.38837 = D.36821->i_;
      this->i_ = D.38837;
    }
  catch
    {
      D.38836 = &this->D.35553;
      sigc::trackable::~trackable (D.38836);
    }
}


sigc::slot<{anonymous}::bar, int>& sigc::slot<{anonymous}::bar, int>::operator=(const sigc::slot<{anonymous}::bar, int>&) (struct slot * const this, const struct slot & D.37185)
{
  const struct slot1 * D.38838;
  struct slot1 * D.38839;
  struct slot & D.38840;

  D.38838 = &D.37185->D.36778;
  D.38839 = &this->D.36778;
  sigc::slot1<{anonymous}::bar, int>::operator= (D.38839, D.38838);
  D.38840 = this;
  return D.38840;
}


sigc::slot1<T_return, T_arg1>& sigc::slot1<T_return, T_arg1>::operator=(const sigc::slot1<T_return, T_arg1>&) [with T_return = {anonymous}::bar; T_arg1 = int] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.38842;
  struct slot_base * D.38843;
  struct slot1 & D.38844;

  D.38842 = &src->D.36736;
  D.38843 = &this->D.36736;
  sigc::slot_base::operator= (D.38843, D.38842);
  D.38844 = this;
  return D.38844;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = {anonymous}::bar; T_arg1 = int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const int&] (const struct slot1 * const this, const int & _A_a1)
{
  bool retval.5;
  bool iftmp.6;
  const struct slot_base * D.38851;
  bool D.38852;
  bool D.38853;
  bool D.38855;
  bool D.38856;
  struct rep_type * D.38860;
  void * (*<T1711>) (void *) D.38861;

  D.38851 = &this->D.36736;
  D.38852 = sigc::slot_base::empty (D.38851);
  D.38853 = ~D.38852;
  if (D.38853 != 0) goto <D.38854>; else goto <D.38849>;
  <D.38854>:
  D.38851 = &this->D.36736;
  D.38855 = sigc::slot_base::blocked (D.38851);
  D.38856 = ~D.38855;
  if (D.38856 != 0) goto <D.38857>; else goto <D.38849>;
  <D.38857>:
  iftmp.6 = 1;
  goto <D.38850>;
  <D.38849>:
  iftmp.6 = 0;
  <D.38850>:
  retval.5 = iftmp.6;
  if (retval.5 != 0) goto <D.38858>; else goto <D.38859>;
  <D.38858>:
  D.38860 = this->D.36736.rep_;
  D.38861 = D.38860->call_;
  D.38860 = this->D.36736.rep_;
  *<retval> = D.38861 (D.38860, _A_a1); [return slot optimization]
  return <retval>;
  <D.38859>:
  {anonymous}::bar::bar (<retval>, 0);
  return <retval>;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.38863;
  bool iftmp.7;
  struct rep_type * D.38868;
  void * (*<T1711>) (void *) D.38870;

  D.38868 = this->rep_;
  if (D.38868 == 0B) goto <D.38865>; else goto <D.38869>;
  <D.38869>:
  D.38868 = this->rep_;
  D.38870 = D.38868->call_;
  if (D.38870 == 0B) goto <D.38865>; else goto <D.38866>;
  <D.38865>:
  iftmp.7 = 1;
  goto <D.38867>;
  <D.38866>:
  iftmp.7 = 0;
  <D.38867>:
  D.38863 = iftmp.7;
  return D.38863;
}


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

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


{anonymous}::bar::operator int() (struct bar * const this)
{
  int D.38874;

  D.38874 = this->i_;
  return D.38874;
}


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

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

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


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

  try
    {
      {

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


{anonymous}::bar::~bar() (struct bar * const this)
{
  struct trackable * D.38878;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.38878 = &this->D.35553;
            sigc::trackable::~trackable (D.38878);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36835>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<{anonymous}::bar, int>::~slot() (struct slot * const this)
{
  struct slot1 * D.38882;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.38882 = &this->D.36778;
            sigc::slot1<{anonymous}::bar, int>::~slot1 (D.38882);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36809>:
}


sigc::slot1<{anonymous}::bar, int>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.38884;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.38884 = &this->D.36736;
            sigc::slot_base::~slot_base (D.38884);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36804>:
}


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.37464;
  struct _Rep * D.38886;
  struct _Alloc_hider * D.38887;

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


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

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


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

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


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

  try
    {
      {

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


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.8;
  struct _Rep & D.38898;
  bool D.38899;
  long int D.38900;
  long int D.38901;
  bool retval.9;
  _Atomic_word * D.38905;
  int D.38906;

  D.38898 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.38899 = D.38898 != this;
  D.38900 = (long int) D.38899;
  D.38901 = __builtin_expect (D.38900, 0);
  retval.8 = D.38901 != 0;
  if (retval.8 != 0) goto <D.38902>; else goto <D.38903>;
  <D.38902>:
  D.38905 = &this->D.11865._M_refcount;
  D.38906 = __gnu_cxx::__exchange_and_add_dispatch (D.38905, -1);
  retval.9 = D.38906 <= 0;
  if (retval.9 != 0) goto <D.38907>; else goto <D.38908>;
  <D.38907>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.38909>;
  <D.38908>:
  <D.38909>:
  goto <D.38910>;
  <D.38903>:
  <D.38910>:
}


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

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


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

  D.38915 = __gthread_active_p ();
  retval.10 = D.38915 != 0;
  if (retval.10 != 0) goto <D.38916>; else goto <D.38917>;
  <D.38916>:
  D.38918 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.38918;
  <D.38917>:
  D.38918 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.38918;
}


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

  D.38921 = __gthrw___pthread_key_create != 0B;
  D.38920 = (int) D.38921;
  return D.38920;
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.38927;
  int D.38928;
  _Atomic_word D.38929;
  _Atomic_word __result;

  __result = *__mem;
  D.38927 = *__mem;
  D.38928 = D.38927 + __val;
  *__mem = D.38928;
  D.38929 = __result;
  return D.38929;
}


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


(static initializers for test_bind_return.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.38931>; else goto <D.38932>;
  <D.38931>:
  if (__priority == 65535) goto <D.38933>; else goto <D.38934>;
  <D.38933>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.38935>;
  <D.38934>:
  <D.38935>:
  goto <D.38936>;
  <D.38932>:
  <D.38936>:
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostringstream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.12;
  const void * * D.38940;
  sizetype iftmp.13;
  int (*__vtbl_ptr_type) () * D.38945;
  int (*__vtbl_ptr_type) () * D.38946;
  long int D.38947;
  struct basic_ios * D.38949;
  int (*__vtbl_ptr_type) () * iftmp.14;
  struct __stringbuf_type * D.38954;
  const void * * iftmp.15;
  struct basic_ostream * D.38959;
  int D.38960;
  struct basic_ios * D.38963;
  int D.38965;

  {
    if (2 == 0) goto <D.38938>; else goto <D.38939>;
    <D.38938>:
    D.38940 = 0B;
    iftmp.12 = *D.38940;
    goto <D.38941>;
    <D.38939>:
    iftmp.12 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.38941>:
    this->D.22312._vptr.basic_ostream = iftmp.12;
    if (2 == 0) goto <D.38943>; else goto <D.38944>;
    <D.38943>:
    D.38945 = this->D.22312._vptr.basic_ostream;
    D.38946 = D.38945 + 18446744073709551592;
    D.38947 = MEM[(long int *)D.38946];
    iftmp.13 = (sizetype) D.38947;
    goto <D.38948>;
    <D.38944>:
    iftmp.13 = 88;
    <D.38948>:
    D.38949 = this + iftmp.13;
    if (2 == 0) goto <D.38951>; else goto <D.38952>;
    <D.38951>:
    iftmp.14 = MEM[(const void * *)0B + 24B];
    goto <D.38953>;
    <D.38952>:
    iftmp.14 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.38953>:
    D.38949->D.19008._vptr.ios_base = iftmp.14;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.38954 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.38954);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.38956>; else goto <D.38957>;
                <D.38956>:
                iftmp.15 = 8B;
                goto <D.38958>;
                <D.38957>:
                iftmp.15 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.38958>:
                D.38959 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.38959, iftmp.15);
              }
          }
        finally
          {
            D.38960 = 2;
            if (D.38960 != 0) goto <D.38961>; else goto <D.38962>;
            <D.38961>:
            D.38963 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.38963);
            goto <D.38964>;
            <D.38962>:
            <D.38964>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38522>:
  D.38965 = 0;
  if (D.38965 != 0) goto <D.38966>; else goto <D.38967>;
  <D.38966>:
  operator delete (this);
  goto <D.38968>;
  <D.38967>:
  <D.38968>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.38978;
  struct basic_streambuf * D.38979;
  int D.38980;

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

              }
            finally
              {
                D.38978 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.38978);
              }
          }
        finally
          {
            D.38979 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.38979);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37291>:
  D.38980 = 0;
  if (D.38980 != 0) goto <D.38981>; else goto <D.38982>;
  <D.38981>:
  operator delete (this);
  goto <D.38983>;
  <D.38982>:
  <D.38983>:
}


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

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

          }
        finally
          {
            D.38986 = &this->_M_buf_locale;
            std::locale::~locale (D.38986);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37580>:
  D.38987 = 0;
  if (D.38987 != 0) goto <D.38988>; else goto <D.38989>;
  <D.38988>:
  operator delete (this);
  goto <D.38990>;
  <D.38989>:
  <D.38990>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.37295>:
  operator delete (this);
}


std::basic_ostream<_CharT, _Traits>::~basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.16;
  sizetype iftmp.17;
  int (*__vtbl_ptr_type) () * D.38998;
  int (*__vtbl_ptr_type) () * D.38999;
  long int D.39000;
  struct basic_ios * D.39002;
  int (*__vtbl_ptr_type) () * iftmp.18;
  int D.39007;
  struct basic_ios * D.39010;
  int D.39012;

  {
    if (0 == 0) goto <D.38992>; else goto <D.38993>;
    <D.38992>:
    iftmp.16 = *__vtt_parm;
    goto <D.38994>;
    <D.38993>:
    iftmp.16 = &MEM[(void *)&_ZTVSo + 24B];
    <D.38994>:
    this->_vptr.basic_ostream = iftmp.16;
    if (0 == 0) goto <D.38996>; else goto <D.38997>;
    <D.38996>:
    D.38998 = this->_vptr.basic_ostream;
    D.38999 = D.38998 + 18446744073709551592;
    D.39000 = MEM[(long int *)D.38999];
    iftmp.17 = (sizetype) D.39000;
    goto <D.39001>;
    <D.38997>:
    iftmp.17 = 8;
    <D.39001>:
    D.39002 = this + iftmp.17;
    if (0 == 0) goto <D.39004>; else goto <D.39005>;
    <D.39004>:
    iftmp.18 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.39006>;
    <D.39005>:
    iftmp.18 = &MEM[(void *)&_ZTVSo + 64B];
    <D.39006>:
    D.39002->D.19008._vptr.ios_base = iftmp.18;
    try
      {
        try
          {

          }
        finally
          {
            D.39007 = 0;
            if (D.39007 != 0) goto <D.39008>; else goto <D.39009>;
            <D.39008>:
            D.39010 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.39010);
            goto <D.39011>;
            <D.39009>:
            <D.39011>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37565>:
  D.39012 = 0;
  if (D.39012 != 0) goto <D.39013>; else goto <D.39014>;
  <D.39013>:
  operator delete (this);
  goto <D.39015>;
  <D.39014>:
  <D.39015>:
}


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

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

          }
        finally
          {
            D.39017 = &this->D.19008;
            std::ios_base::~ios_base (D.39017);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37553>:
  D.39018 = 0;
  if (D.39018 != 0) goto <D.39019>; else goto <D.39020>;
  <D.39019>:
  operator delete (this);
  goto <D.39021>;
  <D.39020>:
  <D.39021>:
}


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.37557>:
  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.39025;
  const void * * iftmp.19;
  struct basic_ostream * D.39031;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * D.39035;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.39040;
  int (*__vtbl_ptr_type) () * D.39041;
  long int D.39042;
  struct basic_ios * D.39044;
  int (*__vtbl_ptr_type) () * iftmp.22;
  _Ios_Openmode D.39049;
  struct __stringbuf_type * D.39050;
  struct basic_streambuf * D.39051;
  sizetype iftmp.23;
  struct basic_ios * D.39056;
  const void * * iftmp.24;

  if (1 != 0) goto <D.39023>; else goto <D.39024>;
  <D.39023>:
  D.39025 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.39025);
  goto <D.39026>;
  <D.39024>:
  <D.39026>:
  try
    {
      if (1 == 0) goto <D.39028>; else goto <D.39029>;
      <D.39028>:
      iftmp.19 = 8B;
      goto <D.39030>;
      <D.39029>:
      iftmp.19 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.39030>:
      D.39031 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.39031, iftmp.19);
      try
        {
          if (1 == 0) goto <D.39033>; else goto <D.39034>;
          <D.39033>:
          D.39035 = 0B;
          iftmp.20 = *D.39035;
          goto <D.39036>;
          <D.39034>:
          iftmp.20 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.39036>:
          this->D.22312._vptr.basic_ostream = iftmp.20;
          if (1 == 0) goto <D.39038>; else goto <D.39039>;
          <D.39038>:
          D.39040 = this->D.22312._vptr.basic_ostream;
          D.39041 = D.39040 + 18446744073709551592;
          D.39042 = MEM[(long int *)D.39041];
          iftmp.21 = (sizetype) D.39042;
          goto <D.39043>;
          <D.39039>:
          iftmp.21 = 88;
          <D.39043>:
          D.39044 = this + iftmp.21;
          if (1 == 0) goto <D.39046>; else goto <D.39047>;
          <D.39046>:
          iftmp.22 = MEM[(const void * *)0B + 24B];
          goto <D.39048>;
          <D.39047>:
          iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.39048>:
          D.39044->D.19008._vptr.ios_base = iftmp.22;
          D.39049 = std::operator| (__mode, 16);
          D.39050 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.39050, D.39049);
          try
            {
              D.39051 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.39053>; else goto <D.39054>;
              <D.39053>:
              D.39040 = this->D.22312._vptr.basic_ostream;
              D.39041 = D.39040 + 18446744073709551592;
              D.39042 = MEM[(long int *)D.39041];
              iftmp.23 = (sizetype) D.39042;
              goto <D.39055>;
              <D.39054>:
              iftmp.23 = 88;
              <D.39055>:
              D.39056 = this + iftmp.23;
              std::basic_ios<char>::init (D.39056, D.39051);
            }
          catch
            {
              D.39050 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.39050);
            }
        }
      catch
        {
          if (1 == 0) goto <D.39058>; else goto <D.39059>;
          <D.39058>:
          iftmp.24 = 8B;
          goto <D.39060>;
          <D.39059>:
          iftmp.24 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.39060>:
          D.39031 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.39031, iftmp.24);
        }
    }
  catch
    {
      if (1 != 0) goto <D.39061>; else goto <D.39062>;
      <D.39061>:
      D.39025 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.39025);
      goto <D.39063>;
      <D.39062>:
      <D.39063>:
    }
}


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

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


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.39070;
  int (*__vtbl_ptr_type) () * iftmp.25;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.39079;
  int (*__vtbl_ptr_type) () * D.39080;
  long int D.39081;
  struct basic_ios * D.39083;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  struct basic_ios * D.39092;

  if (0 != 0) goto <D.39068>; else goto <D.39069>;
  <D.39068>:
  D.39070 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.39070);
  goto <D.39071>;
  <D.39069>:
  <D.39071>:
  try
    {
      if (0 == 0) goto <D.39073>; else goto <D.39074>;
      <D.39073>:
      iftmp.25 = *__vtt_parm;
      goto <D.39075>;
      <D.39074>:
      iftmp.25 = &MEM[(void *)&_ZTVSo + 24B];
      <D.39075>:
      this->_vptr.basic_ostream = iftmp.25;
      if (0 == 0) goto <D.39077>; else goto <D.39078>;
      <D.39077>:
      D.39079 = this->_vptr.basic_ostream;
      D.39080 = D.39079 + 18446744073709551592;
      D.39081 = MEM[(long int *)D.39080];
      iftmp.26 = (sizetype) D.39081;
      goto <D.39082>;
      <D.39078>:
      iftmp.26 = 8;
      <D.39082>:
      D.39083 = this + iftmp.26;
      if (0 == 0) goto <D.39085>; else goto <D.39086>;
      <D.39085>:
      iftmp.27 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.39087>;
      <D.39086>:
      iftmp.27 = &MEM[(void *)&_ZTVSo + 64B];
      <D.39087>:
      D.39083->D.19008._vptr.ios_base = iftmp.27;
      if (0 == 0) goto <D.39089>; else goto <D.39090>;
      <D.39089>:
      D.39079 = this->_vptr.basic_ostream;
      D.39080 = D.39079 + 18446744073709551592;
      D.39081 = MEM[(long int *)D.39080];
      iftmp.28 = (sizetype) D.39081;
      goto <D.39091>;
      <D.39090>:
      iftmp.28 = 8;
      <D.39091>:
      D.39092 = this + iftmp.28;
      std::basic_ios<char>::init (D.39092, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.39093>; else goto <D.39094>;
      <D.39093>:
      D.39070 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.39070);
      goto <D.39095>;
      <D.39094>:
      <D.39095>:
    }
}


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

  __a.29 = (int) __a;
  __b.30 = (int) __b;
  D.39100 = __a.29 | __b.30;
  D.39097 = (_Ios_Openmode) D.39100;
  return D.39097;
}


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.39102;
  struct __string_type * D.39103;

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

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


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

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

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


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.37810;
  struct _Rep & D.39106;
  char * D.39107;
  struct _Alloc_hider * D.39108;

  std::allocator<char>::allocator (&D.37810);
  try
    {
      D.39106 = std::basic_string<char>::_S_empty_rep ();
      D.39107 = std::basic_string<char>::_Rep::_M_refdata (D.39106);
      D.39108 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.39108, D.39107, &D.37810);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.37810);
      D.37810 = {CLOBBER};
    }
  try
    {

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


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

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


_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.39114;
  void * D.39115;

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


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


