int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.38036;
  int D.38039;
  int iftmp.1;
  bool D.38041;
  struct exception_catch_functor D.35654;
  struct my_catch D.34811;
  struct f D.34810;
  int D.38045;
  const struct string D.35707;
  struct allocator D.35706;
  struct exception_catch_functor D.36538;
  struct my_catch D.35709;
  struct g D.35708;
  int D.38046;
  const struct string D.36541;
  struct allocator D.36540;
  struct exception_catch_functor D.37274;
  struct my_catch D.36543;
  struct g_void D.36542;
  const struct string D.37277;
  struct allocator D.37276;
  int iftmp.2;
  bool D.38048;

  {
    struct TestUtilities * util;

    util = TestUtilities::get_instance ();
    D.38036 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.38036;
    if (retval.0 != 0) goto <D.38037>; else goto <D.38038>;
    <D.38037>:
    D.38041 = TestUtilities::get_result_and_delete_instance ();
    if (D.38041 != 0) goto <D.38042>; else goto <D.38043>;
    <D.38042>:
    iftmp.1 = 0;
    goto <D.38044>;
    <D.38043>:
    iftmp.1 = 1;
    <D.38044>:
    D.38039 = iftmp.1;
    return D.38039;
    <D.38038>:
    try
      {
        try
          {
            sigc::exception_catch<{anonymous}::f, {anonymous}::my_catch> (&D.34810, &D.34811);
            try
              {
                D.38045 = sigc::exception_catch_functor<{anonymous}::f, {anonymous}::my_catch, int>::operator()<int> (&D.35654, 2);
                std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38045);
              }
            finally
              {
                D.35654 = {CLOBBER};
              }
          }
        finally
          {
            D.34810 = {CLOBBER};
          }
      }
    finally
      {
        D.34811 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.35706);
    try
      {
        std::basic_string<char>::basic_string (&D.35707, "f(int 2) caught out of range 1", &D.35706);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.35707);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.35707);
            D.35707 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.35706);
        D.35706 = {CLOBBER};
      }
    try
      {
        try
          {
            sigc::exception_catch<{anonymous}::g, {anonymous}::my_catch> (&D.35708, &D.35709);
            try
              {
                D.38046 = sigc::exception_catch_functor<{anonymous}::g, {anonymous}::my_catch, int>::operator() (&D.36538);
                std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38046);
              }
            finally
              {
                D.36538 = {CLOBBER};
              }
          }
        finally
          {
            D.35708 = {CLOBBER};
          }
      }
    finally
      {
        D.35709 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.36540);
    try
      {
        std::basic_string<char>::basic_string (&D.36541, "g() caught out of range 1", &D.36540);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.36541);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.36541);
            D.36541 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.36540);
        D.36540 = {CLOBBER};
      }
    try
      {
        try
          {
            D.37274 = sigc::exception_catch<{anonymous}::g_void, {anonymous}::my_catch> (&D.36542, &D.36543); [return slot optimization]
            try
              {
                sigc::exception_catch_functor<{anonymous}::g_void, {anonymous}::my_catch, void>::operator() (&D.37274);
              }
            finally
              {
                sigc::exception_catch_functor<{anonymous}::g_void, {anonymous}::my_catch, void>::~exception_catch_functor (&D.37274);
                D.37274 = {CLOBBER};
              }
          }
        finally
          {
            D.36542 = {CLOBBER};
          }
      }
    finally
      {
        D.36543 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.37276);
    try
      {
        std::basic_string<char>::basic_string (&D.37277, "g_void() caught out of range ", &D.37276);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.37277);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.37277);
            D.37277 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.37276);
        D.37276 = {CLOBBER};
      }
    D.38048 = TestUtilities::get_result_and_delete_instance ();
    if (D.38048 != 0) goto <D.38049>; else goto <D.38050>;
    <D.38049>:
    iftmp.2 = 0;
    goto <D.38051>;
    <D.38050>:
    iftmp.2 = 1;
    <D.38051>:
    D.38039 = iftmp.2;
    return D.38039;
  }
  D.38039 = 0;
  return D.38039;
}


