int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.49314;
  int D.49317;
  int iftmp.1;
  bool D.49319;
  const struct string D.48727;
  struct allocator D.48726;
  int iftmp.2;
  bool D.49324;

  {
    struct TestUtilities * util;

    util = TestUtilities::get_instance ();
    D.49314 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.49314;
    if (retval.0 != 0) goto <D.49315>; else goto <D.49316>;
    <D.49315>:
    D.49319 = TestUtilities::get_result_and_delete_instance ();
    if (D.49319 != 0) goto <D.49320>; else goto <D.49321>;
    <D.49320>:
    iftmp.1 = 0;
    goto <D.49322>;
    <D.49321>:
    iftmp.1 = 1;
    <D.49322>:
    D.49317 = iftmp.1;
    return D.49317;
    <D.49316>:
    std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Example result string");
    std::allocator<char>::allocator (&D.48726);
    try
      {
        std::basic_string<char>::basic_string (&D.48727, "Example result string", &D.48726);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48727);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48727);
            D.48727 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48726);
        D.48726 = {CLOBBER};
      }
    D.49324 = TestUtilities::get_result_and_delete_instance ();
    if (D.49324 != 0) goto <D.49325>; else goto <D.49326>;
    <D.49325>:
    iftmp.2 = 0;
    goto <D.49327>;
    <D.49326>:
    iftmp.2 = 1;
    <D.49327>:
    D.49317 = iftmp.2;
    return D.49317;
  }
  D.49317 = 0;
  return D.49317;
}


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.49338;
  int (*__vtbl_ptr_type) () * D.49339;
  long int D.49340;
  sizetype D.49341;
  struct basic_ios * D.49342;
  long unsigned int D.49344;
  long int D.49345;
  struct basic_ostream & D.49346;

  if (__s == 0B) goto <D.49336>; else goto <D.49337>;
  <D.49336>:
  D.49338 = __out->_vptr.basic_ostream;
  D.49339 = D.49338 + 18446744073709551592;
  D.49340 = MEM[(long int *)D.49339];
  D.49341 = (sizetype) D.49340;
  D.49342 = __out + D.49341;
  std::basic_ios<char>::setstate (D.49342, 1);
  goto <D.49343>;
  <D.49337>:
  D.49344 = std::char_traits<char>::length (__s);
  D.49345 = (long int) D.49344;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.49345);
  <D.49343>:
  D.49346 = __out;
  return D.49346;
}


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.49348;
  _Ios_Iostate D.49349;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.49356 = __a.3 | __b.4;
  D.49353 = (_Ios_Iostate) D.49356;
  return D.49353;
}


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

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


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

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

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


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

  try
    {
      {

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


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.48930;
  struct _Rep * D.49362;
  struct _Alloc_hider * D.49363;

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


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

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


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

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


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

  try
    {
      {

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


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.49373;
  char * D.49374;

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


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

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


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.5;
  struct _Rep & D.49380;
  bool D.49381;
  long int D.49382;
  long int D.49383;
  bool retval.6;
  _Atomic_word * D.49387;
  int D.49388;

  D.49380 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.49381 = D.49380 != this;
  D.49382 = (long int) D.49381;
  D.49383 = __builtin_expect (D.49382, 0);
  retval.5 = D.49383 != 0;
  if (retval.5 != 0) goto <D.49384>; else goto <D.49385>;
  <D.49384>:
  D.49387 = &this->D.11865._M_refcount;
  D.49388 = __gnu_cxx::__exchange_and_add_dispatch (D.49387, -1);
  retval.6 = D.49388 <= 0;
  if (retval.6 != 0) goto <D.49389>; else goto <D.49390>;
  <D.49389>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.49391>;
  <D.49390>:
  <D.49391>:
  goto <D.49392>;
  <D.49385>:
  <D.49392>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.7;
  int D.49397;
  _Atomic_word D.49400;

  D.49397 = __gthread_active_p ();
  retval.7 = D.49397 != 0;
  if (retval.7 != 0) goto <D.49398>; else goto <D.49399>;
  <D.49398>:
  D.49400 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.49400;
  <D.49399>:
  D.49400 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.49400;
}


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

  D.49403 = __gthrw___pthread_key_create != 0B;
  D.49402 = (int) D.49403;
  return D.49402;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.49405;
  unsigned int __val.8;
  unsigned int D.49407;

  __val.8 = (unsigned int) __val;
  D.49407 = __atomic_fetch_add_4 (__mem, __val.8, 4);
  D.49405 = (_Atomic_word) D.49407;
  return D.49405;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.49409;
  int D.49410;
  _Atomic_word D.49411;
  _Atomic_word __result;

  __result = *__mem;
  D.49409 = *__mem;
  D.49410 = D.49409 + __val;
  *__mem = D.49410;
  D.49411 = __result;
  return D.49411;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_custom.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.49415>; else goto <D.49416>;
  <D.49415>:
  if (__priority == 65535) goto <D.49417>; else goto <D.49418>;
  <D.49417>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.49419>;
  <D.49418>:
  <D.49419>:
  goto <D.49420>;
  <D.49416>:
  <D.49420>:
}


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.9;
  const void * * D.49424;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.49429;
  int (*__vtbl_ptr_type) () * D.49430;
  long int D.49431;
  struct basic_ios * D.49433;
  int (*__vtbl_ptr_type) () * iftmp.11;
  struct __stringbuf_type * D.49438;
  const void * * iftmp.12;
  struct basic_ostream * D.49443;
  int D.49444;
  struct basic_ios * D.49447;
  int D.49449;

  {
    if (2 == 0) goto <D.49422>; else goto <D.49423>;
    <D.49422>:
    D.49424 = 0B;
    iftmp.9 = *D.49424;
    goto <D.49425>;
    <D.49423>:
    iftmp.9 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.49425>:
    this->D.22312._vptr.basic_ostream = iftmp.9;
    if (2 == 0) goto <D.49427>; else goto <D.49428>;
    <D.49427>:
    D.49429 = this->D.22312._vptr.basic_ostream;
    D.49430 = D.49429 + 18446744073709551592;
    D.49431 = MEM[(long int *)D.49430];
    iftmp.10 = (sizetype) D.49431;
    goto <D.49432>;
    <D.49428>:
    iftmp.10 = 88;
    <D.49432>:
    D.49433 = this + iftmp.10;
    if (2 == 0) goto <D.49435>; else goto <D.49436>;
    <D.49435>:
    iftmp.11 = MEM[(const void * *)0B + 24B];
    goto <D.49437>;
    <D.49436>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.49437>:
    D.49433->D.19008._vptr.ios_base = iftmp.11;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.49438 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.49438);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.49440>; else goto <D.49441>;
                <D.49440>:
                iftmp.12 = 8B;
                goto <D.49442>;
                <D.49441>:
                iftmp.12 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.49442>:
                D.49443 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.49443, iftmp.12);
              }
          }
        finally
          {
            D.49444 = 2;
            if (D.49444 != 0) goto <D.49445>; else goto <D.49446>;
            <D.49445>:
            D.49447 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.49447);
            goto <D.49448>;
            <D.49446>:
            <D.49448>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49308>:
  D.49449 = 0;
  if (D.49449 != 0) goto <D.49450>; else goto <D.49451>;
  <D.49450>:
  operator delete (this);
  goto <D.49452>;
  <D.49451>:
  <D.49452>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.49462;
  struct basic_streambuf * D.49463;
  int D.49464;

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

              }
            finally
              {
                D.49462 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.49462);
              }
          }
        finally
          {
            D.49463 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.49463);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48891>:
  D.49464 = 0;
  if (D.49464 != 0) goto <D.49465>; else goto <D.49466>;
  <D.49465>:
  operator delete (this);
  goto <D.49467>;
  <D.49466>:
  <D.49467>:
}


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

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

          }
        finally
          {
            D.49470 = &this->_M_buf_locale;
            std::locale::~locale (D.49470);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49032>:
  D.49471 = 0;
  if (D.49471 != 0) goto <D.49472>; else goto <D.49473>;
  <D.49472>:
  operator delete (this);
  goto <D.49474>;
  <D.49473>:
  <D.49474>:
}


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


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


