int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.42875;
  int D.42878;
  int iftmp.1;
  bool D.42880;
  const struct string D.39661;
  struct allocator D.39660;
  const struct slot D.39808;
  struct bound_mem_functor1 D.39795;
  struct 
{
  void MyClass1::<T6fe3> (struct MyClass1 *, int) * __pfn;
  long int __delta;
} D.42884;
  const int D.39810;
  const struct string D.39813;
  struct allocator D.39812;
  const int D.39814;
  const struct string D.39817;
  struct allocator D.39816;
  const struct string D.39839;
  struct allocator D.39838;
  const struct slot D.39976;
  struct bound_mem_functor1 D.39966;
  struct 
{
  void MyClass2::<T6ff3> (struct MyClass2 *, int) * __pfn;
  long int __delta;
} D.42885;
  const int D.39977;
  const struct string D.39980;
  struct allocator D.39979;
  const int D.39981;
  const struct string D.39984;
  struct allocator D.39983;
  const struct string D.39988;
  struct allocator D.39987;
  const struct slot D.40530;
  struct MyAdaptor1 D.40520;
  struct bound_mem_functor1 D.39989;
  struct 
{
  void MyClass1::<T6fe3> (struct MyClass1 *, int) * __pfn;
  long int __delta;
} D.42886;
  const int D.40531;
  const struct string D.40534;
  struct allocator D.40533;
  const int D.40535;
  const struct string D.40538;
  struct allocator D.40537;
  int iftmp.2;
  bool D.42888;

  {
    struct TestUtilities * util;
    struct slot sl1;

    try
      {
        util = TestUtilities::get_instance ();
        D.42875 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.42875;
        if (retval.0 != 0) goto <D.42876>; else goto <D.42877>;
        <D.42876>:
        D.42880 = TestUtilities::get_result_and_delete_instance ();
        if (D.42880 != 0) goto <D.42881>; else goto <D.42882>;
        <D.42881>:
        iftmp.1 = 0;
        goto <D.42883>;
        <D.42882>:
        iftmp.1 = 1;
        <D.42883>:
        D.42878 = iftmp.1;
        return D.42878;
        <D.42877>:
        sigc::slot<void, int>::slot (&sl1);
        try
          {
            {
              struct MyClass1 my_class1;

              try
                {
                  std::allocator<char>::allocator (&D.39660);
                  try
                    {
                      std::basic_string<char>::basic_string (&D.39661, "x=", &D.39660);
                      try
                        {
                          {anonymous}::MyClass1::MyClass1 (&my_class1, &D.39661);
                        }
                      finally
                        {
                          try
                            {
                              std::basic_string<char>::~basic_string (&D.39661);
                            }
                          catch
                            {
                              {anonymous}::MyClass1::~MyClass1 (&my_class1);
                            }
                          D.39661 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      try
                        {
                          std::allocator<char>::~allocator (&D.39660);
                        }
                      catch
                        {
                          {anonymous}::MyClass1::~MyClass1 (&my_class1);
                        }
                      D.39660 = {CLOBBER};
                    }
                  try
                    {
                      D.42884.__pfn = execute;
                      D.42884.__delta = 0;
                      D.39795 = sigc::mem_fun<int, void, {anonymous}::MyClass1, {anonymous}::MyClass1> (&my_class1, D.42884); [return slot optimization]
                      try
                        {
                          sigc::slot<void, int>::slot<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > (&D.39808, &D.39795);
                          try
                            {
                              sigc::slot<void, int>::operator= (&sl1, &D.39808);
                            }
                          finally
                            {
                              sigc::slot<void, int>::~slot (&D.39808);
                              D.39808 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39795 = {CLOBBER};
                        }
                      D.39810 = -2;
                      try
                        {
                          sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.39810);
                        }
                      finally
                        {
                          D.39810 = {CLOBBER};
                        }
                      std::allocator<char>::allocator (&D.39812);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.39813, "x=-2", &D.39812);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.39813);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.39813);
                              D.39813 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.39812);
                          D.39812 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::MyClass1::~MyClass1 (&my_class1);
                    }
                }
              finally
                {
                  my_class1 = {CLOBBER};
                }
            }
            D.39814 = -2;
            try
              {
                sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.39814);
              }
            finally
              {
                D.39814 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.39816);
            try
              {
                std::basic_string<char>::basic_string (&D.39817, "", &D.39816);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.39817);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.39817);
                    D.39817 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.39816);
                D.39816 = {CLOBBER};
              }
            {
              struct MyClass2 my_class2;

              try
                {
                  std::allocator<char>::allocator (&D.39838);
                  try
                    {
                      std::basic_string<char>::basic_string (&D.39839, "y=", &D.39838);
                      try
                        {
                          {anonymous}::MyClass2::MyClass2 (&my_class2, &D.39839);
                        }
                      finally
                        {
                          try
                            {
                              std::basic_string<char>::~basic_string (&D.39839);
                            }
                          catch
                            {
                              {anonymous}::MyClass2::~MyClass2 (&my_class2);
                            }
                          D.39839 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      try
                        {
                          std::allocator<char>::~allocator (&D.39838);
                        }
                      catch
                        {
                          {anonymous}::MyClass2::~MyClass2 (&my_class2);
                        }
                      D.39838 = {CLOBBER};
                    }
                  try
                    {
                      D.42885.__pfn = execute;
                      D.42885.__delta = 0;
                      D.39966 = sigc::mem_fun<int, void, {anonymous}::MyClass2, {anonymous}::MyClass2> (&my_class2, D.42885); [return slot optimization]
                      try
                        {
                          sigc::slot<void, int>::slot<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > (&D.39976, &D.39966);
                          try
                            {
                              sigc::slot<void, int>::operator= (&sl1, &D.39976);
                            }
                          finally
                            {
                              sigc::slot<void, int>::~slot (&D.39976);
                              D.39976 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39966 = {CLOBBER};
                        }
                      D.39977 = 2;
                      try
                        {
                          sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.39977);
                        }
                      finally
                        {
                          D.39977 = {CLOBBER};
                        }
                      std::allocator<char>::allocator (&D.39979);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.39980, "y=2", &D.39979);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.39980);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.39980);
                              D.39980 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.39979);
                          D.39979 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::MyClass2::~MyClass2 (&my_class2);
                    }
                }
              finally
                {
                  my_class2 = {CLOBBER};
                }
            }
            D.39981 = 2;
            try
              {
                sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.39981);
              }
            finally
              {
                D.39981 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.39983);
            try
              {
                std::basic_string<char>::basic_string (&D.39984, "", &D.39983);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.39984);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.39984);
                    D.39984 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.39983);
                D.39983 = {CLOBBER};
              }
            {
              struct MyClass1 my_class3;

              try
                {
                  std::allocator<char>::allocator (&D.39987);
                  try
                    {
                      std::basic_string<char>::basic_string (&D.39988, "a=", &D.39987);
                      try
                        {
                          {anonymous}::MyClass1::MyClass1 (&my_class3, &D.39988);
                        }
                      finally
                        {
                          try
                            {
                              std::basic_string<char>::~basic_string (&D.39988);
                            }
                          catch
                            {
                              {anonymous}::MyClass1::~MyClass1 (&my_class3);
                            }
                          D.39988 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      try
                        {
                          std::allocator<char>::~allocator (&D.39987);
                        }
                      catch
                        {
                          {anonymous}::MyClass1::~MyClass1 (&my_class3);
                        }
                      D.39987 = {CLOBBER};
                    }
                  try
                    {
                      D.42886.__pfn = execute;
                      D.42886.__delta = 0;
                      D.39989 = sigc::mem_fun<int, void, {anonymous}::MyClass1, {anonymous}::MyClass1> (&my_class3, D.42886); [return slot optimization]
                      try
                        {
                          D.40520 = ns1::my_adaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > (&D.39989); [return slot optimization]
                          try
                            {
                              sigc::slot<void, int>::slot<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.40530, &D.40520);
                              try
                                {
                                  sigc::slot<void, int>::operator= (&sl1, &D.40530);
                                }
                              finally
                                {
                                  sigc::slot<void, int>::~slot (&D.40530);
                                  D.40530 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.40520 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39989 = {CLOBBER};
                        }
                      D.40531 = 42;
                      try
                        {
                          sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.40531);
                        }
                      finally
                        {
                          D.40531 = {CLOBBER};
                        }
                      std::allocator<char>::allocator (&D.40533);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.40534, "MyAdaptor1()(_A_arg1) a=42", &D.40533);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.40534);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.40534);
                              D.40534 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.40533);
                          D.40533 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::MyClass1::~MyClass1 (&my_class3);
                    }
                }
              finally
                {
                  my_class3 = {CLOBBER};
                }
            }
            D.40535 = 42;
            try
              {
                sigc::slot1<void, int>::operator() (&sl1.D.39615, &D.40535);
              }
            finally
              {
                D.40535 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.40537);
            try
              {
                std::basic_string<char>::basic_string (&D.40538, "", &D.40537);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.40538);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.40538);
                    D.40538 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.40537);
                D.40537 = {CLOBBER};
              }
            D.42888 = TestUtilities::get_result_and_delete_instance ();
            if (D.42888 != 0) goto <D.42889>; else goto <D.42890>;
            <D.42889>:
            iftmp.2 = 0;
            goto <D.42891>;
            <D.42890>:
            iftmp.2 = 1;
            <D.42891>:
            D.42878 = iftmp.2;
            return D.42878;
          }
        finally
          {
            sigc::slot<void, int>::~slot (&sl1);
          }
      }
    finally
      {
        sl1 = {CLOBBER};
      }
  }
  D.42878 = 0;
  return D.42878;
}