sigc::exception_catch_functor<T_functor, T_catcher> sigc::exception_catch(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::f; T_catcher = {anonymous}::my_catch; typename sigc::adapts<T_functor>::result_type = int] (const struct f & _A_func, const struct my_catch & _A_catcher)
{
  struct exception_catch_functor D.38075;
  struct exception_catch_functor D.37414;

  sigc::exception_catch_functor<{anonymous}::f, {anonymous}::my_catch, int>::exception_catch_functor (&D.37414, _A_func, _A_catcher);
  try
    {
      return D.38075;
    }
  finally
    {
      D.37414 = {CLOBBER};
    }
}


sigc::exception_catch_functor<T_functor, T_catcher, T_return>::exception_catch_functor(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::f; T_catcher = {anonymous}::my_catch; T_return = int] (struct exception_catch_functor * const this, const struct f & _A_func, const struct my_catch & _A_catcher)
{
  struct adapts * D.38078;

  D.38078 = &this->D.35651;
  sigc::adapts<{anonymous}::f>::adapts (D.38078, _A_func);
}


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

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


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


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

}


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


typename sigc::exception_catch_functor<T_functor, T_catcher, T_return>::deduce_result_type<T_arg1>::type sigc::exception_catch_functor<T_functor, T_catcher, T_return>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::f; T_catcher = {anonymous}::my_catch; T_return = int; typename sigc::exception_catch_functor<T_functor, T_catcher, T_return>::deduce_result_type<T_arg1>::type = int] (struct exception_catch_functor * const this, int _A_a1)
{
  type D.38080;
  struct adaptor_type * D.38081;
  void * D.38082;
  struct my_catch * D.38083;

  try
    {
      D.38081 = &this->D.35651.functor_;
      D.38080 = sigc::adaptor_functor<{anonymous}::f>::operator()<int&> (D.38081, &_A_a1);
      return D.38080;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.38082 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.38082);
              D.38083 = &this->catcher_;
              D.38080 = {anonymous}::my_catch::operator() (D.38083);
              return D.38080;
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = int&; T_functor = {anonymous}::f; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, int & _A_arg1)
{
  type D.38091;
  int D.38092;
  struct f * D.38093;

  D.38092 = *_A_arg1;
  D.38093 = &this->functor_;
  D.38091 = {anonymous}::f::operator() (D.38093, D.38092);
  return D.38091;
}


int {anonymous}::f::operator()(int) (struct f * const this, int i)
{
  struct basic_ostream & D.38096;
  struct basic_ostream & D.38097;
  void * D.34762;
  const struct string D.34758;
  struct allocator D.34757;

  D.38096 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "f(int ");
  D.38097 = std::basic_ostream<char>::operator<< (D.38096, i);
  std::operator<< <std::char_traits<char> > (D.38097, ") ");
  D.34762 = __cxa_allocate_exception (16);
  try
    {
      std::allocator<char>::allocator (&D.34757);
      try
        {
          std::basic_string<char>::basic_string (&D.34758, "out of range ", &D.34757);
          try
            {
              std::range_error::range_error (D.34762, &D.34758);
            }
          finally
            {
              try
                {
                  std::basic_string<char>::~basic_string (&D.34758);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.34758 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.34757);
            }
          catch
            {
              <<<eh_must_not_throw (terminate)>>>
            }
          D.34757 = {CLOBBER};
        }
    }
  catch
    {
      __cxa_free_exception (D.34762);
    }
  __cxa_throw (D.34762, &_ZTISt11range_error, __comp_dtor );
}


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.38105;
  int (*__vtbl_ptr_type) () * D.38106;
  long int D.38107;
  sizetype D.38108;
  struct basic_ios * D.38109;
  long unsigned int D.38111;
  long int D.38112;
  struct basic_ostream & D.38113;

  if (__s == 0B) goto <D.38103>; else goto <D.38104>;
  <D.38103>:
  D.38105 = __out->_vptr.basic_ostream;
  D.38106 = D.38105 + 18446744073709551592;
  D.38107 = MEM[(long int *)D.38106];
  D.38108 = (sizetype) D.38107;
  D.38109 = __out + D.38108;
  std::basic_ios<char>::setstate (D.38109, 1);
  goto <D.38110>;
  <D.38104>:
  D.38111 = std::char_traits<char>::length (__s);
  D.38112 = (long int) D.38111;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.38112);
  <D.38110>:
  D.38113 = __out;
  return D.38113;
}


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.38115;
  _Ios_Iostate D.38116;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.38123 = __a.3 | __b.4;
  D.38120 = (_Ios_Iostate) D.38123;
  return D.38120;
}


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

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