std::basic_ostream<_CharT, _Traits>::~basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.13;
  sizetype iftmp.14;
  int (*__vtbl_ptr_type) () * D.49482;
  int (*__vtbl_ptr_type) () * D.49483;
  long int D.49484;
  struct basic_ios * D.49486;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int D.49491;
  struct basic_ios * D.49494;
  int D.49496;

  {
    if (0 == 0) goto <D.49476>; else goto <D.49477>;
    <D.49476>:
    iftmp.13 = *__vtt_parm;
    goto <D.49478>;
    <D.49477>:
    iftmp.13 = &MEM[(void *)&_ZTVSo + 24B];
    <D.49478>:
    this->_vptr.basic_ostream = iftmp.13;
    if (0 == 0) goto <D.49480>; else goto <D.49481>;
    <D.49480>:
    D.49482 = this->_vptr.basic_ostream;
    D.49483 = D.49482 + 18446744073709551592;
    D.49484 = MEM[(long int *)D.49483];
    iftmp.14 = (sizetype) D.49484;
    goto <D.49485>;
    <D.49481>:
    iftmp.14 = 8;
    <D.49485>:
    D.49486 = this + iftmp.14;
    if (0 == 0) goto <D.49488>; else goto <D.49489>;
    <D.49488>:
    iftmp.15 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.49490>;
    <D.49489>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 64B];
    <D.49490>:
    D.49486->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {

          }
        finally
          {
            D.49491 = 0;
            if (D.49491 != 0) goto <D.49492>; else goto <D.49493>;
            <D.49492>:
            D.49494 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.49494);
            goto <D.49495>;
            <D.49493>:
            <D.49495>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49017>:
  D.49496 = 0;
  if (D.49496 != 0) goto <D.49497>; else goto <D.49498>;
  <D.49497>:
  operator delete (this);
  goto <D.49499>;
  <D.49498>:
  <D.49499>:
}


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

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

          }
        finally
          {
            D.49501 = &this->D.19008;
            std::ios_base::~ios_base (D.49501);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49005>:
  D.49502 = 0;
  if (D.49502 != 0) goto <D.49503>; else goto <D.49504>;
  <D.49503>:
  operator delete (this);
  goto <D.49505>;
  <D.49504>:
  <D.49505>:
}


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