void {anonymous}::MyClass2::execute(int) (struct MyClass2 * const this, int i)
{
  struct string * D.42942;
  struct basic_ostream & D.42943;

  D.42942 = &this->s;
  D.42943 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, D.42942);
  std::basic_ostream<char>::operator<< (D.42943, i);
}


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.42945;
  long unsigned int D.42946;
  long int D.42947;
  const char * D.42948;

  D.42946 = std::basic_string<char>::size (__str);
  D.42947 = (long int) D.42946;
  D.42948 = std::basic_string<char>::data (__str);
  D.42945 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.42948, D.42947);
  return D.42945;
}


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.42953;
  struct _Rep * D.42954;

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


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.42957;
  char * D.42958;

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


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

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


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

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


void {anonymous}::MyClass1::execute(int) (struct MyClass1 * const this, int i)
{
  struct string * D.42966;
  struct basic_ostream & D.42967;

  D.42966 = &this->s;
  D.42967 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, D.42966);
  std::basic_ostream<char>::operator<< (D.42967, i);
}


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

  D.42969 = &this->D.39615;
  sigc::slot1<void, int>::slot1 (D.42969);
  try
    {

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


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

  D.42970 = &this->D.39573;
  sigc::slot_base::slot_base (D.42970);
  try
    {

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


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

  D.42971 = &this->D.39615;
  sigc::slot1<void, int>::slot1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > (D.42971, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct bound_mem_functor1 & _A_func)
{
  void * D.41020;
  struct slot_base * D.42972;
  struct rep_type * D.42973;
  void * (*<T1711>) (void *) D.42974;

  D.41020 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::typed_slot_rep (D.41020, _A_func);
    }
  catch
    {
      operator delete (D.41020);
    }
  D.42972 = &this->D.39573;
  sigc::slot_base::slot_base (D.42972, D.41020);
  try
    {
      D.42973 = this->D.39573.rep_;
      D.42974 = sigc::internal::slot_call1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>, void, int>::address ();
      D.42973->call_ = D.42974;
    }
  catch
    {
      D.42972 = &this->D.39573;
      sigc::slot_base::~slot_base (D.42972);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (struct typed_slot_rep * const this, const struct bound_mem_functor1 & functor)
{
  struct slot_rep * D.42977;
  struct adaptor_type * D.42978;
  struct slot_do_bind D.41827;

  D.42977 = &this->D.41008;
  sigc::internal::slot_rep::slot_rep (D.42977, 0B, destroy, dup);
  try
    {
      D.42978 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::adaptor_functor (D.42978, functor);
      D.42978 = &this->functor_;
      D.42977 = &this->D.41008;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41827, D.42977);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.41827, D.42978);
        }
      finally
        {
          D.41827 = {CLOBBER};
        }
    }
  catch
    {
      D.42977 = &this->D.41008;
      sigc::internal::slot_rep::~slot_rep (D.42977);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (void * data)
{
  void * D.42981;
  void * D.41992;
  struct slot_rep * a_rep;

  a_rep = data;
  D.41992 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::typed_slot_rep (D.41992, a_rep);
    }
  catch
    {
      operator delete (D.41992);
    }
  D.42981 = D.41992;
  return D.42981;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.42985;
  struct slot_rep * D.42986;
  struct adaptor_type * D.42987;
  struct slot_do_bind D.42419;

  D.42985 = cl->D.41008.call_;
  D.42986 = &this->D.41008;
  sigc::internal::slot_rep::slot_rep (D.42986, D.42985, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.42987 = &this->functor_;
      D.42986 = &this->D.41008;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42419, D.42986);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.42419, D.42987);
        }
      finally
        {
          D.42419 = {CLOBBER};
        }
    }
  catch
    {
      D.42986 = &this->D.41008;
      sigc::internal::slot_rep::~slot_rep (D.42986);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (void * data)
{
  struct adaptor_type * D.42990;
  struct slot_do_unbind D.41977;
  void * D.42991;
  struct self * self_;

  self_ = data;
  self_->D.41008.call_ = 0B;
  self_->D.41008.destroy_ = 0B;
  D.42990 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.41977, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.41977, D.42990);
    }
  finally
    {
      D.41977 = {CLOBBER};
    }
  D.42991 = 0B;
  return D.42991;
}


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


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

  D.42995 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > (_A_action, D.42995);
}


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


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

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


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}::MyClass1, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::MyClass1, 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}::MyClass1; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.42997;

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


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

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


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

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

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


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

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


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


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


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

}


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


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

  D.43004 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > (_A_action, D.43004);
}


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


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

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


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}::MyClass1, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::MyClass1, 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}::MyClass1; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.43006;

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


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

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

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


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

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


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

  D.43012 = this->destroy_;
  if (D.43012 != 0B) goto <D.43013>; else goto <D.43014>;
  <D.43013>:
  D.43012 = this->destroy_;
  D.43012 (this);
  goto <D.43015>;
  <D.43014>:
  <D.43015>:
}


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

  D.43016 = call_it;
  return D.43016;
}


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

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


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

  D.43020 = &this->functor_;
  sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>::operator() (D.43020, _A_arg1);
  return;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::MyClass1; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  const struct limit_reference * D.43022;
  struct MyClass1 & D.43023;
  void MyClass1::<T6fe3> (struct MyClass1 *, int) * iftmp.3;
  void MyClass1::<T6fe3> (struct MyClass1 *, int) * D.43025;
  long int D.43026;
  long int D.43027;
  long int D.43031;
  sizetype D.43032;
  struct MyClass1 * D.43033;
  int (*__vtbl_ptr_type) () * D.43034;
  long int D.43035;
  sizetype D.43036;
  int (*__vtbl_ptr_type) () * D.43037;
  int D.43038;

  D.43022 = &this->obj_;
  D.43023 = sigc::limit_reference<{anonymous}::MyClass1, true>::invoke (D.43022);
  D.43025 = this->D.39792.func_ptr_.__pfn;
  D.43026 = (long int) D.43025;
  D.43027 = D.43026 & 1;
  if (D.43027 == 0) goto <D.43028>; else goto <D.43029>;
  <D.43028>:
  iftmp.3 = this->D.39792.func_ptr_.__pfn;
  goto <D.43030>;
  <D.43029>:
  D.43031 = this->D.39792.func_ptr_.__delta;
  D.43032 = (sizetype) D.43031;
  D.43033 = D.43023 + D.43032;
  D.43034 = MEM[(int (*__vtbl_ptr_type) () * *)D.43033];
  D.43025 = this->D.39792.func_ptr_.__pfn;
  D.43026 = (long int) D.43025;
  D.43035 = D.43026 + -1;
  D.43036 = (sizetype) D.43035;
  D.43037 = D.43034 + D.43036;
  iftmp.3 = *D.43037;
  <D.43030>:
  D.43038 = *_A_a1;
  D.43031 = this->D.39792.func_ptr_.__delta;
  D.43032 = (sizetype) D.43031;
  D.43033 = D.43023 + D.43032;
  iftmp.3 (D.43033, D.43038);
  return;
}


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

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


