int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.38318;
  int D.38321;
  int iftmp.1;
  bool D.38323;
  struct hide_functor D.35855;
  struct foo D.35019;
  int D.38327;
  const struct string D.35909;
  struct allocator D.35908;
  struct hide_functor D.36254;
  struct foo D.35910;
  int D.38328;
  const struct string D.36279;
  struct allocator D.36278;
  struct hide_functor D.36650;
  struct foo D.36280;
  int D.38329;
  const struct string D.36674;
  struct allocator D.36673;
  struct hide_functor D.36678;
  struct foo D.36675;
  int D.38330;
  const struct string D.36681;
  struct allocator D.36680;
  struct hide_functor D.37503;
  struct foo_void D.36682;
  const struct string D.37549;
  struct allocator D.37548;
  int iftmp.2;
  bool D.38332;

  {
    struct TestUtilities * util;

    util = TestUtilities::get_instance ();
    D.38318 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.38318;
    if (retval.0 != 0) goto <D.38319>; else goto <D.38320>;
    <D.38319>:
    D.38323 = TestUtilities::get_result_and_delete_instance ();
    if (D.38323 != 0) goto <D.38324>; else goto <D.38325>;
    <D.38324>:
    iftmp.1 = 0;
    goto <D.38326>;
    <D.38325>:
    iftmp.1 = 1;
    <D.38326>:
    D.38321 = iftmp.1;
    return D.38321;
    <D.38320>:
    try
      {
        sigc::hide<0, {anonymous}::foo> (&D.35019);
        try
          {
            D.38327 = sigc::hide_functor<0, {anonymous}::foo>::operator()<int, int> (&D.35855, 1, 2);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38327);
          }
        finally
          {
            D.35855 = {CLOBBER};
          }
      }
    finally
      {
        D.35019 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.35908);
    try
      {
        std::basic_string<char>::basic_string (&D.35909, "foo(int 2) 3", &D.35908);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.35909);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.35909);
            D.35909 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.35908);
        D.35908 = {CLOBBER};
      }
    try
      {
        sigc::hide<1, {anonymous}::foo> (&D.35910);
        try
          {
            D.38328 = sigc::hide_functor<1, {anonymous}::foo>::operator()<int, int> (&D.36254, 1, 2);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38328);
          }
        finally
          {
            D.36254 = {CLOBBER};
          }
      }
    finally
      {
        D.35910 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.36278);
    try
      {
        std::basic_string<char>::basic_string (&D.36279, "foo(int 1) 2", &D.36278);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.36279);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.36279);
            D.36279 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.36278);
        D.36278 = {CLOBBER};
      }
    try
      {
        sigc::hide<-1, {anonymous}::foo> (&D.36280);
        try
          {
            D.38329 = sigc::hide_functor<-1, {anonymous}::foo>::operator()<int> (&D.36650, 1);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38329);
          }
        finally
          {
            D.36650 = {CLOBBER};
          }
      }
    finally
      {
        D.36280 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.36673);
    try
      {
        std::basic_string<char>::basic_string (&D.36674, "foo() 1", &D.36673);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.36674);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.36674);
            D.36674 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.36673);
        D.36673 = {CLOBBER};
      }
    try
      {
        sigc::hide<{anonymous}::foo> (&D.36675);
        try
          {
            D.38330 = sigc::hide_functor<-1, {anonymous}::foo>::operator()<int> (&D.36678, 1);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.38330);
          }
        finally
          {
            D.36678 = {CLOBBER};
          }
      }
    finally
      {
        D.36675 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.36680);
    try
      {
        std::basic_string<char>::basic_string (&D.36681, "foo() 1", &D.36680);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.36681);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.36681);
            D.36681 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.36680);
        D.36680 = {CLOBBER};
      }
    try
      {
        sigc::hide<{anonymous}::foo_void> (&D.36682);
        try
          {
            sigc::hide_functor<-1, {anonymous}::foo_void>::operator()<int> (&D.37503, 1);
          }
        finally
          {
            D.37503 = {CLOBBER};
          }
      }
    finally
      {
        D.36682 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.37548);
    try
      {
        std::basic_string<char>::basic_string (&D.37549, "foo_void()", &D.37548);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.37549);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.37549);
            D.37549 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.37548);
        D.37548 = {CLOBBER};
      }
    D.38332 = TestUtilities::get_result_and_delete_instance ();
    if (D.38332 != 0) goto <D.38333>; else goto <D.38334>;
    <D.38333>:
    iftmp.2 = 0;
    goto <D.38335>;
    <D.38334>:
    iftmp.2 = 1;
    <D.38335>:
    D.38321 = iftmp.2;
    return D.38321;
  }
  D.38321 = 0;
  return D.38321;
}


