int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.51992;
  int D.51995;
  int iftmp.1;
  bool D.51997;
  void * t.2;
  struct __string_type D.49100;
  struct basic_ostream & D.52001;
  struct basic_string D.49105;
  struct __string_type D.49101;
  const struct __string_type D.49108;
  struct allocator D.49107;
  struct bind_functor D.50141;
  struct reference_wrapper D.52002;
  struct pointer_functor1 D.49235;
  const struct string D.50195;
  struct allocator D.50194;
  struct trackable * t.3;
  struct __string_type D.50197;
  struct basic_ostream & D.52007;
  struct basic_string D.50199;
  struct __string_type D.50198;
  const struct __string_type D.50202;
  struct allocator D.50201;
  const struct string D.50207;
  struct allocator D.50206;
  int iftmp.4;
  bool D.52009;

  {
    struct TestUtilities * util;
    struct ostringstream pointer_stream;
    struct trackable * t;
    struct slot foo;
    void * buffer;
    struct slot bar;

    try
      {
        util = TestUtilities::get_instance ();
        D.51992 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.51992;
        if (retval.0 != 0) goto <D.51993>; else goto <D.51994>;
        <D.51993>:
        D.51997 = TestUtilities::get_result_and_delete_instance ();
        if (D.51997 != 0) goto <D.51998>; else goto <D.51999>;
        <D.51998>:
        iftmp.1 = 0;
        goto <D.52000>;
        <D.51999>:
        iftmp.1 = 1;
        <D.52000>:
        D.51995 = iftmp.1;
        return D.51995;
        <D.51994>:
        std::basic_ostringstream<char>::basic_ostringstream (&pointer_stream, 16);
        try
          {
            t.2 = operator new (8);
            try
              {
                sigc::trackable::trackable (t.2);
              }
            catch
              {
                operator delete (t.2);
              }
            t = t.2;
            std::basic_ostream<char>::operator<< (&pointer_stream.D.22312, t);
            D.49100 = std::basic_ostringstream<char>::str (&pointer_stream); [return slot optimization]
            try
              {
                D.52001 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "sigc::trackable instance at ");
                std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.52001, &D.49100);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.49100);
                D.49100 = {CLOBBER};
              }
            D.49101 = std::basic_ostringstream<char>::str (&pointer_stream); [return slot optimization]
            try
              {
                D.49105 = std::operator+<char, std::char_traits<char>, std::allocator<char> > ("sigc::trackable instance at ", &D.49101); [return slot optimization]
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.49105);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.49105);
                    D.49105 = {CLOBBER};
                  }
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.49101);
                D.49101 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.49107);
            try
              {
                std::basic_string<char>::basic_string (&D.49108, "", &D.49107);
                try
                  {
                    std::basic_ostringstream<char>::str (&pointer_stream, &D.49108);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.49108);
                    D.49108 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.49107);
                D.49107 = {CLOBBER};
              }
            D.52002 = sigc::ref<sigc::trackable> (t);
            D.49235 = sigc::ptr_fun<sigc::trackable&, void> (Foo);
            try
              {
                D.50141 = sigc::bind<sigc::reference_wrapper<sigc::trackable>, sigc::pointer_functor1<sigc::trackable&, void> > (&D.49235, D.52002); [return slot optimization]
                try
                  {
                    sigc::slot<void>::slot<sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&foo, &D.50141);
                  }
                finally
                  {
                    try
                      {

                      }
                    catch
                      {
                        sigc::slot<void>::~slot (&foo);
                      }
                    D.50141 = {CLOBBER};
                  }
              }
            finally
              {
                try
                  {

                  }
                catch
                  {
                    sigc::slot<void>::~slot (&foo);
                  }
                D.49235 = {CLOBBER};
              }
            try
              {
                sigc::slot0<void>::operator() (&foo.D.49200);
                std::allocator<char>::allocator (&D.50194);
                try
                  {
                    std::basic_string<char>::basic_string (&D.50195, "Foo(x)", &D.50194);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.50195);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.50195);
                        D.50195 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.50194);
                    D.50194 = {CLOBBER};
                  }
                t.3 = t;
                if (t.3 != 0B) goto <D.52004>; else goto <D.52005>;
                <D.52004>:
                sigc::trackable::~trackable (t.3);
                operator delete (t.3);
                goto <D.52006>;
                <D.52005>:
                <D.52006>:
                buffer = malloc (8);
                memset (buffer, 255, 8);
                std::basic_ostream<char>::operator<< (&pointer_stream.D.22312, buffer);
                D.50197 = std::basic_ostringstream<char>::str (&pointer_stream); [return slot optimization]
                try
                  {
                    D.52007 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "         Polluted buffer at ");
                    std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.52007, &D.50197);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.50197);
                    D.50197 = {CLOBBER};
                  }
                D.50198 = std::basic_ostringstream<char>::str (&pointer_stream); [return slot optimization]
                try
                  {
                    D.50199 = std::operator+<char, std::char_traits<char>, std::allocator<char> > ("         Polluted buffer at ", &D.50198); [return slot optimization]
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.50199);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.50199);
                        D.50199 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.50198);
                    D.50198 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.50201);
                try
                  {
                    std::basic_string<char>::basic_string (&D.50202, "", &D.50201);
                    try
                      {
                        std::basic_ostringstream<char>::str (&pointer_stream, &D.50202);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.50202);
                        D.50202 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.50201);
                    D.50201 = {CLOBBER};
                  }
                sigc::slot<void>::slot (&bar, &foo);
                try
                  {
                    sigc::slot0<void>::operator() (&bar.D.49200);
                    std::allocator<char>::allocator (&D.50206);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.50207, "", &D.50206);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.50207);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.50207);
                            D.50207 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.50206);
                        D.50206 = {CLOBBER};
                      }
                    free (buffer);
                    D.52009 = TestUtilities::get_result_and_delete_instance ();
                    if (D.52009 != 0) goto <D.52010>; else goto <D.52011>;
                    <D.52010>:
                    iftmp.4 = 0;
                    goto <D.52012>;
                    <D.52011>:
                    iftmp.4 = 1;
                    <D.52012>:
                    D.51995 = iftmp.4;
                    return D.51995;
                  }
                finally
                  {
                    sigc::slot<void>::~slot (&bar);
                  }
              }
            finally
              {
                sigc::slot<void>::~slot (&foo);
              }
          }
        finally
          {
            std::basic_ostringstream<char>::~basic_ostringstream (&pointer_stream);
          }
      }
    finally
      {
        pointer_stream = {CLOBBER};
        foo = {CLOBBER};
        bar = {CLOBBER};
      }
  }
  D.51995 = 0;
  return D.51995;
}