{anonymous}::MyClass2::MyClass2(const string&) (struct MyClass2 * const this, const struct string & str)
{
  struct trackable * D.43042;
  struct string * D.43043;

  ns_ext::NsExtClass::NsExtClass (this);
  D.43042 = &this->D.39414;
  sigc::trackable::trackable (D.43042);
  try
    {
      D.43043 = &this->s;
      std::basic_string<char>::basic_string (D.43043, str);
      try
        {

        }
      catch
        {
          D.43043 = &this->s;
          std::basic_string<char>::~basic_string (D.43043);
        }
    }
  catch
    {
      D.43042 = &this->D.39414;
      sigc::trackable::~trackable (D.43042);
    }
}


ns_ext::NsExtClass::NsExtClass() (struct NsExtClass * const this)
{

}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = int; T_return = void; T_obj = {anonymous}::MyClass2; T_obj2 = {anonymous}::MyClass2] (struct MyClass2 * _A_obj, struct 
{
  void MyClass2::<T6ff3> (struct MyClass2 *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>::bound_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::MyClass2; T_arg1 = int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::MyClass2::*)(int)] (struct bound_mem_functor1 * const this, struct MyClass2 * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.43047;
  struct limit_reference * D.43048;

  D.43047 = &this->D.39963;
  sigc::mem_functor1<void, {anonymous}::MyClass2, int>::mem_functor1 (D.43047, _A_func);
  D.43048 = &this->obj_;
  sigc::limit_reference<{anonymous}::MyClass2, true>::limit_reference (D.43048, _A_obj);
}


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


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

  D.43049 = &_A_target->D.39414;
  this->visited = D.43049;
  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::bound_mem_functor1<void, {anonymous}::MyClass2, int>; T_return = void; T_arg1 = int] (struct slot * const this, const struct bound_mem_functor1 & _A_func)
{
  struct slot1 * D.43050;

  D.43050 = &this->D.39615;
  sigc::slot1<void, int>::slot1<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > (D.43050, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct bound_mem_functor1 & _A_func)
{
  void * D.41529;
  struct slot_base * D.43051;
  struct rep_type * D.43052;
  void * (*<T1711>) (void *) D.43053;

  D.41529 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >::typed_slot_rep (D.41529, _A_func);
    }
  catch
    {
      operator delete (D.41529);
    }
  D.43051 = &this->D.39573;
  sigc::slot_base::slot_base (D.43051, D.41529);
  try
    {
      D.43052 = this->D.39573.rep_;
      D.43053 = sigc::internal::slot_call1<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>, void, int>::address ();
      D.43052->call_ = D.43053;
    }
  catch
    {
      D.43051 = &this->D.39573;
      sigc::slot_base::~slot_base (D.43051);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>] (struct typed_slot_rep * const this, const struct bound_mem_functor1 & functor)
{
  struct slot_rep * D.43056;
  struct adaptor_type * D.43057;
  struct slot_do_bind D.41860;

  D.43056 = &this->D.41517;
  sigc::internal::slot_rep::slot_rep (D.43056, 0B, destroy, dup);
  try
    {
      D.43057 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >::adaptor_functor (D.43057, functor);
      D.43057 = &this->functor_;
      D.43056 = &this->D.41517;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41860, D.43056);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > > (&D.41860, D.43057);
        }
      finally
        {
          D.41860 = {CLOBBER};
        }
    }
  catch
    {
      D.43056 = &this->D.41517;
      sigc::internal::slot_rep::~slot_rep (D.43056);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>] (void * data)
{
  void * D.43060;
  void * D.42175;
  struct slot_rep * a_rep;

  a_rep = data;
  D.42175 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >::typed_slot_rep (D.42175, a_rep);
    }
  catch
    {
      operator delete (D.42175);
    }
  D.43060 = D.42175;
  return D.43060;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.43064;
  struct slot_rep * D.43065;
  struct adaptor_type * D.43066;
  struct slot_do_bind D.42459;

  D.43064 = cl->D.41517.call_;
  D.43065 = &this->D.41517;
  sigc::internal::slot_rep::slot_rep (D.43065, D.43064, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.43066 = &this->functor_;
      D.43065 = &this->D.41517;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42459, D.43065);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > > (&D.42459, D.43066);
        }
      finally
        {
          D.42459 = {CLOBBER};
        }
    }
  catch
    {
      D.43065 = &this->D.41517;
      sigc::internal::slot_rep::~slot_rep (D.43065);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>] (void * data)
{
  struct adaptor_type * D.43069;
  struct slot_do_unbind D.42160;
  void * D.43070;
  struct self * self_;

  self_ = data;
  self_->D.41517.call_ = 0B;
  self_->D.41517.destroy_ = 0B;
  D.43069 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42160, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > > (&D.42160, D.43069);
    }
  finally
    {
      D.42160 = {CLOBBER};
    }
  D.43070 = 0B;
  return D.43070;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > > (&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::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


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

  D.43074 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > (_A_action, D.43074);
}


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


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

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


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}::MyClass2, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::MyClass2, 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}::MyClass2; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.43076;

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


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

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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > > (&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::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


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

  D.43080 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int> > (_A_action, D.43080);
}


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


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

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


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}::MyClass2, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::MyClass2, 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}::MyClass2; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.43082;

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


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

  D.43083 = call_it;
  return D.43083;
}


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

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


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

  D.43087 = &this->functor_;
  sigc::bound_mem_functor1<void, {anonymous}::MyClass2, int>::operator() (D.43087, _A_arg1);
  return;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::MyClass2; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  const struct limit_reference * D.43089;
  struct MyClass2 & D.43090;
  void MyClass2::<T6ff3> (struct MyClass2 *, int) * iftmp.4;
  void MyClass2::<T6ff3> (struct MyClass2 *, int) * D.43092;
  long int D.43093;
  long int D.43094;
  long int D.43098;
  sizetype D.43099;
  struct MyClass2 * D.43100;
  int (*__vtbl_ptr_type) () * D.43101;
  long int D.43102;
  sizetype D.43103;
  int (*__vtbl_ptr_type) () * D.43104;
  int D.43105;

  D.43089 = &this->obj_;
  D.43090 = sigc::limit_reference<{anonymous}::MyClass2, true>::invoke (D.43089);
  D.43092 = this->D.39963.func_ptr_.__pfn;
  D.43093 = (long int) D.43092;
  D.43094 = D.43093 & 1;
  if (D.43094 == 0) goto <D.43095>; else goto <D.43096>;
  <D.43095>:
  iftmp.4 = this->D.39963.func_ptr_.__pfn;
  goto <D.43097>;
  <D.43096>:
  D.43098 = this->D.39963.func_ptr_.__delta;
  D.43099 = (sizetype) D.43098;
  D.43100 = D.43090 + D.43099;
  D.43101 = MEM[(int (*__vtbl_ptr_type) () * *)D.43100];
  D.43092 = this->D.39963.func_ptr_.__pfn;
  D.43093 = (long int) D.43092;
  D.43102 = D.43093 + -1;
  D.43103 = (sizetype) D.43102;
  D.43104 = D.43101 + D.43103;
  iftmp.4 = *D.43104;
  <D.43097>:
  D.43105 = *_A_a1;
  D.43098 = this->D.39963.func_ptr_.__delta;
  D.43099 = (sizetype) D.43098;
  D.43100 = D.43090 + D.43099;
  iftmp.4 (D.43100, D.43105);
  return;
}


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

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