sigc::hide_functor<I_location, T_functor> sigc::hide(const T_functor&) [with int I_location = 0; T_functor = {anonymous}::foo] (const struct foo & _A_func)
{
  struct hide_functor D.38366;
  struct hide_functor D.37651;

  sigc::hide_functor<0, {anonymous}::foo>::hide_functor (&D.37651, _A_func);
  try
    {
      return D.38366;
    }
  finally
    {
      D.37651 = {CLOBBER};
    }
}


sigc::hide_functor<0, T_functor>::hide_functor(const T_functor&) [with T_functor = {anonymous}::foo] (struct hide_functor * const this, const struct foo & _A_func)
{
  struct adapts * D.38369;

  D.38369 = &this->D.35853;
  sigc::adapts<{anonymous}::foo>::adapts (D.38369, _A_func);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.38370 = &this->functor_;
  sigc::adaptor_functor<{anonymous}::foo>::adaptor_functor (D.38370, _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}::foo] (struct adaptor_functor * const this, const struct foo & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
}


typename sigc::hide_functor<0, T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::hide_functor<0, T_functor>::operator()(T_arg1, T_arg2) [with T_arg1 = int; T_arg2 = int; T_functor = {anonymous}::foo; typename sigc::hide_functor<0, T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (struct hide_functor * const this, int D.35905, int _A_a2)
{
  type D.38371;
  struct adaptor_type * D.38372;

  D.38372 = &this->D.35853.functor_;
  D.38371 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&> (D.38372, &_A_a2);
  return D.38371;
}


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}::foo; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, int & _A_arg1)
{
  type D.38375;
  int D.38376;
  struct foo * D.38377;

  D.38376 = *_A_arg1;
  D.38377 = &this->functor_;
  D.38375 = {anonymous}::foo::operator() (D.38377, D.38376);
  return D.38375;
}


int {anonymous}::foo::operator()(int) (struct foo * const this, int j)
{
  struct basic_ostream & D.38380;
  struct basic_ostream & D.38381;
  int D.38382;

  D.38380 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.38381 = std::basic_ostream<char>::operator<< (D.38380, j);
  std::operator<< <std::char_traits<char> > (D.38381, ") ");
  D.38382 = j + 1;
  return D.38382;
}


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.38388;
  int (*__vtbl_ptr_type) () * D.38389;
  long int D.38390;
  sizetype D.38391;
  struct basic_ios * D.38392;
  long unsigned int D.38394;
  long int D.38395;
  struct basic_ostream & D.38396;

  if (__s == 0B) goto <D.38386>; else goto <D.38387>;
  <D.38386>:
  D.38388 = __out->_vptr.basic_ostream;
  D.38389 = D.38388 + 18446744073709551592;
  D.38390 = MEM[(long int *)D.38389];
  D.38391 = (sizetype) D.38390;
  D.38392 = __out + D.38391;
  std::basic_ios<char>::setstate (D.38392, 1);
  goto <D.38393>;
  <D.38387>:
  D.38394 = std::char_traits<char>::length (__s);
  D.38395 = (long int) D.38394;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.38395);
  <D.38393>:
  D.38396 = __out;
  return D.38396;
}


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.38398;
  _Ios_Iostate D.38399;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.38406 = __a.3 | __b.4;
  D.38403 = (_Ios_Iostate) D.38406;
  return D.38403;
}


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

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


sigc::hide_functor<I_location, T_functor> sigc::hide(const T_functor&) [with int I_location = 1; T_functor = {anonymous}::foo] (const struct foo & _A_func)
{
  struct hide_functor D.38410;
  struct hide_functor D.37797;

  sigc::hide_functor<1, {anonymous}::foo>::hide_functor (&D.37797, _A_func);
  try
    {
      return D.38410;
    }
  finally
    {
      D.37797 = {CLOBBER};
    }
}


sigc::hide_functor<1, T_functor>::hide_functor(const T_functor&) [with T_functor = {anonymous}::foo] (struct hide_functor * const this, const struct foo & _A_func)
{
  struct adapts * D.38413;

  D.38413 = &this->D.36252;
  sigc::adapts<{anonymous}::foo>::adapts (D.38413, _A_func);
}