void {anonymous}::Foo(sigc::trackable&) (struct trackable & D.49088)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Foo(x)");
}


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.52049;
  const void * * iftmp.5;
  struct basic_ostream * D.52055;
  int (*__vtbl_ptr_type) () * iftmp.6;
  const void * * D.52059;
  sizetype iftmp.7;
  int (*__vtbl_ptr_type) () * D.52064;
  int (*__vtbl_ptr_type) () * D.52065;
  long int D.52066;
  struct basic_ios * D.52068;
  int (*__vtbl_ptr_type) () * iftmp.8;
  _Ios_Openmode D.52073;
  struct __stringbuf_type * D.52074;
  struct basic_streambuf * D.52075;
  sizetype iftmp.9;
  struct basic_ios * D.52080;
  const void * * iftmp.10;

  if (1 != 0) goto <D.52047>; else goto <D.52048>;
  <D.52047>:
  D.52049 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.52049);
  goto <D.52050>;
  <D.52048>:
  <D.52050>:
  try
    {
      if (1 == 0) goto <D.52052>; else goto <D.52053>;
      <D.52052>:
      iftmp.5 = 8B;
      goto <D.52054>;
      <D.52053>:
      iftmp.5 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.52054>:
      D.52055 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.52055, iftmp.5);
      try
        {
          if (1 == 0) goto <D.52057>; else goto <D.52058>;
          <D.52057>:
          D.52059 = 0B;
          iftmp.6 = *D.52059;
          goto <D.52060>;
          <D.52058>:
          iftmp.6 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.52060>:
          this->D.22312._vptr.basic_ostream = iftmp.6;
          if (1 == 0) goto <D.52062>; else goto <D.52063>;
          <D.52062>:
          D.52064 = this->D.22312._vptr.basic_ostream;
          D.52065 = D.52064 + 18446744073709551592;
          D.52066 = MEM[(long int *)D.52065];
          iftmp.7 = (sizetype) D.52066;
          goto <D.52067>;
          <D.52063>:
          iftmp.7 = 88;
          <D.52067>:
          D.52068 = this + iftmp.7;
          if (1 == 0) goto <D.52070>; else goto <D.52071>;
          <D.52070>:
          iftmp.8 = MEM[(const void * *)0B + 24B];
          goto <D.52072>;
          <D.52071>:
          iftmp.8 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.52072>:
          D.52068->D.19008._vptr.ios_base = iftmp.8;
          D.52073 = std::operator| (__mode, 16);
          D.52074 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.52074, D.52073);
          try
            {
              D.52075 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.52077>; else goto <D.52078>;
              <D.52077>:
              D.52064 = this->D.22312._vptr.basic_ostream;
              D.52065 = D.52064 + 18446744073709551592;
              D.52066 = MEM[(long int *)D.52065];
              iftmp.9 = (sizetype) D.52066;
              goto <D.52079>;
              <D.52078>:
              iftmp.9 = 88;
              <D.52079>:
              D.52080 = this + iftmp.9;
              std::basic_ios<char>::init (D.52080, D.52075);
            }
          catch
            {
              D.52074 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.52074);
            }
        }
      catch
        {
          if (1 == 0) goto <D.52082>; else goto <D.52083>;
          <D.52082>:
          iftmp.10 = 8B;
          goto <D.52084>;
          <D.52083>:
          iftmp.10 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.52084>:
          D.52055 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.52055, iftmp.10);
        }
    }
  catch
    {
      if (1 != 0) goto <D.52085>; else goto <D.52086>;
      <D.52085>:
      D.52049 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.52049);
      goto <D.52087>;
      <D.52086>:
      <D.52087>:
    }
}


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


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

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


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.50565>:
  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)
{
  struct basic_ios * D.52094;
  int (*__vtbl_ptr_type) () * iftmp.11;
  sizetype iftmp.12;
  int (*__vtbl_ptr_type) () * D.52103;
  int (*__vtbl_ptr_type) () * D.52104;
  long int D.52105;
  struct basic_ios * D.52107;
  int (*__vtbl_ptr_type) () * iftmp.13;
  sizetype iftmp.14;
  struct basic_ios * D.52116;

  if (0 != 0) goto <D.52092>; else goto <D.52093>;
  <D.52092>:
  D.52094 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.52094);
  goto <D.52095>;
  <D.52093>:
  <D.52095>:
  try
    {
      if (0 == 0) goto <D.52097>; else goto <D.52098>;
      <D.52097>:
      iftmp.11 = *__vtt_parm;
      goto <D.52099>;
      <D.52098>:
      iftmp.11 = &MEM[(void *)&_ZTVSo + 24B];
      <D.52099>:
      this->_vptr.basic_ostream = iftmp.11;
      if (0 == 0) goto <D.52101>; else goto <D.52102>;
      <D.52101>:
      D.52103 = this->_vptr.basic_ostream;
      D.52104 = D.52103 + 18446744073709551592;
      D.52105 = MEM[(long int *)D.52104];
      iftmp.12 = (sizetype) D.52105;
      goto <D.52106>;
      <D.52102>:
      iftmp.12 = 8;
      <D.52106>:
      D.52107 = this + iftmp.12;
      if (0 == 0) goto <D.52109>; else goto <D.52110>;
      <D.52109>:
      iftmp.13 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.52111>;
      <D.52110>:
      iftmp.13 = &MEM[(void *)&_ZTVSo + 64B];
      <D.52111>:
      D.52107->D.19008._vptr.ios_base = iftmp.13;
      if (0 == 0) goto <D.52113>; else goto <D.52114>;
      <D.52113>:
      D.52103 = this->_vptr.basic_ostream;
      D.52104 = D.52103 + 18446744073709551592;
      D.52105 = MEM[(long int *)D.52104];
      iftmp.14 = (sizetype) D.52105;
      goto <D.52115>;
      <D.52114>:
      iftmp.14 = 8;
      <D.52115>:
      D.52116 = this + iftmp.14;
      std::basic_ios<char>::init (D.52116, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.52117>; else goto <D.52118>;
      <D.52117>:
      D.52094 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.52094);
      goto <D.52119>;
      <D.52118>:
      <D.52119>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.52121;
  int __a.15;
  int __b.16;
  int D.52124;

  __a.15 = (int) __a;
  __b.16 = (int) __b;
  D.52124 = __a.15 | __b.16;
  D.52121 = (_Ios_Openmode) D.52124;
  return D.52121;
}


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.52126;
  struct __string_type * D.52127;

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

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


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.52129;
  struct basic_streambuf * D.52130;
  int D.52131;

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

              }
            finally
              {
                D.52129 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.52129);
              }
          }
        finally
          {
            D.52130 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.52130);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50371>:
  D.52131 = 0;
  if (D.52131 != 0) goto <D.52132>; else goto <D.52133>;
  <D.52132>:
  operator delete (this);
  goto <D.52134>;
  <D.52133>:
  <D.52134>:
}


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

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

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


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


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.50645;
  struct _Rep & D.52138;
  char * D.52139;
  struct _Alloc_hider * D.52140;

  std::allocator<char>::allocator (&D.50645);
  try
    {
      D.52138 = std::basic_string<char>::_S_empty_rep ();
      D.52139 = std::basic_string<char>::_Rep::_M_refdata (D.52138);
      D.52140 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.52140, D.52139, &D.50645);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.50645);
      D.50645 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.52148;
  void * D.52149;

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