{anonymous}::MyClass1::MyClass1(const string&) (struct MyClass1 * const this, const struct string & str)
{
  struct trackable * D.43109;
  struct string * D.43110;

  D.43109 = &this->D.39392;
  sigc::trackable::trackable (D.43109);
  try
    {
      D.43110 = &this->s;
      std::basic_string<char>::basic_string (D.43110, str);
      try
        {

        }
      catch
        {
          D.43110 = &this->s;
          std::basic_string<char>::~basic_string (D.43110);
        }
    }
  catch
    {
      D.43109 = &this->D.39392;
      sigc::trackable::~trackable (D.43109);
    }
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = int; T_return = void; T_obj = {anonymous}::MyClass1; T_obj2 = {anonymous}::MyClass1] (struct MyClass1 * _A_obj, struct 
{
  void MyClass1::<T6fe3> (struct MyClass1 *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>::bound_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::MyClass1; T_arg1 = int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::MyClass1::*)(int)] (struct bound_mem_functor1 * const this, struct MyClass1 * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.43114;
  struct limit_reference * D.43115;

  D.43114 = &this->D.39792;
  sigc::mem_functor1<void, {anonymous}::MyClass1, int>::mem_functor1 (D.43114, _A_func);
  D.43115 = &this->obj_;
  sigc::limit_reference<{anonymous}::MyClass1, true>::limit_reference (D.43115, _A_obj);
}


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


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

  D.43116 = &_A_target->D.39392;
  this->visited = D.43116;
  this->invoked = _A_target;
}