int {anonymous}::my_catch::operator()() (struct my_catch * const this)
{
  void * D.38127;
  void * D.38128;
  void * D.38129;
  const char * D.38130;
  struct basic_ostream & D.38131;
  int D.38132;

  try
    {
      __cxa_rethrow ();
    }
  catch
    {
      catch (struct range_error)
        {
          {
            struct range_error e;

            try
              {
                try
                  {
                    try
                      {
                        D.38127 = __builtin_eh_pointer (0);
                        D.38128 = __cxa_get_exception_ptr (D.38127);
                        std::range_error::range_error (&e, D.38128);
                      }
                    catch
                      {
                        <<<eh_must_not_throw (terminate)>>>
                      }
                    try
                      {
                        D.38129 = __builtin_eh_pointer (0);
                        __cxa_begin_catch (D.38129);
                        D.38130 = std::runtime_error::what (&e.D.33895);
                        D.38131 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "caught ");
                        std::operator<< <std::char_traits<char> > (D.38131, D.38130);
                      }
                    finally
                      {
                        std::range_error::~range_error (&e);
                      }
                  }
                finally
                  {
                    __cxa_end_catch ();
                  }
              }
            finally
              {
                e = {CLOBBER};
              }
          }
        }
    }
  D.38132 = 1;
  return D.38132;
}


std::range_error::range_error(const std::range_error&) (struct range_error * const this, const struct range_error & D.34755)
{
  const struct runtime_error * D.38141;
  struct runtime_error * D.38142;

  D.38141 = &D.34755->D.33895;
  D.38142 = &this->D.33895;
  std::runtime_error::runtime_error (D.38142, D.38141);
  try
    {
      this->D.33895.D.33867._vptr.exception = &MEM[(void *)&_ZTVSt11range_error + 16B];
    }
  catch
    {
      D.38142 = &this->D.33895;
      std::runtime_error::~runtime_error (D.38142);
    }
}


std::runtime_error::runtime_error(const std::runtime_error&) (struct runtime_error * const this, const struct runtime_error & D.34746)
{
  const struct exception * D.38143;
  struct exception * D.38144;
  const struct string * D.38145;
  struct string * D.38146;

  D.38143 = &D.34746->D.33867;
  D.38144 = &this->D.33867;
  std::exception::exception (D.38144, D.38143);
  try
    {
      this->D.33867._vptr.exception = &MEM[(void *)&_ZTVSt13runtime_error + 16B];
      D.38145 = &D.34746->_M_msg;
      D.38146 = &this->_M_msg;
      std::basic_string<char>::basic_string (D.38146, D.38145);
      try
        {

        }
      catch
        {
          D.38146 = &this->_M_msg;
          std::basic_string<char>::~basic_string (D.38146);
        }
    }
  catch
    {
      D.38144 = &this->D.33867;
      std::exception::~exception (D.38144);
    }
}


std::exception::exception(const std::exception&) (struct exception * const this, const struct exception & D.6018)
{
  this->_vptr.exception = &MEM[(void *)&_ZTVSt9exception + 16B];
}