std::basic_string<_CharT, _Traits, _Alloc>::_Alloc_hider::_Alloc_hider(_CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Alloc_hider * const this, char * __dat, const struct allocator & __a)
{
  std::allocator<char>::allocator (this, __a);
  try
    {
      this->_M_p = __dat;
    }
  catch
    {
      std::allocator<char>::~allocator (this);
    }
}


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

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


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

  try
    {
      {

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


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

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

          }
        finally
          {
            D.52153 = &this->_M_buf_locale;
            std::locale::~locale (D.52153);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50588>:
  D.52154 = 0;
  if (D.52154 != 0) goto <D.52155>; else goto <D.52156>;
  <D.52155>:
  operator delete (this);
  goto <D.52157>;
  <D.52156>:
  <D.52157>:
}


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.17;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.52165;
  int (*__vtbl_ptr_type) () * D.52166;
  long int D.52167;
  struct basic_ios * D.52169;
  int (*__vtbl_ptr_type) () * iftmp.19;
  int D.52174;
  struct basic_ios * D.52177;
  int D.52179;

  {
    if (0 == 0) goto <D.52159>; else goto <D.52160>;
    <D.52159>:
    iftmp.17 = *__vtt_parm;
    goto <D.52161>;
    <D.52160>:
    iftmp.17 = &MEM[(void *)&_ZTVSo + 24B];
    <D.52161>:
    this->_vptr.basic_ostream = iftmp.17;
    if (0 == 0) goto <D.52163>; else goto <D.52164>;
    <D.52163>:
    D.52165 = this->_vptr.basic_ostream;
    D.52166 = D.52165 + 18446744073709551592;
    D.52167 = MEM[(long int *)D.52166];
    iftmp.18 = (sizetype) D.52167;
    goto <D.52168>;
    <D.52164>:
    iftmp.18 = 8;
    <D.52168>:
    D.52169 = this + iftmp.18;
    if (0 == 0) goto <D.52171>; else goto <D.52172>;
    <D.52171>:
    iftmp.19 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.52173>;
    <D.52172>:
    iftmp.19 = &MEM[(void *)&_ZTVSo + 64B];
    <D.52173>:
    D.52169->D.19008._vptr.ios_base = iftmp.19;
    try
      {
        try
          {

          }
        finally
          {
            D.52174 = 0;
            if (D.52174 != 0) goto <D.52175>; else goto <D.52176>;
            <D.52175>:
            D.52177 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.52177);
            goto <D.52178>;
            <D.52176>:
            <D.52178>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50573>:
  D.52179 = 0;
  if (D.52179 != 0) goto <D.52180>; else goto <D.52181>;
  <D.52180>:
  operator delete (this);
  goto <D.52182>;
  <D.52181>:
  <D.52182>:
}


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

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

          }
        finally
          {
            D.52184 = &this->D.19008;
            std::ios_base::~ios_base (D.52184);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50561>:
  D.52185 = 0;
  if (D.52185 != 0) goto <D.52186>; else goto <D.52187>;
  <D.52186>:
  operator delete (this);
  goto <D.52188>;
  <D.52187>:
  <D.52188>:
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = sigc::trackable] (struct trackable & v)
{
  struct reference_wrapper D.52190;
  struct reference_wrapper D.50447;

  sigc::reference_wrapper<sigc::trackable>::reference_wrapper (&D.50447, v);
  try
    {
      D.52190 = D.50447;
      return D.52190;
    }
  finally
    {
      D.50447 = {CLOBBER};
    }
}


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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = sigc::trackable&; T_return = void] (void (*<T8d0f>) (struct trackable &) _A_func)
{
  struct pointer_functor1 D.52193;
  struct pointer_functor1 D.50445;

  sigc::pointer_functor1<sigc::trackable&, void>::pointer_functor1 (&D.50445, _A_func);
  try
    {
      D.52193 = D.50445;
      return D.52193;
    }
  finally
    {
      D.50445 = {CLOBBER};
    }
}


sigc::pointer_functor1<T_arg1, T_return>::pointer_functor1(sigc::pointer_functor1<T_arg1, T_return>::function_type) [with T_arg1 = sigc::trackable&; T_return = void; sigc::pointer_functor1<T_arg1, T_return>::function_type = void (*)(sigc::trackable&)] (struct pointer_functor1 * const this, void (*function_type) (struct trackable &) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


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

}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = sigc::reference_wrapper<sigc::trackable>; T_functor = sigc::pointer_functor1<sigc::trackable&, void>] (const struct pointer_functor1 & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::pointer_functor1<sigc::trackable&, void>; T_type1 = sigc::reference_wrapper<sigc::trackable>; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor1<sigc::trackable&, void>&; typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<sigc::trackable>&] (struct bind_functor * const this, const struct pointer_functor1 & _A_func, const struct reference_wrapper & _A_bound1)
{
  struct adapts * D.52198;
  struct bound_argument * D.52199;

  D.52198 = &this->D.50138;
  sigc::adapts<sigc::pointer_functor1<sigc::trackable&, void> >::adapts (D.52198, _A_func);
  D.52199 = &this->bound1_;
  sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> >::bound_argument (D.52199, _A_bound1);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::pointer_functor1<sigc::trackable&, void>] (struct adapts * const this, const struct pointer_functor1 & _A_functor)
{
  struct adaptor_type * D.52200;

  sigc::adaptor_base::adaptor_base (this);
  D.52200 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> >::adaptor_functor (D.52200, _A_functor);
}


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


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


sigc::bound_argument<sigc::reference_wrapper<T_type> >::bound_argument(const sigc::reference_wrapper<T_type>&) [with T_wrapped = sigc::trackable] (struct bound_argument * const this, const struct reference_wrapper & _A_argument)
{
  struct trackable & D.52201;
  struct limit_reference * D.52202;

  D.52201 = sigc::unwrap<sigc::trackable> (_A_argument);
  D.52202 = &this->visited_;
  sigc::limit_reference<sigc::trackable, true>::limit_reference (D.52202, D.52201);
}


