TestUtilities::TestUtilities() (struct TestUtilities * const this)
{
  this->verbose_ = 0;
  this->result_ok_ = 1;
  this->test_number_ = 0;
}


static TestUtilities* TestUtilities::get_instance() ()
{
  struct TestUtilities * instance_.0;
  void * instance_.1;
  struct TestUtilities * D.23749;

  instance_.0 = instance_;
  if (instance_.0 == 0B) goto <D.23746>; else goto <D.23747>;
  <D.23746>:
  instance_.1 = operator new (8);
  try
    {
      TestUtilities::TestUtilities (instance_.1);
    }
  catch
    {
      operator delete (instance_.1);
    }
  instance_ = instance_.1;
  goto <D.23748>;
  <D.23747>:
  <D.23748>:
  D.23749 = instance_;
  return D.23749;
}


bool TestUtilities::check_command_args(int, char**) (struct TestUtilities * const this, int argc, char * * argv)
{
  long unsigned int D.23755;
  long unsigned int D.23756;
  char * * D.23757;
  char * D.23758;
  int D.23759;
  int D.23761;
  int D.23762;
  int D.23765;
  struct basic_ostream & D.23768;
  struct basic_ostream & D.23769;
  char * D.23773;
  struct basic_ostream & D.23774;
  struct basic_ostream & D.23775;
  struct basic_ostream & D.23776;
  bool D.23778;
  bool go_on;
  bool print_help;

  go_on = 1;
  print_help = 0;
  {
    int argi;

    argi = 1;
    goto <D.23204>;
    <D.23203>:
    D.23755 = (long unsigned int) argi;
    D.23756 = D.23755 * 8;
    D.23757 = argv + D.23756;
    D.23758 = *D.23757;
    D.23759 = strcmp (D.23758, "-v");
    if (D.23759 == 0) goto <D.23752>; else goto <D.23760>;
    <D.23760>:
    D.23755 = (long unsigned int) argi;
    D.23756 = D.23755 * 8;
    D.23757 = argv + D.23756;
    D.23758 = *D.23757;
    D.23761 = strcmp (D.23758, "--verbose");
    if (D.23761 == 0) goto <D.23752>; else goto <D.23753>;
    <D.23752>:
    this->verbose_ = 1;
    goto <D.23754>;
    <D.23753>:
    print_help = 1;
    go_on = 0;
    D.23755 = (long unsigned int) argi;
    D.23756 = D.23755 * 8;
    D.23757 = argv + D.23756;
    D.23758 = *D.23757;
    D.23762 = strcmp (D.23758, "-h");
    if (D.23762 != 0) goto <D.23763>; else goto <D.23764>;
    <D.23763>:
    D.23755 = (long unsigned int) argi;
    D.23756 = D.23755 * 8;
    D.23757 = argv + D.23756;
    D.23758 = *D.23757;
    D.23765 = strcmp (D.23758, "--help");
    if (D.23765 != 0) goto <D.23766>; else goto <D.23767>;
    <D.23766>:
    this->result_ok_ = 0;
    D.23755 = (long unsigned int) argi;
    D.23756 = D.23755 * 8;
    D.23757 = argv + D.23756;
    D.23758 = *D.23757;
    D.23768 = std::operator<< <std::char_traits<char> > (&cout, "Unknown command argument: ");
    D.23769 = std::operator<< <std::char_traits<char> > (D.23768, D.23758);
    std::basic_ostream<char>::operator<< (D.23769, endl);
    goto <D.23770>;
    <D.23767>:
    <D.23770>:
    <D.23764>:
    <D.23754>:
    argi = argi + 1;
    <D.23204>:
    if (argi < argc) goto <D.23203>; else goto <D.23201>;
    <D.23201>:
  }
  if (print_help != 0) goto <D.23771>; else goto <D.23772>;
  <D.23771>:
  D.23773 = *argv;
  D.23774 = std::operator<< <std::char_traits<char> > (&cout, "Usage: ");
  D.23775 = std::operator<< <std::char_traits<char> > (D.23774, D.23773);
  D.23776 = std::operator<< <std::char_traits<char> > (D.23775, " [-h|--help] [-v|--verbose]");
  std::basic_ostream<char>::operator<< (D.23776, endl);
  goto <D.23777>;
  <D.23772>:
  <D.23777>:
  D.23778 = go_on;
  return D.23778;
}