sigc::exception_catch_functor<T_functor, T_catcher> sigc::exception_catch(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::g; T_catcher = {anonymous}::my_catch; typename sigc::adapts<T_functor>::result_type = int] (const struct g & _A_func, const struct my_catch & _A_catcher)
{
  struct exception_catch_functor D.38148;
  struct exception_catch_functor D.37525;

  sigc::exception_catch_functor<{anonymous}::g, {anonymous}::my_catch, int>::exception_catch_functor (&D.37525, _A_func, _A_catcher);
  try
    {
      return D.38148;
    }
  finally
    {
      D.37525 = {CLOBBER};
    }
}


sigc::exception_catch_functor<T_functor, T_catcher, T_return>::exception_catch_functor(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::g; T_catcher = {anonymous}::my_catch; T_return = int] (struct exception_catch_functor * const this, const struct g & _A_func, const struct my_catch & _A_catcher)
{
  struct adapts * D.38151;

  D.38151 = &this->D.36535;
  sigc::adapts<{anonymous}::g>::adapts (D.38151, _A_func);
}


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

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


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


sigc::exception_catch_functor<T_functor, T_catcher, T_return>::result_type sigc::exception_catch_functor<T_functor, T_catcher, T_return>::operator()() [with T_functor = {anonymous}::g; T_catcher = {anonymous}::my_catch; T_return = int; sigc::exception_catch_functor<T_functor, T_catcher, T_return>::result_type = int] (struct exception_catch_functor * const this)
{
  result_type D.38153;
  struct adaptor_type * D.38154;
  void * D.38155;
  struct my_catch * D.38156;

  try
    {
      D.38154 = &this->D.36535.functor_;
      D.38153 = sigc::adaptor_functor<{anonymous}::g>::operator() (D.38154);
      return D.38153;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.38155 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.38155);
              D.38156 = &this->catcher_;
              D.38153 = {anonymous}::my_catch::operator() (D.38156);
              return D.38153;
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


sigc::adaptor_functor<T_functor>::result_type sigc::adaptor_functor<T_functor>::operator()() const [with T_functor = {anonymous}::g; sigc::adaptor_functor<T_functor>::result_type = int] (const struct adaptor_functor * const this)
{
  result_type D.38164;
  struct g * D.38165;

  D.38165 = &this->functor_;
  D.38164 = {anonymous}::g::operator() (D.38165);
  return D.38164;
}


int {anonymous}::g::operator()() (struct g * const this)
{
  void * D.34783;
  const struct string D.34781;
  struct allocator D.34780;

  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "g() ");
  D.34783 = __cxa_allocate_exception (16);
  try
    {
      std::allocator<char>::allocator (&D.34780);
      try
        {
          std::basic_string<char>::basic_string (&D.34781, "out of range ", &D.34780);
          try
            {
              std::range_error::range_error (D.34783, &D.34781);
            }
          finally
            {
              try
                {
                  std::basic_string<char>::~basic_string (&D.34781);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.34781 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.34780);
            }
          catch
            {
              <<<eh_must_not_throw (terminate)>>>
            }
          D.34780 = {CLOBBER};
        }
    }
  catch
    {
      __cxa_free_exception (D.34783);
    }
  __cxa_throw (D.34783, &_ZTISt11range_error, __comp_dtor );
}


sigc::exception_catch_functor<T_functor, T_catcher> sigc::exception_catch(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::g_void; T_catcher = {anonymous}::my_catch; typename sigc::adapts<T_functor>::result_type = void] (const struct g_void & _A_func, const struct my_catch & _A_catcher)
{
  sigc::exception_catch_functor<{anonymous}::g_void, {anonymous}::my_catch, void>::exception_catch_functor (<retval>, _A_func, _A_catcher);
  return <retval>;
}


sigc::exception_catch_functor<T_functor, T_catcher, void>::exception_catch_functor(const T_functor&, const T_catcher&) [with T_functor = {anonymous}::g_void; T_catcher = {anonymous}::my_catch] (struct exception_catch_functor * const this, const struct g_void & _A_func, const struct my_catch & _A_catcher)
{
  struct adapts * D.38173;

  D.38173 = &this->D.37271;
  sigc::adapts<{anonymous}::g_void>::adapts (D.38173, _A_func);
}


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

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


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