T_type& sigc::unwrap(const sigc::reference_wrapper<T_type>&) [with T_type = sigc::trackable] (const struct reference_wrapper & v)
{
  struct trackable & D.52204;

  D.52204 = sigc::reference_wrapper<sigc::trackable>::operator sigc::trackable& (v);
  return D.52204;
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = sigc::trackable] (const struct reference_wrapper * const this)
{
  struct trackable & D.52206;

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


sigc::limit_reference<T_type, true>::limit_reference(T_type&) [with T_type = sigc::trackable] (struct limit_reference * const this, struct trackable & _A_target)
{
  this->visited = _A_target;
  this->invoked = _A_target;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot * const this, const struct bind_functor & _A_func)
{
  struct slot0 * D.52208;

  D.52208 = &this->D.49200;
  sigc::slot0<void>::slot0<sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.52208, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot0 * const this, const struct bind_functor & _A_func)
{
  void * D.50780;
  struct slot_base * D.52209;
  struct rep_type * D.52210;
  void * (*<T1711>) (void *) D.52211;

  D.50780 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.50780, _A_func);
    }
  catch
    {
      operator delete (D.50780);
    }
  D.52209 = &this->D.49158;
  sigc::slot_base::slot_base (D.52209, D.50780);
  try
    {
      D.52210 = this->D.49158.rep_;
      D.52211 = sigc::internal::slot_call0<sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void>::address ();
      D.52210->call_ = D.52211;
    }
  catch
    {
      D.52209 = &this->D.49158;
      sigc::slot_base::~slot_base (D.52209);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct bind_functor & functor)
{
  struct slot_rep * D.52214;
  struct adaptor_type * D.52215;
  struct slot_do_bind D.51020;

  D.52214 = &this->D.50763;
  sigc::internal::slot_rep::slot_rep (D.52214, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.52215 = &this->functor_;
      D.52214 = &this->D.50763;
      sigc::internal::slot_do_bind::slot_do_bind (&D.51020, D.52214);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51020, D.52215);
        }
      finally
        {
          D.51020 = {CLOBBER};
        }
    }
  catch
    {
      D.52214 = &this->D.50763;
      sigc::internal::slot_rep::~slot_rep (D.52214);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.52218;
  void * D.51171;
  struct slot_rep * a_rep;

  a_rep = data;
  D.51171 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.51171, a_rep);
    }
  catch
    {
      operator delete (D.51171);
    }
  D.52218 = D.51171;
  return D.52218;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.52222;
  struct slot_rep * D.52223;
  struct adaptor_type * D.52224;
  struct slot_do_bind D.51311;

  D.52222 = cl->D.50763.call_;
  D.52223 = &this->D.50763;
  sigc::internal::slot_rep::slot_rep (D.52223, D.52222, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.52224 = &this->functor_;
      D.52223 = &this->D.50763;
      sigc::internal::slot_do_bind::slot_do_bind (&D.51311, D.52223);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51311, D.52224);
        }
      finally
        {
          D.51311 = {CLOBBER};
        }
    }
  catch
    {
      D.52223 = &this->D.50763;
      sigc::internal::slot_rep::~slot_rep (D.52223);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.52227;
  struct slot_do_unbind D.51156;
  void * D.52228;
  struct self * self_;

  self_ = data;
  self_->D.50763.call_ = 0B;
  self_->D.50763.destroy_ = 0B;
  D.52227 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.51156, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.51156, D.52227);
    }
  finally
    {
      D.51156 = {CLOBBER};
    }
  D.52228 = 0B;
  return D.52228;
}


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct bind_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<sigc::trackable&, void>; T_type1 = sigc::reference_wrapper<sigc::trackable>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52232;
  const struct bound_argument * D.52233;

  D.52232 = &_A_target->D.50138.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> > > (_A_action, D.52232);
  D.52233 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> > > (_A_action, D.52233);
}


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::pointer_functor1<sigc::trackable&, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> > >::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::pointer_functor1<sigc::trackable&, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.52234;

  D.52234 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::pointer_functor1<sigc::trackable&, void> > (_A_action, D.52234);
}


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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<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<sigc::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = sigc::reference_wrapper<sigc::trackable>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.52235;

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


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

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


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

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


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

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


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

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

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


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

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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct bind_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<sigc::trackable&, void>; T_type1 = sigc::reference_wrapper<sigc::trackable>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.52245;
  const struct bound_argument * D.52246;

  D.52245 = &_A_target->D.50138.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> > > (_A_action, D.52245);
  D.52246 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> > > (_A_action, D.52246);
}


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::pointer_functor1<sigc::trackable&, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> > >::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::pointer_functor1<sigc::trackable&, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.52247;

  D.52247 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::pointer_functor1<sigc::trackable&, void> > (_A_action, D.52247);
}


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


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


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<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<sigc::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = sigc::reference_wrapper<sigc::trackable>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.52248;

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


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

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


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

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

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


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

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


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

  D.52255 = this->destroy_;
  if (D.52255 != 0B) goto <D.52256>; else goto <D.52257>;
  <D.52256>:
  D.52255 = this->destroy_;
  D.52255 (this);
  goto <D.52258>;
  <D.52257>:
  <D.52258>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.52259;

  D.52259 = call_it;
  return D.52259;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.52261;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.52261 = &typed_rep->functor_;
  sigc::bind_functor<-1, sigc::pointer_functor1<sigc::trackable&, void>, sigc::reference_wrapper<sigc::trackable>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (D.52261);
  return;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = sigc::pointer_functor1<sigc::trackable&, void>; T_type1 = sigc::reference_wrapper<sigc::trackable>; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = void] (struct bind_functor * const this)
{
  struct bound_argument * D.52263;
  struct trackable & D.52264;
  struct adaptor_type * D.52265;

  D.52263 = &this->bound1_;
  D.52264 = sigc::bound_argument<sigc::reference_wrapper<sigc::trackable> >::invoke (D.52263);
  D.52265 = &this->D.50138.functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<sigc::trackable&, void> >::operator()<sigc::trackable&> (D.52265, D.52264);
  return;
}


T_wrapped& sigc::bound_argument<sigc::reference_wrapper<T_type> >::invoke() [with T_wrapped = sigc::trackable] (struct bound_argument * const this)
{
  struct trackable & D.52268;
  struct limit_reference * D.52269;

  D.52269 = &this->visited_;
  D.52268 = sigc::limit_reference<sigc::trackable, true>::invoke (D.52269);
  return D.52268;
}


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

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


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = sigc::trackable&; T_functor = sigc::pointer_functor1<sigc::trackable&, void>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, struct trackable & _A_arg1)
{
  struct pointer_functor1 * D.52273;

  D.52273 = &this->functor_;
  sigc::pointer_functor1<sigc::trackable&, void>::operator() (D.52273, _A_arg1);
  return;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = sigc::trackable&; T_return = void; typename sigc::type_trait<T_base>::take = sigc::trackable&] (const struct pointer_functor1 * const this, struct trackable & _A_a1)
{
  void (*<T8d0f>) (struct trackable &) D.52275;

  D.52275 = this->func_ptr_;
  D.52275 (_A_a1);
  return;
}