std::basic_ostream<_CharT, _Traits>& std::endl(std::basic_ostream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os)
{
  struct basic_ostream & D.23785;
  int (*__vtbl_ptr_type) () * D.23786;
  int (*__vtbl_ptr_type) () * D.23787;
  long int D.23788;
  sizetype D.23789;
  struct basic_ios * D.23790;
  char D.23791;
  int D.23792;
  struct basic_ostream & D.23793;

  D.23786 = __os->_vptr.basic_ostream;
  D.23787 = D.23786 + 18446744073709551592;
  D.23788 = MEM[(long int *)D.23787];
  D.23789 = (sizetype) D.23788;
  D.23790 = __os + D.23789;
  D.23791 = std::basic_ios<char>::widen (D.23790, 10);
  D.23792 = (int) D.23791;
  D.23793 = std::basic_ostream<char>::put (__os, D.23792);
  D.23785 = std::flush<char, std::char_traits<char> > (D.23793);
  return D.23785;
}


std::basic_ios<_CharT, _Traits>::char_type std::basic_ios<_CharT, _Traits>::widen(char) const [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ios<_CharT, _Traits>::char_type = char] (const struct basic_ios * const this, char __c)
{
  char_type D.23798;
  int D.23799;
  const struct __ctype_type * D.23800;
  const struct ctype & D.23801;

  D.23799 = (int) __c;
  D.23800 = this->_M_ctype;
  D.23801 = std::__check_facet<std::ctype<char> > (D.23800);
  D.23798 = std::ctype<char>::widen (D.23801, D.23799);
  return D.23798;
}


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

  if (__f == 0B) goto <D.23805>; else goto <D.23806>;
  <D.23805>:
  std::__throw_bad_cast ();
  <D.23806>:
  D.23807 = __f;
  return D.23807;
}


std::ctype<char>::char_type std::ctype<char>::widen(char) const (const struct ctype * const this, char __c)
{
  char D.23809;
  char_type D.23812;
  unsigned char __c.2;
  int D.23814;
  int (*__vtbl_ptr_type) () * D.23815;
  int (*__vtbl_ptr_type) () * D.23816;
  int (*__vtbl_ptr_type) () D.23817;
  int D.23818;

  D.23809 = this->_M_widen_ok;
  if (D.23809 != 0) goto <D.23810>; else goto <D.23811>;
  <D.23810>:
  __c.2 = (unsigned char) __c;
  D.23814 = (int) __c.2;
  D.23812 = this->_M_widen[D.23814];
  return D.23812;
  <D.23811>:
  std::ctype<char>::_M_widen_init (this);
  D.23815 = this->D.15977._vptr.facet;
  D.23816 = D.23815 + 48;
  D.23817 = *D.23816;
  D.23818 = (int) __c;
  D.23812 = OBJ_TYPE_REF(D.23817;(const struct ctype)this->6) (this, D.23818);
  return D.23812;
}


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

  D.23821 = __c;
  return D.23821;
}


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

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


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.23828;
  int (*__vtbl_ptr_type) () * D.23829;
  long int D.23830;
  sizetype D.23831;
  struct basic_ios * D.23832;
  long unsigned int D.23834;
  long int D.23835;
  struct basic_ostream & D.23836;

  if (__s == 0B) goto <D.23826>; else goto <D.23827>;
  <D.23826>:
  D.23828 = __out->_vptr.basic_ostream;
  D.23829 = D.23828 + 18446744073709551592;
  D.23830 = MEM[(long int *)D.23829];
  D.23831 = (sizetype) D.23830;
  D.23832 = __out + D.23831;
  std::basic_ios<char>::setstate (D.23832, 1);
  goto <D.23833>;
  <D.23827>:
  D.23834 = std::char_traits<char>::length (__s);
  D.23835 = (long int) D.23834;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.23835);
  <D.23833>:
  D.23836 = __out;
  return D.23836;
}


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.23838;
  _Ios_Iostate D.23839;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.23846 = __a.3 | __b.4;
  D.23843 = (_Ios_Iostate) D.23846;
  return D.23843;
}


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

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


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

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