std::basic_ostringstream<_CharT, _Traits, _Alloc>::basic_ostringstream(std::ios_base::openmode) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::ios_base::openmode = std::_Ios_Openmode] (struct basic_ostringstream * const this, openmode __mode)
{
  struct basic_ios * D.49509;
  const void * * iftmp.16;
  struct basic_ostream * D.49515;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.49519;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.49524;
  int (*__vtbl_ptr_type) () * D.49525;
  long int D.49526;
  struct basic_ios * D.49528;
  int (*__vtbl_ptr_type) () * iftmp.19;
  _Ios_Openmode D.49533;
  struct __stringbuf_type * D.49534;
  struct basic_streambuf * D.49535;
  sizetype iftmp.20;
  struct basic_ios * D.49540;
  const void * * iftmp.21;

  if (1 != 0) goto <D.49507>; else goto <D.49508>;
  <D.49507>:
  D.49509 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.49509);
  goto <D.49510>;
  <D.49508>:
  <D.49510>:
  try
    {
      if (1 == 0) goto <D.49512>; else goto <D.49513>;
      <D.49512>:
      iftmp.16 = 8B;
      goto <D.49514>;
      <D.49513>:
      iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.49514>:
      D.49515 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.49515, iftmp.16);
      try
        {
          if (1 == 0) goto <D.49517>; else goto <D.49518>;
          <D.49517>:
          D.49519 = 0B;
          iftmp.17 = *D.49519;
          goto <D.49520>;
          <D.49518>:
          iftmp.17 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.49520>:
          this->D.22312._vptr.basic_ostream = iftmp.17;
          if (1 == 0) goto <D.49522>; else goto <D.49523>;
          <D.49522>:
          D.49524 = this->D.22312._vptr.basic_ostream;
          D.49525 = D.49524 + 18446744073709551592;
          D.49526 = MEM[(long int *)D.49525];
          iftmp.18 = (sizetype) D.49526;
          goto <D.49527>;
          <D.49523>:
          iftmp.18 = 88;
          <D.49527>:
          D.49528 = this + iftmp.18;
          if (1 == 0) goto <D.49530>; else goto <D.49531>;
          <D.49530>:
          iftmp.19 = MEM[(const void * *)0B + 24B];
          goto <D.49532>;
          <D.49531>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.49532>:
          D.49528->D.19008._vptr.ios_base = iftmp.19;
          D.49533 = std::operator| (__mode, 16);
          D.49534 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.49534, D.49533);
          try
            {
              D.49535 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.49537>; else goto <D.49538>;
              <D.49537>:
              D.49524 = this->D.22312._vptr.basic_ostream;
              D.49525 = D.49524 + 18446744073709551592;
              D.49526 = MEM[(long int *)D.49525];
              iftmp.20 = (sizetype) D.49526;
              goto <D.49539>;
              <D.49538>:
              iftmp.20 = 88;
              <D.49539>:
              D.49540 = this + iftmp.20;
              std::basic_ios<char>::init (D.49540, D.49535);
            }
          catch
            {
              D.49534 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.49534);
            }
        }
      catch
        {
          if (1 == 0) goto <D.49542>; else goto <D.49543>;
          <D.49542>:
          iftmp.21 = 8B;
          goto <D.49544>;
          <D.49543>:
          iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.49544>:
          D.49515 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.49515, iftmp.21);
        }
    }
  catch
    {
      if (1 != 0) goto <D.49545>; else goto <D.49546>;
      <D.49545>:
      D.49509 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.49509);
      goto <D.49547>;
      <D.49546>:
      <D.49547>:
    }
}


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

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


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.49554;
  int (*__vtbl_ptr_type) () * iftmp.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.49563;
  int (*__vtbl_ptr_type) () * D.49564;
  long int D.49565;
  struct basic_ios * D.49567;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  struct basic_ios * D.49576;

  if (0 != 0) goto <D.49552>; else goto <D.49553>;
  <D.49552>:
  D.49554 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.49554);
  goto <D.49555>;
  <D.49553>:
  <D.49555>:
  try
    {
      if (0 == 0) goto <D.49557>; else goto <D.49558>;
      <D.49557>:
      iftmp.22 = *__vtt_parm;
      goto <D.49559>;
      <D.49558>:
      iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
      <D.49559>:
      this->_vptr.basic_ostream = iftmp.22;
      if (0 == 0) goto <D.49561>; else goto <D.49562>;
      <D.49561>:
      D.49563 = this->_vptr.basic_ostream;
      D.49564 = D.49563 + 18446744073709551592;
      D.49565 = MEM[(long int *)D.49564];
      iftmp.23 = (sizetype) D.49565;
      goto <D.49566>;
      <D.49562>:
      iftmp.23 = 8;
      <D.49566>:
      D.49567 = this + iftmp.23;
      if (0 == 0) goto <D.49569>; else goto <D.49570>;
      <D.49569>:
      iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.49571>;
      <D.49570>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
      <D.49571>:
      D.49567->D.19008._vptr.ios_base = iftmp.24;
      if (0 == 0) goto <D.49573>; else goto <D.49574>;
      <D.49573>:
      D.49563 = this->_vptr.basic_ostream;
      D.49564 = D.49563 + 18446744073709551592;
      D.49565 = MEM[(long int *)D.49564];
      iftmp.25 = (sizetype) D.49565;
      goto <D.49575>;
      <D.49574>:
      iftmp.25 = 8;
      <D.49575>:
      D.49576 = this + iftmp.25;
      std::basic_ios<char>::init (D.49576, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.49577>; else goto <D.49578>;
      <D.49577>:
      D.49554 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.49554);
      goto <D.49579>;
      <D.49578>:
      <D.49579>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.49581;
  int __a.26;
  int __b.27;
  int D.49584;

  __a.26 = (int) __a;
  __b.27 = (int) __b;
  D.49584 = __a.26 | __b.27;
  D.49581 = (_Ios_Openmode) D.49584;
  return D.49581;
}


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.49586;
  struct __string_type * D.49587;

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

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


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

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

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


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.49188;
  struct _Rep & D.49590;
  char * D.49591;
  struct _Alloc_hider * D.49592;

  std::allocator<char>::allocator (&D.49188);
  try
    {
      D.49590 = std::basic_string<char>::_S_empty_rep ();
      D.49591 = std::basic_string<char>::_Rep::_M_refdata (D.49590);
      D.49592 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.49592, D.49591, &D.49188);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.49188);
      D.49188 = {CLOBBER};
    }
  try
    {

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


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

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


_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.49598;
  void * D.49599;

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


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