void* memset(void*, int, size_t) (void * __dest, int __ch, size_t __len)
{
  int D.52279;
  int D.52284;
  void * D.52286;
  long unsigned int D.52287;
  void * D.52288;

  try
    {
      D.52279 = __builtin_constant_p (__len);
      if (D.52279 != 0) goto <D.52280>; else goto <D.52281>;
      <D.52280>:
      if (__len == 0) goto <D.52282>; else goto <D.52283>;
      <D.52282>:
      D.52284 = __builtin_constant_p (__ch);
      if (D.52284 == 0) goto <D.52277>; else goto <D.52285>;
      <D.52285>:
      if (__ch != 0) goto <D.52277>; else goto <D.52278>;
      <D.52277>:
      __warn_memset_zero_len ();
      D.52286 = __dest;
      return D.52286;
      <D.52278>:
      <D.52283>:
      <D.52281>:
      D.52287 = __builtin_object_size (__dest, 0);
      D.52286 = __builtin___memset_chk (__dest, __ch, __len, D.52287);
      return D.52286;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.52288 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.52288);
          
        }
    }
}


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

  D.52292 = std::basic_ostream<char>::_M_insert<const void*> (this, __p);
  return D.52292;
}


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.52299;
  int (*__vtbl_ptr_type) () * D.52300;
  long int D.52301;
  sizetype D.52302;
  struct basic_ios * D.52303;
  long unsigned int D.52305;
  long int D.52306;
  struct basic_ostream & D.52307;

  if (__s == 0B) goto <D.52297>; else goto <D.52298>;
  <D.52297>:
  D.52299 = __out->_vptr.basic_ostream;
  D.52300 = D.52299 + 18446744073709551592;
  D.52301 = MEM[(long int *)D.52300];
  D.52302 = (sizetype) D.52301;
  D.52303 = __out + D.52302;
  std::basic_ios<char>::setstate (D.52303, 1);
  goto <D.52304>;
  <D.52298>:
  D.52305 = std::char_traits<char>::length (__s);
  D.52306 = (long int) D.52305;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.52306);
  <D.52304>:
  D.52307 = __out;
  return D.52307;
}


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.52309;
  _Ios_Iostate D.52310;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.52314;
  int __a.20;
  int __b.21;
  int D.52317;

  __a.20 = (int) __a;
  __b.21 = (int) __b;
  D.52317 = __a.20 | __b.21;
  D.52314 = (_Ios_Iostate) D.52317;
  return D.52314;
}


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

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


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.52321;
  long unsigned int D.52322;
  long int D.52323;
  const char * D.52324;

  D.52322 = std::basic_string<char>::size (__str);
  D.52323 = (long int) D.52322;
  D.52324 = std::basic_string<char>::data (__str);
  D.52321 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.52324, D.52323);
  return D.52321;
}


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.52329;
  struct _Rep * D.52330;

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


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.52333;
  char * D.52334;

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


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

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


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

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


std::basic_ostringstream<_CharT, _Traits, _Alloc>::__string_type std::basic_ostringstream<_CharT, _Traits, _Alloc>::str() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_ostringstream<_CharT, _Traits, _Alloc>::__string_type = std::basic_string<char>] (const struct basic_ostringstream * const this)
{
  const struct __stringbuf_type * D.52343;

  D.52343 = &this->_M_stringbuf;
  *<retval> = std::basic_stringbuf<char>::str (D.52343); [return slot optimization]
  return <retval>;
}


std::basic_stringbuf<_CharT, _Traits, _Alloc>::__string_type std::basic_stringbuf<_CharT, _Traits, _Alloc>::str() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_stringbuf<_CharT, _Traits, _Alloc>::__string_type = std::basic_string<char>] (const struct basic_stringbuf * const this)
{
  bool retval.22;
  const struct basic_streambuf * D.52347;
  char_type * D.52348;
  bool retval.23;
  char_type * D.52352;
  char_type * D.52353;
  struct __string_type D.50613;
  struct allocator D.50612;
  char_type * D.52356;
  char_type * D.52357;
  struct __string_type D.50616;
  struct allocator D.50615;
  char_type * D.52359;
  char_type * D.52360;
  const struct __string_type * D.52362;
  struct __string_type __ret [value-expr: *<retval>];

  std::basic_string<char>::basic_string (<retval>);
  try
    {
      D.52347 = &this->D.22162;
      D.52348 = std::basic_streambuf<char>::pptr (D.52347);
      retval.22 = D.52348 != 0B;
      if (retval.22 != 0) goto <D.52349>; else goto <D.52350>;
      <D.52349>:
      D.52347 = &this->D.22162;
      D.52352 = std::basic_streambuf<char>::pptr (D.52347);
      D.52347 = &this->D.22162;
      D.52353 = std::basic_streambuf<char>::egptr (D.52347);
      retval.23 = D.52352 > D.52353;
      if (retval.23 != 0) goto <D.52354>; else goto <D.52355>;
      <D.52354>:
      std::allocator<char>::allocator (&D.50612);
      try
        {
          D.52347 = &this->D.22162;
          D.52356 = std::basic_streambuf<char>::pptr (D.52347);
          D.52347 = &this->D.22162;
          D.52357 = std::basic_streambuf<char>::pbase (D.52347);
          std::basic_string<char>::basic_string<char*> (&D.50613, D.52357, D.52356, &D.50612);
          try
            {
              std::basic_string<char>::operator= (<retval>, &D.50613);
            }
          finally
            {
              std::basic_string<char>::~basic_string (&D.50613);
              D.50613 = {CLOBBER};
            }
        }
      finally
        {
          std::allocator<char>::~allocator (&D.50612);
          D.50612 = {CLOBBER};
        }
      goto <D.52358>;
      <D.52355>:
      std::allocator<char>::allocator (&D.50615);
      try
        {
          D.52347 = &this->D.22162;
          D.52359 = std::basic_streambuf<char>::egptr (D.52347);
          D.52347 = &this->D.22162;
          D.52360 = std::basic_streambuf<char>::pbase (D.52347);
          std::basic_string<char>::basic_string<char*> (&D.50616, D.52360, D.52359, &D.50615);
          try
            {
              std::basic_string<char>::operator= (<retval>, &D.50616);
            }
          finally
            {
              std::basic_string<char>::~basic_string (&D.50616);
              D.50616 = {CLOBBER};
            }
        }
      finally
        {
          std::allocator<char>::~allocator (&D.50615);
          D.50615 = {CLOBBER};
        }
      <D.52358>:
      goto <D.52361>;
      <D.52350>:
      D.52362 = &this->_M_string;
      std::basic_string<char>::operator= (<retval>, D.52362);
      <D.52361>:
      return <retval>;
    }
  catch
    {
      std::basic_string<char>::~basic_string (<retval>);
    }
}


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

  D.52376 = this->_M_out_cur;
  return D.52376;
}


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

  D.52378 = this->_M_in_end;
  return D.52378;
}


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

  D.52380 = this->_M_out_beg;
  return D.52380;
}