void TestUtilities::check_result(std::ostringstream&, const string&) (struct TestUtilities * const this, struct ostringstream & result_stream, const struct string & expected_result)
{
  bool D.23853;
  struct __string_type D.23210;
  struct basic_ostream & D.23856;
  int D.23858;
  int D.23859;
  bool retval.5;
  struct __string_type D.23211;
  struct basic_ostream & D.23863;
  struct basic_ostream & D.23864;
  struct basic_ostream & D.23865;
  struct basic_ostream & D.23866;
  struct basic_ostream & D.23867;
  struct __string_type D.23215;
  struct basic_ostream & D.23868;
  struct basic_ostream & D.23869;
  struct basic_ostream & D.23870;
  const struct __string_type D.23218;
  struct allocator D.23217;

  D.23853 = this->verbose_;
  if (D.23853 != 0) goto <D.23854>; else goto <D.23855>;
  <D.23854>:
  D.23210 = std::basic_ostringstream<char>::str (result_stream); [return slot optimization]
  try
    {
      D.23856 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&cout, &D.23210);
      std::basic_ostream<char>::operator<< (D.23856, endl);
    }
  finally
    {
      std::basic_string<char>::~basic_string (&D.23210);
      D.23210 = {CLOBBER};
    }
  goto <D.23857>;
  <D.23855>:
  <D.23857>:
  D.23858 = this->test_number_;
  D.23859 = D.23858 + 1;
  this->test_number_ = D.23859;
  D.23211 = std::basic_ostringstream<char>::str (result_stream); [return slot optimization]
  try
    {
      retval.5 = std::operator!=<char, std::char_traits<char>, std::allocator<char> > (expected_result, &D.23211);
    }
  finally
    {
      std::basic_string<char>::~basic_string (&D.23211);
      D.23211 = {CLOBBER};
    }
  if (retval.5 != 0) goto <D.23861>; else goto <D.23862>;
  <D.23861>:
  D.23858 = this->test_number_;
  D.23863 = std::operator<< <std::char_traits<char> > (&cerr, "   Test ");
  D.23864 = std::basic_ostream<char>::operator<< (D.23863, D.23858);
  std::basic_ostream<char>::operator<< (D.23864, endl);
  D.23865 = std::operator<< <std::char_traits<char> > (&cerr, "Expected \"");
  D.23866 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.23865, expected_result);
  D.23867 = std::operator<< <std::char_traits<char> > (D.23866, "\"");
  std::basic_ostream<char>::operator<< (D.23867, endl);
  D.23215 = std::basic_ostringstream<char>::str (result_stream); [return slot optimization]
  try
    {
      D.23868 = std::operator<< <std::char_traits<char> > (&cerr, "Got      \"");
      D.23869 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.23868, &D.23215);
      D.23870 = std::operator<< <std::char_traits<char> > (D.23869, "\"");
      std::basic_ostream<char>::operator<< (D.23870, endl);
    }
  finally
    {
      std::basic_string<char>::~basic_string (&D.23215);
      D.23215 = {CLOBBER};
    }
  this->result_ok_ = 0;
  goto <D.23871>;
  <D.23862>:
  <D.23871>:
  std::allocator<char>::allocator (&D.23217);
  try
    {
      std::basic_string<char>::basic_string (&D.23218, "", &D.23217);
      try
        {
          std::basic_ostringstream<char>::str (result_stream, &D.23218);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.23218);
          D.23218 = {CLOBBER};
        }
    }
  finally
    {
      std::allocator<char>::~allocator (&D.23217);
      D.23217 = {CLOBBER};
    }
}


bool std::operator!=(const std::basic_string<_CharT, _Traits, _Alloc>&, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string & __lhs, const struct basic_string & __rhs)
{
  bool D.23888;
  bool D.23889;

  D.23889 = std::operator==<char> (__lhs, __rhs);
  D.23888 = ~D.23889;
  return D.23888;
}