ns1::MyAdaptor1<T_functor> ns1::my_adaptor1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (const struct bound_mem_functor1 & _A_func)
{
  ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::MyAdaptor1 (&<retval>, _A_func);
  return <retval>;
}


ns1::MyAdaptor1<T_functor>::MyAdaptor1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (struct MyAdaptor1 * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adapts * D.43119;

  D.43119 = &this->D.40518;
  sigc::adapts<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::adapts (D.43119, _A_functor);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (struct adapts * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adaptor_type * D.43120;

  sigc::adaptor_base::adaptor_base (this);
  D.43120 = &this->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::adaptor_functor (D.43120, _A_functor);
}


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

  D.43121 = &this->D.39615;
  sigc::slot1<void, int>::slot1<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (D.43121, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >; T_return = void; T_arg1 = int] (struct slot1 * const this, const struct MyAdaptor1 & _A_func)
{
  void * D.41615;
  struct slot_base * D.43122;
  struct rep_type * D.43123;
  void * (*<T1711>) (void *) D.43124;

  D.41615 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > >::typed_slot_rep (D.41615, _A_func);
    }
  catch
    {
      operator delete (D.41615);
    }
  D.43122 = &this->D.39573;
  sigc::slot_base::slot_base (D.43122, D.41615);
  try
    {
      D.43123 = this->D.39573.rep_;
      D.43124 = sigc::internal::slot_call1<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >, void, int>::address ();
      D.43123->call_ = D.43124;
    }
  catch
    {
      D.43122 = &this->D.39573;
      sigc::slot_base::~slot_base (D.43122);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (struct typed_slot_rep * const this, const struct MyAdaptor1 & functor)
{
  struct slot_rep * D.43127;
  struct adaptor_type * D.43128;
  struct slot_do_bind D.41890;

  D.43127 = &this->D.41603;
  sigc::internal::slot_rep::slot_rep (D.43127, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.43128 = &this->functor_;
      D.43127 = &this->D.41603;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41890, D.43127);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.41890, D.43128);
        }
      finally
        {
          D.41890 = {CLOBBER};
        }
    }
  catch
    {
      D.43127 = &this->D.41603;
      sigc::internal::slot_rep::~slot_rep (D.43127);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (void * data)
{
  void * D.43131;
  void * D.42326;
  struct slot_rep * a_rep;

  a_rep = data;
  D.42326 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > >::typed_slot_rep (D.42326, a_rep);
    }
  catch
    {
      operator delete (D.42326);
    }
  D.43131 = D.42326;
  return D.43131;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.43135;
  struct slot_rep * D.43136;
  struct adaptor_type * D.43137;
  struct slot_do_bind D.42487;

  D.43135 = cl->D.41603.call_;
  D.43136 = &this->D.41603;
  sigc::internal::slot_rep::slot_rep (D.43136, D.43135, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.43137 = &this->functor_;
      D.43136 = &this->D.41603;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42487, D.43136);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.42487, D.43137);
        }
      finally
        {
          D.42487 = {CLOBBER};
        }
    }
  catch
    {
      D.43136 = &this->D.41603;
      sigc::internal::slot_rep::~slot_rep (D.43136);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (void * data)
{
  struct adaptor_type * D.43140;
  struct slot_do_unbind D.42311;
  void * D.43141;
  struct self * self_;

  self_ = data;
  self_->D.41603.call_ = 0B;
  self_->D.41603.destroy_ = 0B;
  D.43140 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42311, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&D.42311, D.43140);
    }
  finally
    {
      D.42311 = {CLOBBER};
    }
  D.43141 = 0B;
  return D.43141;
}


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 = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct slot_do_unbind & _A_action, const struct MyAdaptor1 & _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>, ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&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 = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct limit_derived_target & _A_action, const struct MyAdaptor1 & _A_functor)
{
  sigc::visitor<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<ns1::MyAdaptor1<T_functor> >::do_visit_each(const T_action&, const ns1::MyAdaptor1<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (const struct limit_derived_target & _A_action, const struct MyAdaptor1 & _A_target)
{
  struct adaptor_type * D.43145;

  D.43145 = &_A_target->D.40518.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (_A_action, D.43145);
}


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 = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct slot_do_bind & _A_action, const struct MyAdaptor1 & _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>, ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (&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 = ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >] (const struct limit_derived_target & _A_action, const struct MyAdaptor1 & _A_functor)
{
  sigc::visitor<ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<ns1::MyAdaptor1<T_functor> >::do_visit_each(const T_action&, const ns1::MyAdaptor1<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>] (const struct limit_derived_target & _A_action, const struct MyAdaptor1 & _A_target)
{
  struct adaptor_type * D.43147;

  D.43147 = &_A_target->D.40518.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> > > (_A_action, D.43147);
}


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

  D.43148 = call_it;
  return D.43148;
}


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

  typed_rep = rep;
  D.43150 = &typed_rep->functor_;
  ns1::MyAdaptor1<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::operator()<const int&> (D.43150, a_1);
  return;
}


typename ns1::MyAdaptor1<T_functor>::deduce_result_type<T_arg1>::type ns1::MyAdaptor1<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>; typename ns1::MyAdaptor1<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct MyAdaptor1 * const this, const int & _A_arg1)
{
  int D.43152;
  struct adaptor_type * D.43153;

  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "MyAdaptor1()(_A_arg1) ");
  D.43152 = *_A_arg1;
  D.43153 = &this->D.40518.functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int> >::operator()<int> (D.43153, D.43152);
  return;
}


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.43157;
  int (*__vtbl_ptr_type) () * D.43158;
  long int D.43159;
  sizetype D.43160;
  struct basic_ios * D.43161;
  long unsigned int D.43163;
  long int D.43164;
  struct basic_ostream & D.43165;

  if (__s == 0B) goto <D.43155>; else goto <D.43156>;
  <D.43155>:
  D.43157 = __out->_vptr.basic_ostream;
  D.43158 = D.43157 + 18446744073709551592;
  D.43159 = MEM[(long int *)D.43158];
  D.43160 = (sizetype) D.43159;
  D.43161 = __out + D.43160;
  std::basic_ios<char>::setstate (D.43161, 1);
  goto <D.43162>;
  <D.43156>:
  D.43163 = std::char_traits<char>::length (__s);
  D.43164 = (long int) D.43163;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.43164);
  <D.43162>:
  D.43165 = __out;
  return D.43165;
}


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.43167;
  _Ios_Iostate D.43168;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.43172;
  int __a.5;
  int __b.6;
  int D.43175;

  __a.5 = (int) __a;
  __b.6 = (int) __b;
  D.43175 = __a.5 | __b.6;
  D.43172 = (_Ios_Iostate) D.43175;
  return D.43172;
}


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

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


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 = sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, int _A_arg1)
{
  struct bound_mem_functor1 * D.43179;

  D.43179 = &this->functor_;
  sigc::bound_mem_functor1<void, {anonymous}::MyClass1, int>::operator() (D.43179, &_A_arg1);
  return;
}