std::basic_string<_CharT, _Traits, _Alloc>::basic_string(_InputIterator, _InputIterator, const _Alloc&) [with _InputIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, char * __beg, char * __end, const struct allocator & __a)
{
  char * D.52382;
  struct _Alloc_hider * D.52383;

  D.52382 = std::basic_string<char>::_S_construct<char*> (__beg, __end, __a);
  D.52383 = &this->_M_dataplus;
  std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.52383, D.52382, __a);
  try
    {

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


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&) [with _InIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a)
{
  char * D.52385;
  struct _Integral D.51096;
  struct __false_type D.52386;
  typedef struct _Integral _Integral;

  try
    {
      D.52385 = std::basic_string<char>::_S_construct_aux<char*> (__beg, __end, __a, D.52386);
      return D.52385;
    }
  finally
    {
      D.51096 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct_aux(_InIterator, _InIterator, const _Alloc&, std::__false_type) [with _InIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a, struct __false_type D.51116)
{
  char * D.52391;
  struct forward_iterator_tag D.51265;
  struct _Tag D.51239;
  struct _Tag * D.52392;
  struct forward_iterator_tag D.52393;
  typedef struct _Tag _Tag;

  try
    {
      D.52392 = &D.51239;
      D.52391 = std::basic_string<char>::_S_construct<char*> (__beg, __end, __a, D.52393);
      return D.52391;
    }
  finally
    {
      D.51239 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&, std::forward_iterator_tag) [with _FwdIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a, struct forward_iterator_tag D.51244)
{
  bool retval.24;
  bool iftmp.25;
  struct allocator D.51459;
  bool cleanup.26;
  bool D.52406;
  char * D.52410;
  struct _Rep & D.52411;
  bool retval.27;
  bool iftmp.28;
  bool D.52416;
  long int D.52421;
  char * D.52422;
  void * D.52423;
  const size_type __dnew;
  struct _Rep * __r;

  cleanup.26 = 0;
  try
    {
      if (__beg == __end) goto <D.52402>; else goto <D.52400>;
      <D.52402>:
      std::allocator<char>::allocator (&D.51459);
      cleanup.26 = 1;
      D.52406 = std::operator==<char> (__a, &D.51459);
      if (D.52406 != 0) goto <D.52407>; else goto <D.52400>;
      <D.52407>:
      iftmp.25 = 1;
      goto <D.52401>;
      <D.52400>:
      iftmp.25 = 0;
      <D.52401>:
      retval.24 = iftmp.25;
    }
  finally
    {
      if (cleanup.26 != 0) goto <D.52404>; else goto <D.52405>;
      <D.52404>:
      std::allocator<char>::~allocator (&D.51459);
      D.51459 = {CLOBBER};
      <D.52405>:
    }
  if (retval.24 != 0) goto <D.52408>; else goto <D.52409>;
  <D.52408>:
  D.52411 = std::basic_string<char>::_S_empty_rep ();
  D.52410 = std::basic_string<char>::_Rep::_M_refdata (D.52411);
  return D.52410;
  <D.52409>:
  D.52416 = __gnu_cxx::__is_null_pointer<char> (__beg);
  if (D.52416 != 0) goto <D.52417>; else goto <D.52414>;
  <D.52417>:
  if (__beg != __end) goto <D.52418>; else goto <D.52414>;
  <D.52418>:
  iftmp.28 = 1;
  goto <D.52415>;
  <D.52414>:
  iftmp.28 = 0;
  <D.52415>:
  retval.27 = iftmp.28;
  if (retval.27 != 0) goto <D.52419>; else goto <D.52420>;
  <D.52419>:
  std::__throw_logic_error ("basic_string::_S_construct null not valid");
  <D.52420>:
  D.52421 = std::distance<char*> (__beg, __end);
  __dnew = (const size_type) D.52421;
  __r = std::basic_string<char>::_Rep::_S_create (__dnew, 0, __a);
  try
    {
      D.52422 = std::basic_string<char>::_Rep::_M_refdata (__r);
      std::basic_string<char>::_S_copy_chars (D.52422, __beg, __end);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.52423 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.52423);
              std::basic_string<char>::_Rep::_M_destroy (__r, __a);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  std::basic_string<char>::_Rep::_M_set_length_and_sharable (__r, __dnew);
  D.52410 = std::basic_string<char>::_Rep::_M_refdata (__r);
  return D.52410;
}


bool std::operator==(const std::allocator<_CharT>&, const std::allocator<_CharT>&) [with _Tp = char] (const struct allocator & D.51464, const struct allocator & D.51465)
{
  bool D.52431;

  D.52431 = 1;
  return D.52431;
}


bool __gnu_cxx::__is_null_pointer(_Type*) [with _Type = char] (char * __ptr)
{
  bool D.52433;

  D.52433 = __ptr == 0B;
  return D.52433;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (char * __first, char * __last)
{
  difference_type D.52435;
  struct iterator_category D.51719;
  struct random_access_iterator_tag D.52436;
  char * __first.29;

  std::__iterator_category<char*> (&__first);
  try
    {
      __first.29 = __first;
      D.52435 = std::__distance<char*> (__first.29, __last, D.52436);
      return D.52435;
    }
  finally
    {
      D.51719 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = char*; typename std::iterator_traits<_Iterator>::iterator_category = std::random_access_iterator_tag] (char * const & D.51718)
{
  struct iterator_category D.52440;

  return D.52440;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_RandomAccessIterator, _RandomAccessIterator, std::random_access_iterator_tag) [with _RandomAccessIterator = char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (char * __first, char * __last, struct random_access_iterator_tag D.51723)
{
  difference_type D.52442;
  long int __last.30;
  long int __first.31;

  __last.30 = (long int) __last;
  __first.31 = (long int) __first;
  D.52442 = __last.30 - __first.31;
  return D.52442;
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_S_copy_chars(_CharT*, _CharT*, _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __p, char * __k1, char * __k2)
{
  long int __k2.32;
  long int __k1.33;
  long int D.52448;
  long unsigned int D.52449;

  __k2.32 = (long int) __k2;
  __k1.33 = (long int) __k1;
  D.52448 = __k2.32 - __k1.33;
  D.52449 = (long unsigned int) D.52448;
  std::basic_string<char>::_M_copy (__p, __k1, D.52449);
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_M_copy(_CharT*, const _CharT*, std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (char * __d, const char * __s, size_type __n)
{
  if (__n == 1) goto <D.52450>; else goto <D.52451>;
  <D.52450>:
  std::char_traits<char>::assign (__d, __s);
  goto <D.52452>;
  <D.52451>:
  std::char_traits<char>::copy (__d, __s, __n);
  <D.52452>:
}


static void std::char_traits<char>::assign(std::char_traits<char>::char_type&, const char_type&) (char_type & __c1, const char_type & __c2)
{
  char D.52453;

  D.52453 = *__c2;
  *__c1 = D.52453;
}


static std::char_traits<char>::char_type* std::char_traits<char>::copy(std::char_traits<char>::char_type*, const char_type*, std::size_t) (char_type * __s1, const char_type * __s2, size_t __n)
{
  char_type * D.52454;

  D.52454 = __builtin_memcpy (__s1, __s2, __n);
  return D.52454;
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_length_and_sharable(std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (struct _Rep * const this, size_type __n)
{
  bool retval.34;
  struct _Rep & D.52457;
  bool D.52458;
  long int D.52459;
  long int D.52460;
  char * D.52463;
  char * D.52464;

  D.52457 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.52458 = D.52457 != this;
  D.52459 = (long int) D.52458;
  D.52460 = __builtin_expect (D.52459, 0);
  retval.34 = D.52460 != 0;
  if (retval.34 != 0) goto <D.52461>; else goto <D.52462>;
  <D.52461>:
  std::basic_string<char>::_Rep::_M_set_sharable (this);
  this->D.11865._M_length = __n;
  D.52463 = std::basic_string<char>::_Rep::_M_refdata (this);
  D.52464 = D.52463 + __n;
  std::char_traits<char>::assign (D.52464, &_S_terminal);
  goto <D.52465>;
  <D.52462>:
  <D.52465>:
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_sharable() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  this->D.11865._M_refcount = 0;
}


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

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


std::basic_string<_CharT, _Traits, _Alloc> std::operator+(const _CharT*, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const char * __lhs, const struct basic_string & __rhs)
{
  long unsigned int D.52471;
  long unsigned int D.52472;
  typedef struct __string_type __string_type;
  typedef __size_type __size_type;
  const __size_type __len;
  struct __string_type __str [value-expr: *<retval>];

  __len = std::char_traits<char>::length (__lhs);
  std::basic_string<char>::basic_string (<retval>);
  try
    {
      D.52471 = std::basic_string<char>::size (__rhs);
      D.52472 = D.52471 + __len;
      std::basic_string<char>::reserve (<retval>, D.52472);
      std::basic_string<char>::append (<retval>, __lhs, __len);
      std::basic_string<char>::append (<retval>, __rhs);
      return <retval>;
    }
  catch
    {
      std::basic_string<char>::~basic_string (<retval>);
    }
}


void std::basic_ostringstream<_CharT, _Traits, _Alloc>::str(const __string_type&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_ostringstream<_CharT, _Traits, _Alloc>::__string_type = std::basic_string<char>] (struct basic_ostringstream * const this, const struct __string_type & __s)
{
  struct __stringbuf_type * D.52476;

  D.52476 = &this->_M_stringbuf;
  std::basic_stringbuf<char>::str (D.52476, __s);
}


void std::basic_stringbuf<_CharT, _Traits, _Alloc>::str(const __string_type&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_stringbuf<_CharT, _Traits, _Alloc>::__string_type = std::basic_string<char>] (struct basic_stringbuf * const this, const struct __string_type & __s)
{
  long unsigned int D.52477;
  const char * D.52478;
  struct __string_type * D.52479;
  _Ios_Openmode D.52480;

  D.52477 = std::basic_string<char>::size (__s);
  D.52478 = std::basic_string<char>::data (__s);
  D.52479 = &this->_M_string;
  std::basic_string<char>::assign (D.52479, D.52478, D.52477);
  D.52480 = this->_M_mode;
  std::basic_stringbuf<char>::_M_stringbuf_init (this, D.52480);
}


void std::basic_stringbuf<_CharT, _Traits, _Alloc>::_M_stringbuf_init(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)
{
  bool retval.35;
  _Ios_Openmode D.52484;
  _Ios_Openmode D.52485;
  _Ios_Openmode D.52486;
  struct __string_type * D.52489;
  const char * D.52491;
  __size_type __len;

  this->_M_mode = __mode;
  __len = 0;
  D.52484 = std::operator| (2, 1);
  D.52485 = this->_M_mode;
  D.52486 = std::operator& (D.52485, D.52484);
  retval.35 = D.52486 != 0;
  if (retval.35 != 0) goto <D.52487>; else goto <D.52488>;
  <D.52487>:
  D.52489 = &this->_M_string;
  __len = std::basic_string<char>::size (D.52489);
  goto <D.52490>;
  <D.52488>:
  <D.52490>:
  D.52489 = &this->_M_string;
  D.52491 = std::basic_string<char>::data (D.52489);
  std::basic_stringbuf<char>::_M_sync (this, D.52491, 0, __len);
}


std::_Ios_Openmode std::operator&(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.52494;
  int __a.36;
  int __b.37;
  int D.52497;

  __a.36 = (int) __a;
  __b.37 = (int) __b;
  D.52497 = __a.36 & __b.37;
  D.52494 = (_Ios_Openmode) D.52497;
  return D.52494;
}


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

  D.52499 = &this->D.49200;
  sigc::slot0<void>::slot0 (D.52499, src);
  try
    {

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


sigc::slot0<T_return>::slot0(const sigc::slot0<T_return>&) [with T_return = void] (struct slot0 * const this, const struct slot0 & src)
{
  const struct slot_base * D.52500;
  struct slot_base * D.52501;

  D.52500 = &src->D.49158;
  D.52501 = &this->D.49158;
  sigc::slot_base::slot_base (D.52501, D.52500);
  try
    {

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


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.38;
  bool iftmp.39;
  const struct slot_base * D.52506;
  bool D.52507;
  bool D.52508;
  bool D.52510;
  bool D.52511;
  struct rep_type * D.52515;
  void * (*<T1711>) (void *) D.52516;

  D.52506 = &this->D.49158;
  D.52507 = sigc::slot_base::empty (D.52506);
  D.52508 = ~D.52507;
  if (D.52508 != 0) goto <D.52509>; else goto <D.52504>;
  <D.52509>:
  D.52506 = &this->D.49158;
  D.52510 = sigc::slot_base::blocked (D.52506);
  D.52511 = ~D.52510;
  if (D.52511 != 0) goto <D.52512>; else goto <D.52504>;
  <D.52512>:
  iftmp.39 = 1;
  goto <D.52505>;
  <D.52504>:
  iftmp.39 = 0;
  <D.52505>:
  retval.38 = iftmp.39;
  if (retval.38 != 0) goto <D.52513>; else goto <D.52514>;
  <D.52513>:
  D.52515 = this->D.49158.rep_;
  D.52516 = D.52515->call_;
  D.52515 = this->D.49158.rep_;
  D.52516 (D.52515);
  return;
  <D.52514>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.52518;
  bool iftmp.40;
  struct rep_type * D.52523;
  void * (*<T1711>) (void *) D.52525;

  D.52523 = this->rep_;
  if (D.52523 == 0B) goto <D.52520>; else goto <D.52524>;
  <D.52524>:
  D.52523 = this->rep_;
  D.52525 = D.52523->call_;
  if (D.52525 == 0B) goto <D.52520>; else goto <D.52521>;
  <D.52520>:
  iftmp.40 = 1;
  goto <D.52522>;
  <D.52521>:
  iftmp.40 = 0;
  <D.52522>:
  D.52518 = iftmp.40;
  return D.52518;
}


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

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


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

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

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


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

  try
    {
      {

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


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.50413;
  struct _Rep * D.52531;
  struct _Alloc_hider * D.52532;

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


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

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


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.41;
  struct _Rep & D.52541;
  bool D.52542;
  long int D.52543;
  long int D.52544;
  bool retval.42;
  _Atomic_word * D.52548;
  int D.52549;

  D.52541 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.52542 = D.52541 != this;
  D.52543 = (long int) D.52542;
  D.52544 = __builtin_expect (D.52543, 0);
  retval.41 = D.52544 != 0;
  if (retval.41 != 0) goto <D.52545>; else goto <D.52546>;
  <D.52545>:
  D.52548 = &this->D.11865._M_refcount;
  D.52549 = __gnu_cxx::__exchange_and_add_dispatch (D.52548, -1);
  retval.42 = D.52549 <= 0;
  if (retval.42 != 0) goto <D.52550>; else goto <D.52551>;
  <D.52550>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.52552>;
  <D.52551>:
  <D.52552>:
  goto <D.52553>;
  <D.52546>:
  <D.52553>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.43;
  int D.52556;
  _Atomic_word D.52559;

  D.52556 = __gthread_active_p ();
  retval.43 = D.52556 != 0;
  if (retval.43 != 0) goto <D.52557>; else goto <D.52558>;
  <D.52557>:
  D.52559 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.52559;
  <D.52558>:
  D.52559 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.52559;
}


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

  D.52562 = __gthrw___pthread_key_create != 0B;
  D.52561 = (int) D.52562;
  return D.52561;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.52564;
  unsigned int __val.44;
  unsigned int D.52566;

  __val.44 = (unsigned int) __val;
  D.52566 = __atomic_fetch_add_4 (__mem, __val.44, 4);
  D.52564 = (_Atomic_word) D.52566;
  return D.52564;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.52568;
  int D.52569;
  _Atomic_word D.52570;
  _Atomic_word __result;

  __result = *__mem;
  D.52568 = *__mem;
  D.52569 = D.52568 + __val;
  *__mem = D.52569;
  D.52570 = __result;
  return D.52570;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52574 = &this->D.49200;
            sigc::slot0<void>::~slot0 (D.52574);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50181>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.52576 = &this->D.49158;
            sigc::slot_base::~slot_base (D.52576);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50176>:
}


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.45;
  const void * * D.52581;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.52586;
  int (*__vtbl_ptr_type) () * D.52587;
  long int D.52588;
  struct basic_ios * D.52590;
  int (*__vtbl_ptr_type) () * iftmp.47;
  struct __stringbuf_type * D.52595;
  const void * * iftmp.48;
  struct basic_ostream * D.52600;
  int D.52601;
  struct basic_ios * D.52604;
  int D.52606;

  {
    if (2 == 0) goto <D.52579>; else goto <D.52580>;
    <D.52579>:
    D.52581 = 0B;
    iftmp.45 = *D.52581;
    goto <D.52582>;
    <D.52580>:
    iftmp.45 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.52582>:
    this->D.22312._vptr.basic_ostream = iftmp.45;
    if (2 == 0) goto <D.52584>; else goto <D.52585>;
    <D.52584>:
    D.52586 = this->D.22312._vptr.basic_ostream;
    D.52587 = D.52586 + 18446744073709551592;
    D.52588 = MEM[(long int *)D.52587];
    iftmp.46 = (sizetype) D.52588;
    goto <D.52589>;
    <D.52585>:
    iftmp.46 = 88;
    <D.52589>:
    D.52590 = this + iftmp.46;
    if (2 == 0) goto <D.52592>; else goto <D.52593>;
    <D.52592>:
    iftmp.47 = MEM[(const void * *)0B + 24B];
    goto <D.52594>;
    <D.52593>:
    iftmp.47 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.52594>:
    D.52590->D.19008._vptr.ios_base = iftmp.47;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.52595 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.52595);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.52597>; else goto <D.52598>;
                <D.52597>:
                iftmp.48 = 8B;
                goto <D.52599>;
                <D.52598>:
                iftmp.48 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.52599>:
                D.52600 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.52600, iftmp.48);
              }
          }
        finally
          {
            D.52601 = 2;
            if (D.52601 != 0) goto <D.52602>; else goto <D.52603>;
            <D.52602>:
            D.52604 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.52604);
            goto <D.52605>;
            <D.52603>:
            <D.52605>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50386>:
  D.52606 = 0;
  if (D.52606 != 0) goto <D.52607>; else goto <D.52608>;
  <D.52607>:
  operator delete (this);
  goto <D.52609>;
  <D.52608>:
  <D.52609>:
}


(static initializers for test_copy_invalid_slot.cc) ()
{
  __static_initialization_and_destruction_0 (1, 65535);
}


void __static_initialization_and_destruction_0(int, int) (int __initialize_p, int __priority)
{
  if (__initialize_p == 1) goto <D.52619>; else goto <D.52620>;
  <D.52619>:
  if (__priority == 65535) goto <D.52621>; else goto <D.52622>;
  <D.52621>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.52623>;
  <D.52622>:
  <D.52623>:
  goto <D.52624>;
  <D.52620>:
  <D.52624>:
}