typename __gnu_cxx::__enable_if<std::__is_char<_Tp>::__value, bool>::__type std::operator==(const std::basic_string<_CharT>&, const std::basic_string<_CharT>&) [with _CharT = char; typename __gnu_cxx::__enable_if<std::__is_char<_Tp>::__value, bool>::__type = bool] (const struct basic_string & __lhs, const struct basic_string & __rhs)
{
  __type D.23892;
  bool iftmp.6;
  long unsigned int D.23896;
  long unsigned int D.23897;
  long unsigned int D.23899;
  const char * D.23900;
  const char * D.23901;
  int D.23902;

  D.23896 = std::basic_string<char>::size (__lhs);
  D.23897 = std::basic_string<char>::size (__rhs);
  if (D.23896 == D.23897) goto <D.23898>; else goto <D.23894>;
  <D.23898>:
  D.23899 = std::basic_string<char>::size (__lhs);
  D.23900 = std::basic_string<char>::data (__rhs);
  D.23901 = std::basic_string<char>::data (__lhs);
  D.23902 = std::char_traits<char>::compare (D.23901, D.23900, D.23899);
  if (D.23902 == 0) goto <D.23903>; else goto <D.23894>;
  <D.23903>:
  iftmp.6 = 1;
  goto <D.23895>;
  <D.23894>:
  iftmp.6 = 0;
  <D.23895>:
  D.23892 = iftmp.6;
  return D.23892;
}


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.23910;
  struct _Rep * D.23911;

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


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.23914;
  char * D.23915;

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


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

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


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

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


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

  D.23923 = __builtin_memcmp (__s1, __s2, __n);
  return D.23923;
}


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

  D.23926 = &this->_M_stringbuf;
  *<retval> = std::basic_stringbuf<char>::str (D.23926); [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.7;
  const struct basic_streambuf * D.23930;
  char_type * D.23931;
  bool retval.8;
  char_type * D.23935;
  char_type * D.23936;
  struct __string_type D.23301;
  struct allocator D.23300;
  char_type * D.23939;
  char_type * D.23940;
  struct __string_type D.23304;
  struct allocator D.23303;
  char_type * D.23942;
  char_type * D.23943;
  const struct __string_type * D.23945;
  struct __string_type __ret [value-expr: *<retval>];

  std::basic_string<char>::basic_string (<retval>);
  try
    {
      D.23930 = &this->D.22162;
      D.23931 = std::basic_streambuf<char>::pptr (D.23930);
      retval.7 = D.23931 != 0B;
      if (retval.7 != 0) goto <D.23932>; else goto <D.23933>;
      <D.23932>:
      D.23930 = &this->D.22162;
      D.23935 = std::basic_streambuf<char>::pptr (D.23930);
      D.23930 = &this->D.22162;
      D.23936 = std::basic_streambuf<char>::egptr (D.23930);
      retval.8 = D.23935 > D.23936;
      if (retval.8 != 0) goto <D.23937>; else goto <D.23938>;
      <D.23937>:
      std::allocator<char>::allocator (&D.23300);
      try
        {
          D.23930 = &this->D.22162;
          D.23939 = std::basic_streambuf<char>::pptr (D.23930);
          D.23930 = &this->D.22162;
          D.23940 = std::basic_streambuf<char>::pbase (D.23930);
          std::basic_string<char>::basic_string<char*> (&D.23301, D.23940, D.23939, &D.23300);
          try
            {
              std::basic_string<char>::operator= (<retval>, &D.23301);
            }
          finally
            {
              std::basic_string<char>::~basic_string (&D.23301);
              D.23301 = {CLOBBER};
            }
        }
      finally
        {
          std::allocator<char>::~allocator (&D.23300);
          D.23300 = {CLOBBER};
        }
      goto <D.23941>;
      <D.23938>:
      std::allocator<char>::allocator (&D.23303);
      try
        {
          D.23930 = &this->D.22162;
          D.23942 = std::basic_streambuf<char>::egptr (D.23930);
          D.23930 = &this->D.22162;
          D.23943 = std::basic_streambuf<char>::pbase (D.23930);
          std::basic_string<char>::basic_string<char*> (&D.23304, D.23943, D.23942, &D.23303);
          try
            {
              std::basic_string<char>::operator= (<retval>, &D.23304);
            }
          finally
            {
              std::basic_string<char>::~basic_string (&D.23304);
              D.23304 = {CLOBBER};
            }
        }
      finally
        {
          std::allocator<char>::~allocator (&D.23303);
          D.23303 = {CLOBBER};
        }
      <D.23941>:
      goto <D.23944>;
      <D.23933>:
      D.23945 = &this->_M_string;
      std::basic_string<char>::operator= (<retval>, D.23945);
      <D.23944>:
      return <retval>;
    }
  catch
    {
      std::basic_string<char>::~basic_string (<retval>);
    }
}


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.23347;
  struct _Rep & D.23959;
  char * D.23960;
  struct _Alloc_hider * D.23961;

  std::allocator<char>::allocator (&D.23347);
  try
    {
      D.23959 = std::basic_string<char>::_S_empty_rep ();
      D.23960 = std::basic_string<char>::_Rep::_M_refdata (D.23959);
      D.23961 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.23961, D.23960, &D.23347);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.23347);
      D.23347 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.23969;
  void * D.23970;

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


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

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


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

  try
    {
      {

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


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

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


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

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


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

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


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.23980;
  struct _Alloc_hider * D.23981;

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

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


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.23983;
  struct _Integral D.23399;
  struct __false_type D.23984;
  typedef struct _Integral _Integral;

  try
    {
      D.23983 = std::basic_string<char>::_S_construct_aux<char*> (__beg, __end, __a, D.23984);
      return D.23983;
    }
  finally
    {
      D.23399 = {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.23419)
{
  char * D.23989;
  struct forward_iterator_tag D.23477;
  struct _Tag D.23451;
  struct _Tag * D.23990;
  struct forward_iterator_tag D.23991;
  typedef struct _Tag _Tag;

  try
    {
      D.23990 = &D.23451;
      D.23989 = std::basic_string<char>::_S_construct<char*> (__beg, __end, __a, D.23991);
      return D.23989;
    }
  finally
    {
      D.23451 = {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.23456)
{
  bool retval.9;
  bool iftmp.10;
  struct allocator D.23482;
  bool cleanup.11;
  bool D.24004;
  char * D.24008;
  struct _Rep & D.24009;
  bool retval.12;
  bool iftmp.13;
  bool D.24014;
  long int D.24019;
  char * D.24020;
  void * D.24021;
  const size_type __dnew;
  struct _Rep * __r;

  cleanup.11 = 0;
  try
    {
      if (__beg == __end) goto <D.24000>; else goto <D.23998>;
      <D.24000>:
      std::allocator<char>::allocator (&D.23482);
      cleanup.11 = 1;
      D.24004 = std::operator==<char> (__a, &D.23482);
      if (D.24004 != 0) goto <D.24005>; else goto <D.23998>;
      <D.24005>:
      iftmp.10 = 1;
      goto <D.23999>;
      <D.23998>:
      iftmp.10 = 0;
      <D.23999>:
      retval.9 = iftmp.10;
    }
  finally
    {
      if (cleanup.11 != 0) goto <D.24002>; else goto <D.24003>;
      <D.24002>:
      std::allocator<char>::~allocator (&D.23482);
      D.23482 = {CLOBBER};
      <D.24003>:
    }
  if (retval.9 != 0) goto <D.24006>; else goto <D.24007>;
  <D.24006>:
  D.24009 = std::basic_string<char>::_S_empty_rep ();
  D.24008 = std::basic_string<char>::_Rep::_M_refdata (D.24009);
  return D.24008;
  <D.24007>:
  D.24014 = __gnu_cxx::__is_null_pointer<char> (__beg);
  if (D.24014 != 0) goto <D.24015>; else goto <D.24012>;
  <D.24015>:
  if (__beg != __end) goto <D.24016>; else goto <D.24012>;
  <D.24016>:
  iftmp.13 = 1;
  goto <D.24013>;
  <D.24012>:
  iftmp.13 = 0;
  <D.24013>:
  retval.12 = iftmp.13;
  if (retval.12 != 0) goto <D.24017>; else goto <D.24018>;
  <D.24017>:
  std::__throw_logic_error ("basic_string::_S_construct null not valid");
  <D.24018>:
  D.24019 = std::distance<char*> (__beg, __end);
  __dnew = (const size_type) D.24019;
  __r = std::basic_string<char>::_Rep::_S_create (__dnew, 0, __a);
  try
    {
      D.24020 = std::basic_string<char>::_Rep::_M_refdata (__r);
      std::basic_string<char>::_S_copy_chars (D.24020, __beg, __end);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.24021 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.24021);
              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.24008 = std::basic_string<char>::_Rep::_M_refdata (__r);
  return D.24008;
}


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

  D.24029 = 1;
  return D.24029;
}


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

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


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.24033;
  struct iterator_category D.23706;
  struct random_access_iterator_tag D.24034;
  char * __first.14;

  std::__iterator_category<char*> (&__first);
  try
    {
      __first.14 = __first;
      D.24033 = std::__distance<char*> (__first.14, __last, D.24034);
      return D.24033;
    }
  finally
    {
      D.23706 = {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.23705)
{
  struct iterator_category D.24038;

  return D.24038;
}


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.23710)
{
  difference_type D.24040;
  long int __last.15;
  long int __first.16;

  __last.15 = (long int) __last;
  __first.16 = (long int) __first;
  D.24040 = __last.15 - __first.16;
  return D.24040;
}


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.17;
  long int __k1.18;
  long int D.24046;
  long unsigned int D.24047;

  __k2.17 = (long int) __k2;
  __k1.18 = (long int) __k1;
  D.24046 = __k2.17 - __k1.18;
  D.24047 = (long unsigned int) D.24046;
  std::basic_string<char>::_M_copy (__p, __k1, D.24047);
}


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.24048>; else goto <D.24049>;
  <D.24048>:
  std::char_traits<char>::assign (__d, __s);
  goto <D.24050>;
  <D.24049>:
  std::char_traits<char>::copy (__d, __s, __n);
  <D.24050>:
}


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

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


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

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


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.19;
  struct _Rep & D.24055;
  bool D.24056;
  long int D.24057;
  long int D.24058;
  char * D.24061;
  char * D.24062;

  D.24055 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.24056 = D.24055 != this;
  D.24057 = (long int) D.24056;
  D.24058 = __builtin_expect (D.24057, 0);
  retval.19 = D.24058 != 0;
  if (retval.19 != 0) goto <D.24059>; else goto <D.24060>;
  <D.24059>:
  std::basic_string<char>::_Rep::_M_set_sharable (this);
  this->D.11865._M_length = __n;
  D.24061 = std::basic_string<char>::_Rep::_M_refdata (this);
  D.24062 = D.24061 + __n;
  std::char_traits<char>::assign (D.24062, &_S_terminal);
  goto <D.24063>;
  <D.24060>:
  <D.24063>:
}


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

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


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.24068;
  long unsigned int D.24069;
  long int D.24070;
  const char * D.24071;

  D.24069 = std::basic_string<char>::size (__str);
  D.24070 = (long int) D.24069;
  D.24071 = std::basic_string<char>::data (__str);
  D.24068 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.24071, D.24070);
  return D.24068;
}


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

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

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


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

  try
    {
      {

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


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

  D.24078 = &this->_M_stringbuf;
  std::basic_stringbuf<char>::str (D.24078, __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.24079;
  const char * D.24080;
  struct __string_type * D.24081;
  _Ios_Openmode D.24082;

  D.24079 = std::basic_string<char>::size (__s);
  D.24080 = std::basic_string<char>::data (__s);
  D.24081 = &this->_M_string;
  std::basic_string<char>::assign (D.24081, D.24080, D.24079);
  D.24082 = this->_M_mode;
  std::basic_stringbuf<char>::_M_stringbuf_init (this, D.24082);
}


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.20;
  _Ios_Openmode D.24086;
  _Ios_Openmode D.24087;
  _Ios_Openmode D.24088;
  struct __string_type * D.24091;
  const char * D.24093;
  __size_type __len;

  this->_M_mode = __mode;
  __len = 0;
  D.24086 = std::operator| (2, 1);
  D.24087 = this->_M_mode;
  D.24088 = std::operator& (D.24087, D.24086);
  retval.20 = D.24088 != 0;
  if (retval.20 != 0) goto <D.24089>; else goto <D.24090>;
  <D.24089>:
  D.24091 = &this->_M_string;
  __len = std::basic_string<char>::size (D.24091);
  goto <D.24092>;
  <D.24090>:
  <D.24092>:
  D.24091 = &this->_M_string;
  D.24093 = std::basic_string<char>::data (D.24091);
  std::basic_stringbuf<char>::_M_sync (this, D.24093, 0, __len);
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.24096;
  int __a.21;
  int __b.22;
  int D.24099;

  __a.21 = (int) __a;
  __b.22 = (int) __b;
  D.24099 = __a.21 | __b.22;
  D.24096 = (_Ios_Openmode) D.24099;
  return D.24096;
}


std::_Ios_Openmode std::operator&(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.24101;
  int __a.23;
  int __b.24;
  int D.24104;

  __a.23 = (int) __a;
  __b.24 = (int) __b;
  D.24104 = __a.23 & __b.24;
  D.24101 = (_Ios_Openmode) D.24104;
  return D.24101;
}


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.23250;
  struct _Rep * D.24106;
  struct _Alloc_hider * D.24107;

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


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

  D.24113 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.24113);
  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.25;
  struct _Rep & D.24116;
  bool D.24117;
  long int D.24118;
  long int D.24119;
  bool retval.26;
  _Atomic_word * D.24123;
  int D.24124;

  D.24116 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.24117 = D.24116 != this;
  D.24118 = (long int) D.24117;
  D.24119 = __builtin_expect (D.24118, 0);
  retval.25 = D.24119 != 0;
  if (retval.25 != 0) goto <D.24120>; else goto <D.24121>;
  <D.24120>:
  D.24123 = &this->D.11865._M_refcount;
  D.24124 = __gnu_cxx::__exchange_and_add_dispatch (D.24123, -1);
  retval.26 = D.24124 <= 0;
  if (retval.26 != 0) goto <D.24125>; else goto <D.24126>;
  <D.24125>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.24127>;
  <D.24126>:
  <D.24127>:
  goto <D.24128>;
  <D.24121>:
  <D.24128>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.27;
  int D.24131;
  _Atomic_word D.24134;

  D.24131 = __gthread_active_p ();
  retval.27 = D.24131 != 0;
  if (retval.27 != 0) goto <D.24132>; else goto <D.24133>;
  <D.24132>:
  D.24134 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.24134;
  <D.24133>:
  D.24134 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.24134;
}


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

  D.24137 = __gthrw___pthread_key_create != 0B;
  D.24136 = (int) D.24137;
  return D.24136;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.24139;
  unsigned int __val.28;
  unsigned int D.24141;

  __val.28 = (unsigned int) __val;
  D.24141 = __atomic_fetch_add_4 (__mem, __val.28, 4);
  D.24139 = (_Atomic_word) D.24141;
  return D.24139;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.24143;
  int D.24144;
  _Atomic_word D.24145;
  _Atomic_word __result;

  __result = *__mem;
  D.24143 = *__mem;
  D.24144 = D.24143 + __val;
  *__mem = D.24144;
  D.24145 = __result;
  return D.24145;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


static bool TestUtilities::get_result_and_delete_instance() ()
{
  bool iftmp.29;
  struct TestUtilities * instance_.30;
  bool D.24154;
  const bool result;

  instance_.30 = instance_;
  if (instance_.30 != 0B) goto <D.24151>; else goto <D.24152>;
  <D.24151>:
  instance_.30 = instance_;
  iftmp.29 = instance_.30->result_ok_;
  goto <D.24153>;
  <D.24152>:
  iftmp.29 = 1;
  <D.24153>:
  result = iftmp.29;
  instance_.30 = instance_;
  operator delete (instance_.30);
  instance_ = 0B;
  D.24154 = result;
  return D.24154;
}


(static initializers for testutilities.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.24156>; else goto <D.24157>;
  <D.24156>:
  if (__priority == 65535) goto <D.24158>; else goto <D.24159>;
  <D.24158>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  goto <D.24160>;
  <D.24159>:
  <D.24160>:
  goto <D.24161>;
  <D.24157>:
  <D.24161>:
}