sigc::slot<void, int>& sigc::slot<void, int>::operator=(const sigc::slot<void, int>&) (struct slot * const this, const struct slot & D.39797)
{
  const struct slot1 * D.43181;
  struct slot1 * D.43182;
  struct slot & D.43183;

  D.43181 = &D.39797->D.39615;
  D.43182 = &this->D.39615;
  sigc::slot1<void, int>::operator= (D.43182, D.43181);
  D.43183 = this;
  return D.43183;
}


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

  D.43185 = &src->D.39573;
  D.43186 = &this->D.39573;
  sigc::slot_base::operator= (D.43186, D.43185);
  D.43187 = this;
  return D.43187;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const int&] (const struct slot1 * const this, const int & _A_a1)
{
  bool retval.7;
  bool iftmp.8;
  const struct slot_base * D.43193;
  bool D.43194;
  bool D.43195;
  bool D.43197;
  bool D.43198;
  struct rep_type * D.43202;
  void * (*<T1711>) (void *) D.43203;

  D.43193 = &this->D.39573;
  D.43194 = sigc::slot_base::empty (D.43193);
  D.43195 = ~D.43194;
  if (D.43195 != 0) goto <D.43196>; else goto <D.43191>;
  <D.43196>:
  D.43193 = &this->D.39573;
  D.43197 = sigc::slot_base::blocked (D.43193);
  D.43198 = ~D.43197;
  if (D.43198 != 0) goto <D.43199>; else goto <D.43191>;
  <D.43199>:
  iftmp.8 = 1;
  goto <D.43192>;
  <D.43191>:
  iftmp.8 = 0;
  <D.43192>:
  retval.7 = iftmp.8;
  if (retval.7 != 0) goto <D.43200>; else goto <D.43201>;
  <D.43200>:
  D.43202 = this->D.39573.rep_;
  D.43203 = D.43202->call_;
  D.43202 = this->D.39573.rep_;
  D.43203 (D.43202, _A_a1);
  return;
  <D.43201>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.43205;
  bool iftmp.9;
  struct rep_type * D.43210;
  void * (*<T1711>) (void *) D.43212;

  D.43210 = this->rep_;
  if (D.43210 == 0B) goto <D.43207>; else goto <D.43211>;
  <D.43211>:
  D.43210 = this->rep_;
  D.43212 = D.43210->call_;
  if (D.43212 == 0B) goto <D.43207>; else goto <D.43208>;
  <D.43207>:
  iftmp.9 = 1;
  goto <D.43209>;
  <D.43208>:
  iftmp.9 = 0;
  <D.43209>:
  D.43205 = iftmp.9;
  return D.43205;
}


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

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


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

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

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


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

  try
    {
      {

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


{anonymous}::MyClass2::~MyClass2() (struct MyClass2 * const this)
{
  struct string * D.43218;
  struct trackable * D.43219;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.43218 = &this->s;
                std::basic_string<char>::~basic_string (D.43218);
              }
          }
        finally
          {
            D.43219 = &this->D.39414;
            sigc::trackable::~trackable (D.43219);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39853>:
}


{anonymous}::MyClass1::~MyClass1() (struct MyClass1 * const this)
{
  struct string * D.43222;
  struct trackable * D.43223;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.43222 = &this->s;
                std::basic_string<char>::~basic_string (D.43222);
              }
          }
        finally
          {
            D.43223 = &this->D.39392;
            sigc::trackable::~trackable (D.43223);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39675>:
}


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.40730;
  struct _Rep * D.43226;
  struct _Alloc_hider * D.43227;

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


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

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

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


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

  try
    {
      {

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


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.10;
  struct _Rep & D.43238;
  bool D.43239;
  long int D.43240;
  long int D.43241;
  bool retval.11;
  _Atomic_word * D.43245;
  int D.43246;

  D.43238 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.43239 = D.43238 != this;
  D.43240 = (long int) D.43239;
  D.43241 = __builtin_expect (D.43240, 0);
  retval.10 = D.43241 != 0;
  if (retval.10 != 0) goto <D.43242>; else goto <D.43243>;
  <D.43242>:
  D.43245 = &this->D.11865._M_refcount;
  D.43246 = __gnu_cxx::__exchange_and_add_dispatch (D.43245, -1);
  retval.11 = D.43246 <= 0;
  if (retval.11 != 0) goto <D.43247>; else goto <D.43248>;
  <D.43247>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.43249>;
  <D.43248>:
  <D.43249>:
  goto <D.43250>;
  <D.43243>:
  <D.43250>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.12;
  int D.43255;
  _Atomic_word D.43258;

  D.43255 = __gthread_active_p ();
  retval.12 = D.43255 != 0;
  if (retval.12 != 0) goto <D.43256>; else goto <D.43257>;
  <D.43256>:
  D.43258 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.43258;
  <D.43257>:
  D.43258 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.43258;
}


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

  D.43261 = __gthrw___pthread_key_create != 0B;
  D.43260 = (int) D.43261;
  return D.43260;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.43263;
  unsigned int __val.13;
  unsigned int D.43265;

  __val.13 = (unsigned int) __val;
  D.43265 = __atomic_fetch_add_4 (__mem, __val.13, 4);
  D.43263 = (_Atomic_word) D.43265;
  return D.43263;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.43267;
  int D.43268;
  _Atomic_word D.43269;
  _Atomic_word __result;

  __result = *__mem;
  D.43267 = *__mem;
  D.43268 = D.43267 + __val;
  *__mem = D.43268;
  D.43269 = __result;
  return D.43269;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.43273 = &this->D.39615;
            sigc::slot1<void, int>::~slot1 (D.43273);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39646>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.43275 = &this->D.39573;
            sigc::slot_base::~slot_base (D.43275);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39641>:
}