typename sigc::hide_functor<1, T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::hide_functor<1, T_functor>::operator()(T_arg1, T_arg2) [with T_arg1 = int; T_arg2 = int; T_functor = {anonymous}::foo; typename sigc::hide_functor<1, T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (struct hide_functor * const this, int _A_a1, int D.36276)
{
  type D.38414;
  struct adaptor_type * D.38415;

  D.38415 = &this->D.36252.functor_;
  D.38414 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&> (D.38415, &_A_a1);
  return D.38414;
}


sigc::hide_functor<I_location, T_functor> sigc::hide(const T_functor&) [with int I_location = -1; T_functor = {anonymous}::foo] (const struct foo & _A_func)
{
  struct hide_functor D.38418;
  struct hide_functor D.37809;

  sigc::hide_functor<-1, {anonymous}::foo>::hide_functor (&D.37809, _A_func);
  try
    {
      return D.38418;
    }
  finally
    {
      D.37809 = {CLOBBER};
    }
}


sigc::hide_functor<-1, T_functor>::hide_functor(const T_functor&) [with T_functor = {anonymous}::foo] (struct hide_functor * const this, const struct foo & _A_func)
{
  struct adapts * D.38421;

  D.38421 = &this->D.36648;
  sigc::adapts<{anonymous}::foo>::adapts (D.38421, _A_func);
}


sigc::hide_functor<-1, T_functor> sigc::hide(const T_functor&) [with T_functor = {anonymous}::foo] (const struct foo & _A_func)
{
  struct hide_functor D.38422;
  struct hide_functor D.37812;

  sigc::hide_functor<-1, {anonymous}::foo>::hide_functor (&D.37812, _A_func);
  try
    {
      return D.38422;
    }
  finally
    {
      D.37812 = {CLOBBER};
    }
}


typename sigc::hide_functor<-1, T_functor>::deduce_result_type<T_arg1>::type sigc::hide_functor<-1, T_functor>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo; typename sigc::hide_functor<-1, T_functor>::deduce_result_type<T_arg1>::type = int] (struct hide_functor * const this, int D.36671)
{
  type D.38425;
  struct adaptor_type * D.38426;

  D.38426 = &this->D.36648.functor_;
  D.38425 = sigc::adaptor_functor<{anonymous}::foo>::operator() (D.38426);
  return D.38425;
}


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

  D.38430 = &this->functor_;
  D.38429 = {anonymous}::foo::operator() (D.38430);
  return D.38429;
}


int {anonymous}::foo::operator()() (struct foo * const this)
{
  int D.38433;

  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo() ");
  D.38433 = 1;
  return D.38433;
}


sigc::hide_functor<-1, T_functor> sigc::hide(const T_functor&) [with T_functor = {anonymous}::foo_void] (const struct foo_void & _A_func)
{
  struct hide_functor D.38435;
  struct hide_functor D.37823;

  sigc::hide_functor<-1, {anonymous}::foo_void>::hide_functor (&D.37823, _A_func);
  try
    {
      return D.38435;
    }
  finally
    {
      D.37823 = {CLOBBER};
    }
}


sigc::hide_functor<-1, T_functor>::hide_functor(const T_functor&) [with T_functor = {anonymous}::foo_void] (struct hide_functor * const this, const struct foo_void & _A_func)
{
  struct adapts * D.38438;

  D.38438 = &this->D.37501;
  sigc::adapts<{anonymous}::foo_void>::adapts (D.38438, _A_func);
}


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

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


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


typename sigc::hide_functor<-1, T_functor>::deduce_result_type<T_arg1>::type sigc::hide_functor<-1, T_functor>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo_void; typename sigc::hide_functor<-1, T_functor>::deduce_result_type<T_arg1>::type = void] (struct hide_functor * const this, int D.37546)
{
  struct adaptor_type * D.38440;

  D.38440 = &this->D.37501.functor_;
  sigc::adaptor_functor<{anonymous}::foo_void>::operator() (D.38440);
  return;
}


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

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