void sigc::exception_catch_functor<T_functor, T_catcher, void>::operator()() [with T_functor = {anonymous}::g_void; T_catcher = {anonymous}::my_catch] (struct exception_catch_functor * const this)
{
  struct adaptor_type * D.38175;
  void * D.38176;
  struct my_catch * D.38177;

  try
    {
      D.38175 = &this->D.37271.functor_;
      sigc::adaptor_functor<{anonymous}::g_void>::operator() (D.38175);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.38176 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.38176);
              D.38177 = &this->catcher_;
              {anonymous}::my_catch::operator() (D.38177);
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


sigc::adaptor_functor<T_functor>::result_type sigc::adaptor_functor<T_functor>::operator()() const [with T_functor = {anonymous}::g_void; sigc::adaptor_functor<T_functor>::result_type = void] (const struct adaptor_functor * const this)
{
  struct g_void * D.38182;

  D.38182 = &this->functor_;
  {anonymous}::g_void::operator() (D.38182);
  return;
}


void {anonymous}::g_void::operator()() (struct g_void * const this)
{
  void * D.34794;
  const struct string D.34792;
  struct allocator D.34791;

  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "g_void() ");
  D.34794 = __cxa_allocate_exception (16);
  try
    {
      std::allocator<char>::allocator (&D.34791);
      try
        {
          std::basic_string<char>::basic_string (&D.34792, "out of range ", &D.34791);
          try
            {
              std::range_error::range_error (D.34794, &D.34792);
            }
          finally
            {
              try
                {
                  std::basic_string<char>::~basic_string (&D.34792);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.34792 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.34791);
            }
          catch
            {
              <<<eh_must_not_throw (terminate)>>>
            }
          D.34791 = {CLOBBER};
        }
    }
  catch
    {
      __cxa_free_exception (D.34794);
    }
  __cxa_throw (D.34794, &_ZTISt11range_error, __comp_dtor );
}


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

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

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


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

  try
    {
      {

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


sigc::exception_catch_functor<T_functor, T_catcher, void>::~exception_catch_functor() [with T_functor = {anonymous}::g_void; T_catcher = {anonymous}::my_catch] (struct exception_catch_functor * const this)
{
  {
    try
      {

      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37542>:
}


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.37400;
  struct _Rep * D.38189;
  struct _Alloc_hider * D.38190;

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


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

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

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


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

  try
    {
      {

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


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.38200;
  char * D.38201;

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


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

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


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.38207;
  bool D.38208;
  long int D.38209;
  long int D.38210;
  bool retval.6;
  _Atomic_word * D.38214;
  int D.38215;

  D.38207 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.38208 = D.38207 != this;
  D.38209 = (long int) D.38208;
  D.38210 = __builtin_expect (D.38209, 0);
  retval.5 = D.38210 != 0;
  if (retval.5 != 0) goto <D.38211>; else goto <D.38212>;
  <D.38211>:
  D.38214 = &this->D.11865._M_refcount;
  D.38215 = __gnu_cxx::__exchange_and_add_dispatch (D.38214, -1);
  retval.6 = D.38215 <= 0;
  if (retval.6 != 0) goto <D.38216>; else goto <D.38217>;
  <D.38216>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.38218>;
  <D.38217>:
  <D.38218>:
  goto <D.38219>;
  <D.38212>:
  <D.38219>:
}


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

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


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

  D.38224 = __gthread_active_p ();
  retval.7 = D.38224 != 0;
  if (retval.7 != 0) goto <D.38225>; else goto <D.38226>;
  <D.38225>:
  D.38227 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.38227;
  <D.38226>:
  D.38227 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.38227;
}


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

  D.38230 = __gthrw___pthread_key_create != 0B;
  D.38229 = (int) D.38230;
  return D.38229;
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.38236;
  int D.38237;
  _Atomic_word D.38238;
  _Atomic_word __result;

  __result = *__mem;
  D.38236 = *__mem;
  D.38237 = D.38236 + __val;
  *__mem = D.38237;
  D.38238 = __result;
  return D.38238;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_exception_catch.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.38242>; else goto <D.38243>;
  <D.38242>:
  if (__priority == 65535) goto <D.38244>; else goto <D.38245>;
  <D.38244>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.38246>;
  <D.38245>:
  <D.38246>:
  goto <D.38247>;
  <D.38243>:
  <D.38247>:
}


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.38251;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.38256;
  int (*__vtbl_ptr_type) () * D.38257;
  long int D.38258;
  struct basic_ios * D.38260;
  int (*__vtbl_ptr_type) () * iftmp.11;
  struct __stringbuf_type * D.38265;
  const void * * iftmp.12;
  struct basic_ostream * D.38270;
  int D.38271;
  struct basic_ios * D.38274;
  int D.38276;

  {
    if (2 == 0) goto <D.38249>; else goto <D.38250>;
    <D.38249>:
    D.38251 = 0B;
    iftmp.9 = *D.38251;
    goto <D.38252>;
    <D.38250>:
    iftmp.9 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.38252>:
    this->D.22312._vptr.basic_ostream = iftmp.9;
    if (2 == 0) goto <D.38254>; else goto <D.38255>;
    <D.38254>:
    D.38256 = this->D.22312._vptr.basic_ostream;
    D.38257 = D.38256 + 18446744073709551592;
    D.38258 = MEM[(long int *)D.38257];
    iftmp.10 = (sizetype) D.38258;
    goto <D.38259>;
    <D.38255>:
    iftmp.10 = 88;
    <D.38259>:
    D.38260 = this + iftmp.10;
    if (2 == 0) goto <D.38262>; else goto <D.38263>;
    <D.38262>:
    iftmp.11 = MEM[(const void * *)0B + 24B];
    goto <D.38264>;
    <D.38263>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.38264>:
    D.38260->D.19008._vptr.ios_base = iftmp.11;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.38265 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.38265);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.38267>; else goto <D.38268>;
                <D.38267>:
                iftmp.12 = 8B;
                goto <D.38269>;
                <D.38268>:
                iftmp.12 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.38269>:
                D.38270 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.38270, iftmp.12);
              }
          }
        finally
          {
            D.38271 = 2;
            if (D.38271 != 0) goto <D.38272>; else goto <D.38273>;
            <D.38272>:
            D.38274 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.38274);
            goto <D.38275>;
            <D.38273>:
            <D.38275>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37992>:
  D.38276 = 0;
  if (D.38276 != 0) goto <D.38277>; else goto <D.38278>;
  <D.38277>:
  operator delete (this);
  goto <D.38279>;
  <D.38278>:
  <D.38279>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.38289;
  struct basic_streambuf * D.38290;
  int D.38291;

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

              }
            finally
              {
                D.38289 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.38289);
              }
          }
        finally
          {
            D.38290 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.38290);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37361>:
  D.38291 = 0;
  if (D.38291 != 0) goto <D.38292>; else goto <D.38293>;
  <D.38292>:
  operator delete (this);
  goto <D.38294>;
  <D.38293>:
  <D.38294>:
}


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

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

          }
        finally
          {
            D.38297 = &this->_M_buf_locale;
            std::locale::~locale (D.38297);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37607>:
  D.38298 = 0;
  if (D.38298 != 0) goto <D.38299>; else goto <D.38300>;
  <D.38299>:
  operator delete (this);
  goto <D.38301>;
  <D.38300>:
  <D.38301>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.37365>:
  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.38309;
  int (*__vtbl_ptr_type) () * D.38310;
  long int D.38311;
  struct basic_ios * D.38313;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int D.38318;
  struct basic_ios * D.38321;
  int D.38323;

  {
    if (0 == 0) goto <D.38303>; else goto <D.38304>;
    <D.38303>:
    iftmp.13 = *__vtt_parm;
    goto <D.38305>;
    <D.38304>:
    iftmp.13 = &MEM[(void *)&_ZTVSo + 24B];
    <D.38305>:
    this->_vptr.basic_ostream = iftmp.13;
    if (0 == 0) goto <D.38307>; else goto <D.38308>;
    <D.38307>:
    D.38309 = this->_vptr.basic_ostream;
    D.38310 = D.38309 + 18446744073709551592;
    D.38311 = MEM[(long int *)D.38310];
    iftmp.14 = (sizetype) D.38311;
    goto <D.38312>;
    <D.38308>:
    iftmp.14 = 8;
    <D.38312>:
    D.38313 = this + iftmp.14;
    if (0 == 0) goto <D.38315>; else goto <D.38316>;
    <D.38315>:
    iftmp.15 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.38317>;
    <D.38316>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 64B];
    <D.38317>:
    D.38313->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {

          }
        finally
          {
            D.38318 = 0;
            if (D.38318 != 0) goto <D.38319>; else goto <D.38320>;
            <D.38319>:
            D.38321 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.38321);
            goto <D.38322>;
            <D.38320>:
            <D.38322>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37592>:
  D.38323 = 0;
  if (D.38323 != 0) goto <D.38324>; else goto <D.38325>;
  <D.38324>:
  operator delete (this);
  goto <D.38326>;
  <D.38325>:
  <D.38326>:
}


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

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

          }
        finally
          {
            D.38328 = &this->D.19008;
            std::ios_base::~ios_base (D.38328);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37580>:
  D.38329 = 0;
  if (D.38329 != 0) goto <D.38330>; else goto <D.38331>;
  <D.38330>:
  operator delete (this);
  goto <D.38332>;
  <D.38331>:
  <D.38332>:
}


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.37584>:
  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.38336;
  const void * * iftmp.16;
  struct basic_ostream * D.38342;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.38346;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.38351;
  int (*__vtbl_ptr_type) () * D.38352;
  long int D.38353;
  struct basic_ios * D.38355;
  int (*__vtbl_ptr_type) () * iftmp.19;
  _Ios_Openmode D.38360;
  struct __stringbuf_type * D.38361;
  struct basic_streambuf * D.38362;
  sizetype iftmp.20;
  struct basic_ios * D.38367;
  const void * * iftmp.21;

  if (1 != 0) goto <D.38334>; else goto <D.38335>;
  <D.38334>:
  D.38336 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.38336);
  goto <D.38337>;
  <D.38335>:
  <D.38337>:
  try
    {
      if (1 == 0) goto <D.38339>; else goto <D.38340>;
      <D.38339>:
      iftmp.16 = 8B;
      goto <D.38341>;
      <D.38340>:
      iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.38341>:
      D.38342 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.38342, iftmp.16);
      try
        {
          if (1 == 0) goto <D.38344>; else goto <D.38345>;
          <D.38344>:
          D.38346 = 0B;
          iftmp.17 = *D.38346;
          goto <D.38347>;
          <D.38345>:
          iftmp.17 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.38347>:
          this->D.22312._vptr.basic_ostream = iftmp.17;
          if (1 == 0) goto <D.38349>; else goto <D.38350>;
          <D.38349>:
          D.38351 = this->D.22312._vptr.basic_ostream;
          D.38352 = D.38351 + 18446744073709551592;
          D.38353 = MEM[(long int *)D.38352];
          iftmp.18 = (sizetype) D.38353;
          goto <D.38354>;
          <D.38350>:
          iftmp.18 = 88;
          <D.38354>:
          D.38355 = this + iftmp.18;
          if (1 == 0) goto <D.38357>; else goto <D.38358>;
          <D.38357>:
          iftmp.19 = MEM[(const void * *)0B + 24B];
          goto <D.38359>;
          <D.38358>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.38359>:
          D.38355->D.19008._vptr.ios_base = iftmp.19;
          D.38360 = std::operator| (__mode, 16);
          D.38361 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.38361, D.38360);
          try
            {
              D.38362 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.38364>; else goto <D.38365>;
              <D.38364>:
              D.38351 = this->D.22312._vptr.basic_ostream;
              D.38352 = D.38351 + 18446744073709551592;
              D.38353 = MEM[(long int *)D.38352];
              iftmp.20 = (sizetype) D.38353;
              goto <D.38366>;
              <D.38365>:
              iftmp.20 = 88;
              <D.38366>:
              D.38367 = this + iftmp.20;
              std::basic_ios<char>::init (D.38367, D.38362);
            }
          catch
            {
              D.38361 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.38361);
            }
        }
      catch
        {
          if (1 == 0) goto <D.38369>; else goto <D.38370>;
          <D.38369>:
          iftmp.21 = 8B;
          goto <D.38371>;
          <D.38370>:
          iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.38371>:
          D.38342 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.38342, iftmp.21);
        }
    }
  catch
    {
      if (1 != 0) goto <D.38372>; else goto <D.38373>;
      <D.38372>:
      D.38336 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.38336);
      goto <D.38374>;
      <D.38373>:
      <D.38374>:
    }
}


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

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


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.38381;
  int (*__vtbl_ptr_type) () * iftmp.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.38390;
  int (*__vtbl_ptr_type) () * D.38391;
  long int D.38392;
  struct basic_ios * D.38394;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  struct basic_ios * D.38403;

  if (0 != 0) goto <D.38379>; else goto <D.38380>;
  <D.38379>:
  D.38381 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.38381);
  goto <D.38382>;
  <D.38380>:
  <D.38382>:
  try
    {
      if (0 == 0) goto <D.38384>; else goto <D.38385>;
      <D.38384>:
      iftmp.22 = *__vtt_parm;
      goto <D.38386>;
      <D.38385>:
      iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
      <D.38386>:
      this->_vptr.basic_ostream = iftmp.22;
      if (0 == 0) goto <D.38388>; else goto <D.38389>;
      <D.38388>:
      D.38390 = this->_vptr.basic_ostream;
      D.38391 = D.38390 + 18446744073709551592;
      D.38392 = MEM[(long int *)D.38391];
      iftmp.23 = (sizetype) D.38392;
      goto <D.38393>;
      <D.38389>:
      iftmp.23 = 8;
      <D.38393>:
      D.38394 = this + iftmp.23;
      if (0 == 0) goto <D.38396>; else goto <D.38397>;
      <D.38396>:
      iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.38398>;
      <D.38397>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
      <D.38398>:
      D.38394->D.19008._vptr.ios_base = iftmp.24;
      if (0 == 0) goto <D.38400>; else goto <D.38401>;
      <D.38400>:
      D.38390 = this->_vptr.basic_ostream;
      D.38391 = D.38390 + 18446744073709551592;
      D.38392 = MEM[(long int *)D.38391];
      iftmp.25 = (sizetype) D.38392;
      goto <D.38402>;
      <D.38401>:
      iftmp.25 = 8;
      <D.38402>:
      D.38403 = this + iftmp.25;
      std::basic_ios<char>::init (D.38403, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.38404>; else goto <D.38405>;
      <D.38404>:
      D.38381 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.38381);
      goto <D.38406>;
      <D.38405>:
      <D.38406>:
    }
}


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

  __a.26 = (int) __a;
  __b.27 = (int) __b;
  D.38411 = __a.26 | __b.27;
  D.38408 = (_Ios_Openmode) D.38411;
  return D.38408;
}


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.38413;
  struct __string_type * D.38414;

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

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


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

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

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


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.37757;
  struct _Rep & D.38417;
  char * D.38418;
  struct _Alloc_hider * D.38419;

  std::allocator<char>::allocator (&D.37757);
  try
    {
      D.38417 = std::basic_string<char>::_S_empty_rep ();
      D.38418 = std::basic_string<char>::_Rep::_M_refdata (D.38417);
      D.38419 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.38419, D.38418, &D.37757);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.37757);
      D.37757 = {CLOBBER};
    }
  try
    {

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


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

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


_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.38425;
  void * D.38426;

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


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