(static initializers for test_visit_each.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.43277>; else goto <D.43278>;
  <D.43277>:
  if (__priority == 65535) goto <D.43279>; else goto <D.43280>;
  <D.43279>:
  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.43281>;
  <D.43280>:
  <D.43281>:
  goto <D.43282>;
  <D.43278>:
  <D.43282>:
}


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.14;
  const void * * D.43286;
  sizetype iftmp.15;
  int (*__vtbl_ptr_type) () * D.43291;
  int (*__vtbl_ptr_type) () * D.43292;
  long int D.43293;
  struct basic_ios * D.43295;
  int (*__vtbl_ptr_type) () * iftmp.16;
  struct __stringbuf_type * D.43300;
  const void * * iftmp.17;
  struct basic_ostream * D.43305;
  int D.43306;
  struct basic_ios * D.43309;
  int D.43311;

  {
    if (2 == 0) goto <D.43284>; else goto <D.43285>;
    <D.43284>:
    D.43286 = 0B;
    iftmp.14 = *D.43286;
    goto <D.43287>;
    <D.43285>:
    iftmp.14 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.43287>:
    this->D.22312._vptr.basic_ostream = iftmp.14;
    if (2 == 0) goto <D.43289>; else goto <D.43290>;
    <D.43289>:
    D.43291 = this->D.22312._vptr.basic_ostream;
    D.43292 = D.43291 + 18446744073709551592;
    D.43293 = MEM[(long int *)D.43292];
    iftmp.15 = (sizetype) D.43293;
    goto <D.43294>;
    <D.43290>:
    iftmp.15 = 88;
    <D.43294>:
    D.43295 = this + iftmp.15;
    if (2 == 0) goto <D.43297>; else goto <D.43298>;
    <D.43297>:
    iftmp.16 = MEM[(const void * *)0B + 24B];
    goto <D.43299>;
    <D.43298>:
    iftmp.16 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.43299>:
    D.43295->D.19008._vptr.ios_base = iftmp.16;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.43300 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.43300);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.43302>; else goto <D.43303>;
                <D.43302>:
                iftmp.17 = 8B;
                goto <D.43304>;
                <D.43303>:
                iftmp.17 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.43304>:
                D.43305 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.43305, iftmp.17);
              }
          }
        finally
          {
            D.43306 = 2;
            if (D.43306 != 0) goto <D.43307>; else goto <D.43308>;
            <D.43307>:
            D.43309 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.43309);
            goto <D.43310>;
            <D.43308>:
            <D.43310>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42755>:
  D.43311 = 0;
  if (D.43311 != 0) goto <D.43312>; else goto <D.43313>;
  <D.43312>:
  operator delete (this);
  goto <D.43314>;
  <D.43313>:
  <D.43314>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.43324;
  struct basic_streambuf * D.43325;
  int D.43326;

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

              }
            finally
              {
                D.43324 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.43324);
              }
          }
        finally
          {
            D.43325 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.43325);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40702>:
  D.43326 = 0;
  if (D.43326 != 0) goto <D.43327>; else goto <D.43328>;
  <D.43327>:
  operator delete (this);
  goto <D.43329>;
  <D.43328>:
  <D.43329>:
}


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

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

          }
        finally
          {
            D.43332 = &this->_M_buf_locale;
            std::locale::~locale (D.43332);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40917>:
  D.43333 = 0;
  if (D.43333 != 0) goto <D.43334>; else goto <D.43335>;
  <D.43334>:
  operator delete (this);
  goto <D.43336>;
  <D.43335>:
  <D.43336>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.40706>:
  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.18;
  sizetype iftmp.19;
  int (*__vtbl_ptr_type) () * D.43344;
  int (*__vtbl_ptr_type) () * D.43345;
  long int D.43346;
  struct basic_ios * D.43348;
  int (*__vtbl_ptr_type) () * iftmp.20;
  int D.43353;
  struct basic_ios * D.43356;
  int D.43358;

  {
    if (0 == 0) goto <D.43338>; else goto <D.43339>;
    <D.43338>:
    iftmp.18 = *__vtt_parm;
    goto <D.43340>;
    <D.43339>:
    iftmp.18 = &MEM[(void *)&_ZTVSo + 24B];
    <D.43340>:
    this->_vptr.basic_ostream = iftmp.18;
    if (0 == 0) goto <D.43342>; else goto <D.43343>;
    <D.43342>:
    D.43344 = this->_vptr.basic_ostream;
    D.43345 = D.43344 + 18446744073709551592;
    D.43346 = MEM[(long int *)D.43345];
    iftmp.19 = (sizetype) D.43346;
    goto <D.43347>;
    <D.43343>:
    iftmp.19 = 8;
    <D.43347>:
    D.43348 = this + iftmp.19;
    if (0 == 0) goto <D.43350>; else goto <D.43351>;
    <D.43350>:
    iftmp.20 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.43352>;
    <D.43351>:
    iftmp.20 = &MEM[(void *)&_ZTVSo + 64B];
    <D.43352>:
    D.43348->D.19008._vptr.ios_base = iftmp.20;
    try
      {
        try
          {

          }
        finally
          {
            D.43353 = 0;
            if (D.43353 != 0) goto <D.43354>; else goto <D.43355>;
            <D.43354>:
            D.43356 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.43356);
            goto <D.43357>;
            <D.43355>:
            <D.43357>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40902>:
  D.43358 = 0;
  if (D.43358 != 0) goto <D.43359>; else goto <D.43360>;
  <D.43359>:
  operator delete (this);
  goto <D.43361>;
  <D.43360>:
  <D.43361>:
}


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

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

          }
        finally
          {
            D.43363 = &this->D.19008;
            std::ios_base::~ios_base (D.43363);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40890>:
  D.43364 = 0;
  if (D.43364 != 0) goto <D.43365>; else goto <D.43366>;
  <D.43365>:
  operator delete (this);
  goto <D.43367>;
  <D.43366>:
  <D.43367>:
}


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.40894>:
  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.43371;
  const void * * iftmp.21;
  struct basic_ostream * D.43377;
  int (*__vtbl_ptr_type) () * iftmp.22;
  const void * * D.43381;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.43386;
  int (*__vtbl_ptr_type) () * D.43387;
  long int D.43388;
  struct basic_ios * D.43390;
  int (*__vtbl_ptr_type) () * iftmp.24;
  _Ios_Openmode D.43395;
  struct __stringbuf_type * D.43396;
  struct basic_streambuf * D.43397;
  sizetype iftmp.25;
  struct basic_ios * D.43402;
  const void * * iftmp.26;

  if (1 != 0) goto <D.43369>; else goto <D.43370>;
  <D.43369>:
  D.43371 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.43371);
  goto <D.43372>;
  <D.43370>:
  <D.43372>:
  try
    {
      if (1 == 0) goto <D.43374>; else goto <D.43375>;
      <D.43374>:
      iftmp.21 = 8B;
      goto <D.43376>;
      <D.43375>:
      iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.43376>:
      D.43377 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.43377, iftmp.21);
      try
        {
          if (1 == 0) goto <D.43379>; else goto <D.43380>;
          <D.43379>:
          D.43381 = 0B;
          iftmp.22 = *D.43381;
          goto <D.43382>;
          <D.43380>:
          iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.43382>:
          this->D.22312._vptr.basic_ostream = iftmp.22;
          if (1 == 0) goto <D.43384>; else goto <D.43385>;
          <D.43384>:
          D.43386 = this->D.22312._vptr.basic_ostream;
          D.43387 = D.43386 + 18446744073709551592;
          D.43388 = MEM[(long int *)D.43387];
          iftmp.23 = (sizetype) D.43388;
          goto <D.43389>;
          <D.43385>:
          iftmp.23 = 88;
          <D.43389>:
          D.43390 = this + iftmp.23;
          if (1 == 0) goto <D.43392>; else goto <D.43393>;
          <D.43392>:
          iftmp.24 = MEM[(const void * *)0B + 24B];
          goto <D.43394>;
          <D.43393>:
          iftmp.24 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.43394>:
          D.43390->D.19008._vptr.ios_base = iftmp.24;
          D.43395 = std::operator| (__mode, 16);
          D.43396 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.43396, D.43395);
          try
            {
              D.43397 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.43399>; else goto <D.43400>;
              <D.43399>:
              D.43386 = this->D.22312._vptr.basic_ostream;
              D.43387 = D.43386 + 18446744073709551592;
              D.43388 = MEM[(long int *)D.43387];
              iftmp.25 = (sizetype) D.43388;
              goto <D.43401>;
              <D.43400>:
              iftmp.25 = 88;
              <D.43401>:
              D.43402 = this + iftmp.25;
              std::basic_ios<char>::init (D.43402, D.43397);
            }
          catch
            {
              D.43396 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.43396);
            }
        }
      catch
        {
          if (1 == 0) goto <D.43404>; else goto <D.43405>;
          <D.43404>:
          iftmp.26 = 8B;
          goto <D.43406>;
          <D.43405>:
          iftmp.26 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.43406>:
          D.43377 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.43377, iftmp.26);
        }
    }
  catch
    {
      if (1 != 0) goto <D.43407>; else goto <D.43408>;
      <D.43407>:
      D.43371 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.43371);
      goto <D.43409>;
      <D.43408>:
      <D.43409>:
    }
}


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

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


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.43416;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  int (*__vtbl_ptr_type) () * D.43425;
  int (*__vtbl_ptr_type) () * D.43426;
  long int D.43427;
  struct basic_ios * D.43429;
  int (*__vtbl_ptr_type) () * iftmp.29;
  sizetype iftmp.30;
  struct basic_ios * D.43438;

  if (0 != 0) goto <D.43414>; else goto <D.43415>;
  <D.43414>:
  D.43416 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.43416);
  goto <D.43417>;
  <D.43415>:
  <D.43417>:
  try
    {
      if (0 == 0) goto <D.43419>; else goto <D.43420>;
      <D.43419>:
      iftmp.27 = *__vtt_parm;
      goto <D.43421>;
      <D.43420>:
      iftmp.27 = &MEM[(void *)&_ZTVSo + 24B];
      <D.43421>:
      this->_vptr.basic_ostream = iftmp.27;
      if (0 == 0) goto <D.43423>; else goto <D.43424>;
      <D.43423>:
      D.43425 = this->_vptr.basic_ostream;
      D.43426 = D.43425 + 18446744073709551592;
      D.43427 = MEM[(long int *)D.43426];
      iftmp.28 = (sizetype) D.43427;
      goto <D.43428>;
      <D.43424>:
      iftmp.28 = 8;
      <D.43428>:
      D.43429 = this + iftmp.28;
      if (0 == 0) goto <D.43431>; else goto <D.43432>;
      <D.43431>:
      iftmp.29 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.43433>;
      <D.43432>:
      iftmp.29 = &MEM[(void *)&_ZTVSo + 64B];
      <D.43433>:
      D.43429->D.19008._vptr.ios_base = iftmp.29;
      if (0 == 0) goto <D.43435>; else goto <D.43436>;
      <D.43435>:
      D.43425 = this->_vptr.basic_ostream;
      D.43426 = D.43425 + 18446744073709551592;
      D.43427 = MEM[(long int *)D.43426];
      iftmp.30 = (sizetype) D.43427;
      goto <D.43437>;
      <D.43436>:
      iftmp.30 = 8;
      <D.43437>:
      D.43438 = this + iftmp.30;
      std::basic_ios<char>::init (D.43438, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.43439>; else goto <D.43440>;
      <D.43439>:
      D.43416 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.43416);
      goto <D.43441>;
      <D.43440>:
      <D.43441>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.43443;
  int __a.31;
  int __b.32;
  int D.43446;

  __a.31 = (int) __a;
  __b.32 = (int) __b;
  D.43446 = __a.31 | __b.32;
  D.43443 = (_Ios_Openmode) D.43446;
  return D.43443;
}


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.43448;
  struct __string_type * D.43449;

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

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


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

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

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


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.41744;
  struct _Rep & D.43452;
  char * D.43453;
  struct _Alloc_hider * D.43454;

  std::allocator<char>::allocator (&D.41744);
  try
    {
      D.43452 = std::basic_string<char>::_S_empty_rep ();
      D.43453 = std::basic_string<char>::_Rep::_M_refdata (D.43452);
      D.43454 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.43454, D.43453, &D.41744);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.41744);
      D.41744 = {CLOBBER};
    }
  try
    {

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


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

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


_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.43460;
  void * D.43461;

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


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