void {anonymous}::foo_void::operator()() (struct foo_void * const this)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo_void()");
}


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

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

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


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

  try
    {
      {

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


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.37783;
  struct _Rep * D.38446;
  struct _Alloc_hider * D.38447;

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


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

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

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


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

  try
    {
      {

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


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.38457;
  char * D.38458;

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


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

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


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.38464;
  bool D.38465;
  long int D.38466;
  long int D.38467;
  bool retval.6;
  _Atomic_word * D.38471;
  int D.38472;

  D.38464 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.38465 = D.38464 != this;
  D.38466 = (long int) D.38465;
  D.38467 = __builtin_expect (D.38466, 0);
  retval.5 = D.38467 != 0;
  if (retval.5 != 0) goto <D.38468>; else goto <D.38469>;
  <D.38468>:
  D.38471 = &this->D.11865._M_refcount;
  D.38472 = __gnu_cxx::__exchange_and_add_dispatch (D.38471, -1);
  retval.6 = D.38472 <= 0;
  if (retval.6 != 0) goto <D.38473>; else goto <D.38474>;
  <D.38473>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.38475>;
  <D.38474>:
  <D.38475>:
  goto <D.38476>;
  <D.38469>:
  <D.38476>:
}


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

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


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

  D.38481 = __gthread_active_p ();
  retval.7 = D.38481 != 0;
  if (retval.7 != 0) goto <D.38482>; else goto <D.38483>;
  <D.38482>:
  D.38484 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.38484;
  <D.38483>:
  D.38484 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.38484;
}


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

  D.38487 = __gthrw___pthread_key_create != 0B;
  D.38486 = (int) D.38487;
  return D.38486;
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.38493;
  int D.38494;
  _Atomic_word D.38495;
  _Atomic_word __result;

  __result = *__mem;
  D.38493 = *__mem;
  D.38494 = D.38493 + __val;
  *__mem = D.38494;
  D.38495 = __result;
  return D.38495;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_hide.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.38499>; else goto <D.38500>;
  <D.38499>:
  if (__priority == 65535) goto <D.38501>; else goto <D.38502>;
  <D.38501>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.38503>;
  <D.38502>:
  <D.38503>:
  goto <D.38504>;
  <D.38500>:
  <D.38504>:
}


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.38508;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.38513;
  int (*__vtbl_ptr_type) () * D.38514;
  long int D.38515;
  struct basic_ios * D.38517;
  int (*__vtbl_ptr_type) () * iftmp.11;
  struct __stringbuf_type * D.38522;
  const void * * iftmp.12;
  struct basic_ostream * D.38527;
  int D.38528;
  struct basic_ios * D.38531;
  int D.38533;

  {
    if (2 == 0) goto <D.38506>; else goto <D.38507>;
    <D.38506>:
    D.38508 = 0B;
    iftmp.9 = *D.38508;
    goto <D.38509>;
    <D.38507>:
    iftmp.9 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.38509>:
    this->D.22312._vptr.basic_ostream = iftmp.9;
    if (2 == 0) goto <D.38511>; else goto <D.38512>;
    <D.38511>:
    D.38513 = this->D.22312._vptr.basic_ostream;
    D.38514 = D.38513 + 18446744073709551592;
    D.38515 = MEM[(long int *)D.38514];
    iftmp.10 = (sizetype) D.38515;
    goto <D.38516>;
    <D.38512>:
    iftmp.10 = 88;
    <D.38516>:
    D.38517 = this + iftmp.10;
    if (2 == 0) goto <D.38519>; else goto <D.38520>;
    <D.38519>:
    iftmp.11 = MEM[(const void * *)0B + 24B];
    goto <D.38521>;
    <D.38520>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.38521>:
    D.38517->D.19008._vptr.ios_base = iftmp.11;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.38522 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.38522);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.38524>; else goto <D.38525>;
                <D.38524>:
                iftmp.12 = 8B;
                goto <D.38526>;
                <D.38525>:
                iftmp.12 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.38526>:
                D.38527 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.38527, iftmp.12);
              }
          }
        finally
          {
            D.38528 = 2;
            if (D.38528 != 0) goto <D.38529>; else goto <D.38530>;
            <D.38529>:
            D.38531 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.38531);
            goto <D.38532>;
            <D.38530>:
            <D.38532>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38211>:
  D.38533 = 0;
  if (D.38533 != 0) goto <D.38534>; else goto <D.38535>;
  <D.38534>:
  operator delete (this);
  goto <D.38536>;
  <D.38535>:
  <D.38536>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.38546;
  struct basic_streambuf * D.38547;
  int D.38548;

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

              }
            finally
              {
                D.38546 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.38546);
              }
          }
        finally
          {
            D.38547 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.38547);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37633>:
  D.38548 = 0;
  if (D.38548 != 0) goto <D.38549>; else goto <D.38550>;
  <D.38549>:
  operator delete (this);
  goto <D.38551>;
  <D.38550>:
  <D.38551>:
}


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

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

          }
        finally
          {
            D.38554 = &this->_M_buf_locale;
            std::locale::~locale (D.38554);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37886>:
  D.38555 = 0;
  if (D.38555 != 0) goto <D.38556>; else goto <D.38557>;
  <D.38556>:
  operator delete (this);
  goto <D.38558>;
  <D.38557>:
  <D.38558>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.37637>:
  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.38566;
  int (*__vtbl_ptr_type) () * D.38567;
  long int D.38568;
  struct basic_ios * D.38570;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int D.38575;
  struct basic_ios * D.38578;
  int D.38580;

  {
    if (0 == 0) goto <D.38560>; else goto <D.38561>;
    <D.38560>:
    iftmp.13 = *__vtt_parm;
    goto <D.38562>;
    <D.38561>:
    iftmp.13 = &MEM[(void *)&_ZTVSo + 24B];
    <D.38562>:
    this->_vptr.basic_ostream = iftmp.13;
    if (0 == 0) goto <D.38564>; else goto <D.38565>;
    <D.38564>:
    D.38566 = this->_vptr.basic_ostream;
    D.38567 = D.38566 + 18446744073709551592;
    D.38568 = MEM[(long int *)D.38567];
    iftmp.14 = (sizetype) D.38568;
    goto <D.38569>;
    <D.38565>:
    iftmp.14 = 8;
    <D.38569>:
    D.38570 = this + iftmp.14;
    if (0 == 0) goto <D.38572>; else goto <D.38573>;
    <D.38572>:
    iftmp.15 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.38574>;
    <D.38573>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 64B];
    <D.38574>:
    D.38570->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {

          }
        finally
          {
            D.38575 = 0;
            if (D.38575 != 0) goto <D.38576>; else goto <D.38577>;
            <D.38576>:
            D.38578 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.38578);
            goto <D.38579>;
            <D.38577>:
            <D.38579>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37871>:
  D.38580 = 0;
  if (D.38580 != 0) goto <D.38581>; else goto <D.38582>;
  <D.38581>:
  operator delete (this);
  goto <D.38583>;
  <D.38582>:
  <D.38583>:
}


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

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

          }
        finally
          {
            D.38585 = &this->D.19008;
            std::ios_base::~ios_base (D.38585);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.37859>:
  D.38586 = 0;
  if (D.38586 != 0) goto <D.38587>; else goto <D.38588>;
  <D.38587>:
  operator delete (this);
  goto <D.38589>;
  <D.38588>:
  <D.38589>:
}


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.37863>:
  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.38593;
  const void * * iftmp.16;
  struct basic_ostream * D.38599;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.38603;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.38608;
  int (*__vtbl_ptr_type) () * D.38609;
  long int D.38610;
  struct basic_ios * D.38612;
  int (*__vtbl_ptr_type) () * iftmp.19;
  _Ios_Openmode D.38617;
  struct __stringbuf_type * D.38618;
  struct basic_streambuf * D.38619;
  sizetype iftmp.20;
  struct basic_ios * D.38624;
  const void * * iftmp.21;

  if (1 != 0) goto <D.38591>; else goto <D.38592>;
  <D.38591>:
  D.38593 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.38593);
  goto <D.38594>;
  <D.38592>:
  <D.38594>:
  try
    {
      if (1 == 0) goto <D.38596>; else goto <D.38597>;
      <D.38596>:
      iftmp.16 = 8B;
      goto <D.38598>;
      <D.38597>:
      iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.38598>:
      D.38599 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.38599, iftmp.16);
      try
        {
          if (1 == 0) goto <D.38601>; else goto <D.38602>;
          <D.38601>:
          D.38603 = 0B;
          iftmp.17 = *D.38603;
          goto <D.38604>;
          <D.38602>:
          iftmp.17 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.38604>:
          this->D.22312._vptr.basic_ostream = iftmp.17;
          if (1 == 0) goto <D.38606>; else goto <D.38607>;
          <D.38606>:
          D.38608 = this->D.22312._vptr.basic_ostream;
          D.38609 = D.38608 + 18446744073709551592;
          D.38610 = MEM[(long int *)D.38609];
          iftmp.18 = (sizetype) D.38610;
          goto <D.38611>;
          <D.38607>:
          iftmp.18 = 88;
          <D.38611>:
          D.38612 = this + iftmp.18;
          if (1 == 0) goto <D.38614>; else goto <D.38615>;
          <D.38614>:
          iftmp.19 = MEM[(const void * *)0B + 24B];
          goto <D.38616>;
          <D.38615>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.38616>:
          D.38612->D.19008._vptr.ios_base = iftmp.19;
          D.38617 = std::operator| (__mode, 16);
          D.38618 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.38618, D.38617);
          try
            {
              D.38619 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.38621>; else goto <D.38622>;
              <D.38621>:
              D.38608 = this->D.22312._vptr.basic_ostream;
              D.38609 = D.38608 + 18446744073709551592;
              D.38610 = MEM[(long int *)D.38609];
              iftmp.20 = (sizetype) D.38610;
              goto <D.38623>;
              <D.38622>:
              iftmp.20 = 88;
              <D.38623>:
              D.38624 = this + iftmp.20;
              std::basic_ios<char>::init (D.38624, D.38619);
            }
          catch
            {
              D.38618 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.38618);
            }
        }
      catch
        {
          if (1 == 0) goto <D.38626>; else goto <D.38627>;
          <D.38626>:
          iftmp.21 = 8B;
          goto <D.38628>;
          <D.38627>:
          iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.38628>:
          D.38599 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.38599, iftmp.21);
        }
    }
  catch
    {
      if (1 != 0) goto <D.38629>; else goto <D.38630>;
      <D.38629>:
      D.38593 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.38593);
      goto <D.38631>;
      <D.38630>:
      <D.38631>:
    }
}


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

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


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.38638;
  int (*__vtbl_ptr_type) () * iftmp.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.38647;
  int (*__vtbl_ptr_type) () * D.38648;
  long int D.38649;
  struct basic_ios * D.38651;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  struct basic_ios * D.38660;

  if (0 != 0) goto <D.38636>; else goto <D.38637>;
  <D.38636>:
  D.38638 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.38638);
  goto <D.38639>;
  <D.38637>:
  <D.38639>:
  try
    {
      if (0 == 0) goto <D.38641>; else goto <D.38642>;
      <D.38641>:
      iftmp.22 = *__vtt_parm;
      goto <D.38643>;
      <D.38642>:
      iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
      <D.38643>:
      this->_vptr.basic_ostream = iftmp.22;
      if (0 == 0) goto <D.38645>; else goto <D.38646>;
      <D.38645>:
      D.38647 = this->_vptr.basic_ostream;
      D.38648 = D.38647 + 18446744073709551592;
      D.38649 = MEM[(long int *)D.38648];
      iftmp.23 = (sizetype) D.38649;
      goto <D.38650>;
      <D.38646>:
      iftmp.23 = 8;
      <D.38650>:
      D.38651 = this + iftmp.23;
      if (0 == 0) goto <D.38653>; else goto <D.38654>;
      <D.38653>:
      iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.38655>;
      <D.38654>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
      <D.38655>:
      D.38651->D.19008._vptr.ios_base = iftmp.24;
      if (0 == 0) goto <D.38657>; else goto <D.38658>;
      <D.38657>:
      D.38647 = this->_vptr.basic_ostream;
      D.38648 = D.38647 + 18446744073709551592;
      D.38649 = MEM[(long int *)D.38648];
      iftmp.25 = (sizetype) D.38649;
      goto <D.38659>;
      <D.38658>:
      iftmp.25 = 8;
      <D.38659>:
      D.38660 = this + iftmp.25;
      std::basic_ios<char>::init (D.38660, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.38661>; else goto <D.38662>;
      <D.38661>:
      D.38638 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.38638);
      goto <D.38663>;
      <D.38662>:
      <D.38663>:
    }
}


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

  __a.26 = (int) __a;
  __b.27 = (int) __b;
  D.38668 = __a.26 | __b.27;
  D.38665 = (_Ios_Openmode) D.38668;
  return D.38665;
}


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.38670;
  struct __string_type * D.38671;

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

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


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

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

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


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.38015;
  struct _Rep & D.38674;
  char * D.38675;
  struct _Alloc_hider * D.38676;

  std::allocator<char>::allocator (&D.38015);
  try
    {
      D.38674 = std::basic_string<char>::_S_empty_rep ();
      D.38675 = std::basic_string<char>::_Rep::_M_refdata (D.38674);
      D.38676 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.38676, D.38675, &D.38015);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.38015);
      D.38015 = {CLOBBER};
    }
  try
    {

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


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

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


_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.38682;
  void * D.38683;

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


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


