int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.49589;
  int D.49592;
  int iftmp.1;
  bool D.49594;
  struct pointer_functor0 D.48767;
  const struct string D.48770;
  struct allocator D.48769;
  const int D.48805;
  struct pointer_functor1 D.48804;
  const struct string D.48808;
  struct allocator D.48807;
  const float D.48843;
  struct pointer_functor1 D.48842;
  const struct string D.48846;
  struct allocator D.48845;
  const int D.48876;
  const int D.48875;
  struct pointer_functor2 D.48874;
  const struct string D.48879;
  struct allocator D.48878;
  struct pointer_functor0 D.48905;
  const struct string D.48908;
  struct allocator D.48907;
  int iftmp.2;
  bool D.49599;

  {
    struct TestUtilities * util;

    util = TestUtilities::get_instance ();
    D.49589 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.49589;
    if (retval.0 != 0) goto <D.49590>; else goto <D.49591>;
    <D.49590>:
    D.49594 = TestUtilities::get_result_and_delete_instance ();
    if (D.49594 != 0) goto <D.49595>; else goto <D.49596>;
    <D.49595>:
    iftmp.1 = 0;
    goto <D.49597>;
    <D.49596>:
    iftmp.1 = 1;
    <D.49597>:
    D.49592 = iftmp.1;
    return D.49592;
    <D.49591>:
    D.48767 = sigc::ptr_fun0<int> (foo);
    try
      {
        sigc::pointer_functor0<int>::operator() (&D.48767);
      }
    finally
      {
        D.48767 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.48769);
    try
      {
        std::basic_string<char>::basic_string (&D.48770, "foo()", &D.48769);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48770);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48770);
            D.48770 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48769);
        D.48769 = {CLOBBER};
      }
    D.48805 = 1;
    try
      {
        D.48804 = sigc::ptr_fun1<int, void> (foo);
        try
          {
            sigc::pointer_functor1<int, void>::operator() (&D.48804, &D.48805);
          }
        finally
          {
            D.48804 = {CLOBBER};
          }
      }
    finally
      {
        D.48805 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.48807);
    try
      {
        std::basic_string<char>::basic_string (&D.48808, "foo(int 1)", &D.48807);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48808);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48808);
            D.48808 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48807);
        D.48807 = {CLOBBER};
      }
    D.48843 = 2.0e+0;
    try
      {
        D.48842 = sigc::ptr_fun1<float, void> (bar);
        try
          {
            sigc::pointer_functor1<float, void>::operator() (&D.48842, &D.48843);
          }
        finally
          {
            D.48842 = {CLOBBER};
          }
      }
    finally
      {
        D.48843 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.48845);
    try
      {
        std::basic_string<char>::basic_string (&D.48846, "bar(float 2)", &D.48845);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48846);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48846);
            D.48846 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48845);
        D.48845 = {CLOBBER};
      }
    D.48876 = 5;
    try
      {
        D.48875 = 3;
        try
          {
            D.48874 = sigc::ptr_fun2<int, int, double> (bar);
            try
              {
                sigc::pointer_functor2<int, int, double>::operator() (&D.48874, &D.48875, &D.48876);
              }
            finally
              {
                D.48874 = {CLOBBER};
              }
          }
        finally
          {
            D.48875 = {CLOBBER};
          }
      }
    finally
      {
        D.48876 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.48878);
    try
      {
        std::basic_string<char>::basic_string (&D.48879, "bar(int 3, int 5)", &D.48878);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48879);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48879);
            D.48879 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48878);
        D.48878 = {CLOBBER};
      }
    D.48905 = sigc::ptr_fun<void> (foo);
    try
      {
        sigc::pointer_functor0<void>::operator() (&D.48905);
      }
    finally
      {
        D.48905 = {CLOBBER};
      }
    std::allocator<char>::allocator (&D.48907);
    try
      {
        std::basic_string<char>::basic_string (&D.48908, "test::foo()", &D.48907);
        try
          {
            TestUtilities::check_result (util, &result_stream, &D.48908);
          }
        finally
          {
            std::basic_string<char>::~basic_string (&D.48908);
            D.48908 = {CLOBBER};
          }
      }
    finally
      {
        std::allocator<char>::~allocator (&D.48907);
        D.48907 = {CLOBBER};
      }
    D.49599 = TestUtilities::get_result_and_delete_instance ();
    if (D.49599 != 0) goto <D.49600>; else goto <D.49601>;
    <D.49600>:
    iftmp.2 = 0;
    goto <D.49602>;
    <D.49601>:
    iftmp.2 = 1;
    <D.49602>:
    D.49592 = iftmp.2;
    return D.49592;
  }
  D.49592 = 0;
  return D.49592;
}


static void {anonymous}::test::foo() ()
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "test::foo()");
}


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.49630;
  int (*__vtbl_ptr_type) () * D.49631;
  long int D.49632;
  sizetype D.49633;
  struct basic_ios * D.49634;
  long unsigned int D.49636;
  long int D.49637;
  struct basic_ostream & D.49638;

  if (__s == 0B) goto <D.49628>; else goto <D.49629>;
  <D.49628>:
  D.49630 = __out->_vptr.basic_ostream;
  D.49631 = D.49630 + 18446744073709551592;
  D.49632 = MEM[(long int *)D.49631];
  D.49633 = (sizetype) D.49632;
  D.49634 = __out + D.49633;
  std::basic_ios<char>::setstate (D.49634, 1);
  goto <D.49635>;
  <D.49629>:
  D.49636 = std::char_traits<char>::length (__s);
  D.49637 = (long int) D.49636;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.49637);
  <D.49635>:
  D.49638 = __out;
  return D.49638;
}


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.49640;
  _Ios_Iostate D.49641;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.49648 = __a.3 | __b.4;
  D.49645 = (_Ios_Iostate) D.49648;
  return D.49645;
}


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

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


double {anonymous}::bar(int, int) (int i1, int i2)
{
  struct basic_ostream & D.49652;
  struct basic_ostream & D.49653;
  struct basic_ostream & D.49654;
  struct basic_ostream & D.49655;
  double D.49656;

  D.49652 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar(int ");
  D.49653 = std::basic_ostream<char>::operator<< (D.49652, i1);
  D.49654 = std::operator<< <std::char_traits<char> > (D.49653, ", int ");
  D.49655 = std::basic_ostream<char>::operator<< (D.49654, i2);
  std::operator<< <std::char_traits<char> > (D.49655, ")");
  D.49656 = 1.0e+0;
  return D.49656;
}


void {anonymous}::bar(float) (float i1)
{
  struct basic_ostream & D.49662;
  struct __ostream_type & D.49663;

  D.49662 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar(float ");
  D.49663 = std::basic_ostream<char>::operator<< (D.49662, i1);
  std::operator<< <std::char_traits<char> > (D.49663, ")");
}


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, float __f)
{
  struct __ostream_type & D.49666;
  double D.49667;

  D.49667 = (double) __f;
  D.49666 = std::basic_ostream<char>::_M_insert<double> (this, D.49667);
  return D.49666;
}


void {anonymous}::foo(int) (int i1)
{
  struct basic_ostream & D.49672;
  struct basic_ostream & D.49673;

  D.49672 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.49673 = std::basic_ostream<char>::operator<< (D.49672, i1);
  std::operator<< <std::char_traits<char> > (D.49673, ")");
}


int {anonymous}::foo() ()
{
  int D.49676;

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


sigc::pointer_functor0<T_return> sigc::ptr_fun0(T_return (*)()) [with T_return = int] (int (*<Tcb1>) (void) _A_func)
{
  struct pointer_functor0 D.49678;
  struct pointer_functor0 D.49091;

  sigc::pointer_functor0<int>::pointer_functor0 (&D.49091, _A_func);
  try
    {
      D.49678 = D.49091;
      return D.49678;
    }
  finally
    {
      D.49091 = {CLOBBER};
    }
}


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


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

}


T_return sigc::pointer_functor0<T_return>::operator()() const [with T_return = int] (const struct pointer_functor0 * const this)
{
  int D.49681;
  int (*<Tcb1>) (void) D.49682;

  D.49682 = this->func_ptr_;
  D.49681 = D.49682 ();
  return D.49681;
}


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = void] (void (*<T8b3d>) (int) _A_func)
{
  struct pointer_functor1 D.49685;
  struct pointer_functor1 D.49138;

  sigc::pointer_functor1<int, void>::pointer_functor1 (&D.49138, _A_func);
  try
    {
      D.49685 = D.49138;
      return D.49685;
    }
  finally
    {
      D.49138 = {CLOBBER};
    }
}


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


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

  D.49688 = this->func_ptr_;
  D.49689 = *_A_a1;
  D.49688 (D.49689);
  return;
}


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = float; T_return = void] (void (*<T8b7c>) (float) _A_func)
{
  struct pointer_functor1 D.49691;
  struct pointer_functor1 D.49150;

  sigc::pointer_functor1<float, void>::pointer_functor1 (&D.49150, _A_func);
  try
    {
      D.49691 = D.49150;
      return D.49691;
    }
  finally
    {
      D.49150 = {CLOBBER};
    }
}


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


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

  D.49694 = this->func_ptr_;
  D.49695 = *_A_a1;
  D.49694 (D.49695);
  return;
}


sigc::pointer_functor2<T_arg1, T_arg2, T_return> sigc::ptr_fun2(T_return (*)(T_arg1, T_arg2)) [with T_arg1 = int; T_arg2 = int; T_return = double] (double (*<T8b7b>) (int, int) _A_func)
{
  struct pointer_functor2 D.49697;
  struct pointer_functor2 D.49162;

  sigc::pointer_functor2<int, int, double>::pointer_functor2 (&D.49162, _A_func);
  try
    {
      D.49697 = D.49162;
      return D.49697;
    }
  finally
    {
      D.49162 = {CLOBBER};
    }
}


sigc::pointer_functor2<T_arg1, T_arg2, T_return>::pointer_functor2(sigc::pointer_functor2<T_arg1, T_arg2, T_return>::function_type) [with T_arg1 = int; T_arg2 = int; T_return = double; sigc::pointer_functor2<T_arg1, T_arg2, T_return>::function_type = double (*)(int, int)] (struct pointer_functor2 * const this, double (*function_type) (int, int) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


T_return sigc::pointer_functor2<T_arg1, T_arg2, T_return>::operator()(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) const [with T_arg1 = int; T_arg2 = int; T_return = double; typename sigc::type_trait<T_base>::take = const int&; typename sigc::type_trait<T_derived>::take = const int&] (const struct pointer_functor2 * const this, const int & _A_a1, const int & _A_a2)
{
  double D.49700;
  double (*<T8b7b>) (int, int) D.49701;
  int D.49702;
  int D.49703;

  D.49701 = this->func_ptr_;
  D.49702 = *_A_a2;
  D.49703 = *_A_a1;
  D.49700 = D.49701 (D.49703, D.49702);
  return D.49700;
}


sigc::pointer_functor0<T_return> sigc::ptr_fun(T_return (*)()) [with T_return = void] (void (*<Ted6>) (void) _A_func)
{
  struct pointer_functor0 D.49706;
  struct pointer_functor0 D.49174;

  sigc::pointer_functor0<void>::pointer_functor0 (&D.49174, _A_func);
  try
    {
      D.49706 = D.49174;
      return D.49706;
    }
  finally
    {
      D.49174 = {CLOBBER};
    }
}


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


T_return sigc::pointer_functor0<T_return>::operator()() const [with T_return = void] (const struct pointer_functor0 * const this)
{
  void (*<Ted6>) (void) D.49709;

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


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

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

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


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

  try
    {
      {

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


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.49124;
  struct _Rep * D.49713;
  struct _Alloc_hider * D.49714;

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


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

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

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


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

  try
    {
      {

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


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.49724;
  char * D.49725;

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


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

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


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.49731;
  bool D.49732;
  long int D.49733;
  long int D.49734;
  bool retval.6;
  _Atomic_word * D.49738;
  int D.49739;

  D.49731 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.49732 = D.49731 != this;
  D.49733 = (long int) D.49732;
  D.49734 = __builtin_expect (D.49733, 0);
  retval.5 = D.49734 != 0;
  if (retval.5 != 0) goto <D.49735>; else goto <D.49736>;
  <D.49735>:
  D.49738 = &this->D.11865._M_refcount;
  D.49739 = __gnu_cxx::__exchange_and_add_dispatch (D.49738, -1);
  retval.6 = D.49739 <= 0;
  if (retval.6 != 0) goto <D.49740>; else goto <D.49741>;
  <D.49740>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.49742>;
  <D.49741>:
  <D.49742>:
  goto <D.49743>;
  <D.49736>:
  <D.49743>:
}


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

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


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

  D.49748 = __gthread_active_p ();
  retval.7 = D.49748 != 0;
  if (retval.7 != 0) goto <D.49749>; else goto <D.49750>;
  <D.49749>:
  D.49751 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.49751;
  <D.49750>:
  D.49751 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.49751;
}


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

  D.49754 = __gthrw___pthread_key_create != 0B;
  D.49753 = (int) D.49754;
  return D.49753;
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.49760;
  int D.49761;
  _Atomic_word D.49762;
  _Atomic_word __result;

  __result = *__mem;
  D.49760 = *__mem;
  D.49761 = D.49760 + __val;
  *__mem = D.49761;
  D.49762 = __result;
  return D.49762;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_ptr_fun.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.49766>; else goto <D.49767>;
  <D.49766>:
  if (__priority == 65535) goto <D.49768>; else goto <D.49769>;
  <D.49768>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.49770>;
  <D.49769>:
  <D.49770>:
  goto <D.49771>;
  <D.49767>:
  <D.49771>:
}


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.49775;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.49780;
  int (*__vtbl_ptr_type) () * D.49781;
  long int D.49782;
  struct basic_ios * D.49784;
  int (*__vtbl_ptr_type) () * iftmp.11;
  struct __stringbuf_type * D.49789;
  const void * * iftmp.12;
  struct basic_ostream * D.49794;
  int D.49795;
  struct basic_ios * D.49798;
  int D.49800;

  {
    if (2 == 0) goto <D.49773>; else goto <D.49774>;
    <D.49773>:
    D.49775 = 0B;
    iftmp.9 = *D.49775;
    goto <D.49776>;
    <D.49774>:
    iftmp.9 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.49776>:
    this->D.22312._vptr.basic_ostream = iftmp.9;
    if (2 == 0) goto <D.49778>; else goto <D.49779>;
    <D.49778>:
    D.49780 = this->D.22312._vptr.basic_ostream;
    D.49781 = D.49780 + 18446744073709551592;
    D.49782 = MEM[(long int *)D.49781];
    iftmp.10 = (sizetype) D.49782;
    goto <D.49783>;
    <D.49779>:
    iftmp.10 = 88;
    <D.49783>:
    D.49784 = this + iftmp.10;
    if (2 == 0) goto <D.49786>; else goto <D.49787>;
    <D.49786>:
    iftmp.11 = MEM[(const void * *)0B + 24B];
    goto <D.49788>;
    <D.49787>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.49788>:
    D.49784->D.19008._vptr.ios_base = iftmp.11;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.49789 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.49789);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.49791>; else goto <D.49792>;
                <D.49791>:
                iftmp.12 = 8B;
                goto <D.49793>;
                <D.49792>:
                iftmp.12 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.49793>:
                D.49794 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.49794, iftmp.12);
              }
          }
        finally
          {
            D.49795 = 2;
            if (D.49795 != 0) goto <D.49796>; else goto <D.49797>;
            <D.49796>:
            D.49798 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.49798);
            goto <D.49799>;
            <D.49797>:
            <D.49799>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49583>:
  D.49800 = 0;
  if (D.49800 != 0) goto <D.49801>; else goto <D.49802>;
  <D.49801>:
  operator delete (this);
  goto <D.49803>;
  <D.49802>:
  <D.49803>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.49813;
  struct basic_streambuf * D.49814;
  int D.49815;

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

              }
            finally
              {
                D.49813 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.49813);
              }
          }
        finally
          {
            D.49814 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.49814);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49072>:
  D.49815 = 0;
  if (D.49815 != 0) goto <D.49816>; else goto <D.49817>;
  <D.49816>:
  operator delete (this);
  goto <D.49818>;
  <D.49817>:
  <D.49818>:
}


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

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

          }
        finally
          {
            D.49821 = &this->_M_buf_locale;
            std::locale::~locale (D.49821);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49274>:
  D.49822 = 0;
  if (D.49822 != 0) goto <D.49823>; else goto <D.49824>;
  <D.49823>:
  operator delete (this);
  goto <D.49825>;
  <D.49824>:
  <D.49825>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.49076>:
  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.49833;
  int (*__vtbl_ptr_type) () * D.49834;
  long int D.49835;
  struct basic_ios * D.49837;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int D.49842;
  struct basic_ios * D.49845;
  int D.49847;

  {
    if (0 == 0) goto <D.49827>; else goto <D.49828>;
    <D.49827>:
    iftmp.13 = *__vtt_parm;
    goto <D.49829>;
    <D.49828>:
    iftmp.13 = &MEM[(void *)&_ZTVSo + 24B];
    <D.49829>:
    this->_vptr.basic_ostream = iftmp.13;
    if (0 == 0) goto <D.49831>; else goto <D.49832>;
    <D.49831>:
    D.49833 = this->_vptr.basic_ostream;
    D.49834 = D.49833 + 18446744073709551592;
    D.49835 = MEM[(long int *)D.49834];
    iftmp.14 = (sizetype) D.49835;
    goto <D.49836>;
    <D.49832>:
    iftmp.14 = 8;
    <D.49836>:
    D.49837 = this + iftmp.14;
    if (0 == 0) goto <D.49839>; else goto <D.49840>;
    <D.49839>:
    iftmp.15 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.49841>;
    <D.49840>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 64B];
    <D.49841>:
    D.49837->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {

          }
        finally
          {
            D.49842 = 0;
            if (D.49842 != 0) goto <D.49843>; else goto <D.49844>;
            <D.49843>:
            D.49845 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.49845);
            goto <D.49846>;
            <D.49844>:
            <D.49846>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49259>:
  D.49847 = 0;
  if (D.49847 != 0) goto <D.49848>; else goto <D.49849>;
  <D.49848>:
  operator delete (this);
  goto <D.49850>;
  <D.49849>:
  <D.49850>:
}


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

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

          }
        finally
          {
            D.49852 = &this->D.19008;
            std::ios_base::~ios_base (D.49852);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49247>:
  D.49853 = 0;
  if (D.49853 != 0) goto <D.49854>; else goto <D.49855>;
  <D.49854>:
  operator delete (this);
  goto <D.49856>;
  <D.49855>:
  <D.49856>:
}


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.49251>:
  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.49860;
  const void * * iftmp.16;
  struct basic_ostream * D.49866;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.49870;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.49875;
  int (*__vtbl_ptr_type) () * D.49876;
  long int D.49877;
  struct basic_ios * D.49879;
  int (*__vtbl_ptr_type) () * iftmp.19;
  _Ios_Openmode D.49884;
  struct __stringbuf_type * D.49885;
  struct basic_streambuf * D.49886;
  sizetype iftmp.20;
  struct basic_ios * D.49891;
  const void * * iftmp.21;

  if (1 != 0) goto <D.49858>; else goto <D.49859>;
  <D.49858>:
  D.49860 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.49860);
  goto <D.49861>;
  <D.49859>:
  <D.49861>:
  try
    {
      if (1 == 0) goto <D.49863>; else goto <D.49864>;
      <D.49863>:
      iftmp.16 = 8B;
      goto <D.49865>;
      <D.49864>:
      iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.49865>:
      D.49866 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.49866, iftmp.16);
      try
        {
          if (1 == 0) goto <D.49868>; else goto <D.49869>;
          <D.49868>:
          D.49870 = 0B;
          iftmp.17 = *D.49870;
          goto <D.49871>;
          <D.49869>:
          iftmp.17 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.49871>:
          this->D.22312._vptr.basic_ostream = iftmp.17;
          if (1 == 0) goto <D.49873>; else goto <D.49874>;
          <D.49873>:
          D.49875 = this->D.22312._vptr.basic_ostream;
          D.49876 = D.49875 + 18446744073709551592;
          D.49877 = MEM[(long int *)D.49876];
          iftmp.18 = (sizetype) D.49877;
          goto <D.49878>;
          <D.49874>:
          iftmp.18 = 88;
          <D.49878>:
          D.49879 = this + iftmp.18;
          if (1 == 0) goto <D.49881>; else goto <D.49882>;
          <D.49881>:
          iftmp.19 = MEM[(const void * *)0B + 24B];
          goto <D.49883>;
          <D.49882>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.49883>:
          D.49879->D.19008._vptr.ios_base = iftmp.19;
          D.49884 = std::operator| (__mode, 16);
          D.49885 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.49885, D.49884);
          try
            {
              D.49886 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.49888>; else goto <D.49889>;
              <D.49888>:
              D.49875 = this->D.22312._vptr.basic_ostream;
              D.49876 = D.49875 + 18446744073709551592;
              D.49877 = MEM[(long int *)D.49876];
              iftmp.20 = (sizetype) D.49877;
              goto <D.49890>;
              <D.49889>:
              iftmp.20 = 88;
              <D.49890>:
              D.49891 = this + iftmp.20;
              std::basic_ios<char>::init (D.49891, D.49886);
            }
          catch
            {
              D.49885 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.49885);
            }
        }
      catch
        {
          if (1 == 0) goto <D.49893>; else goto <D.49894>;
          <D.49893>:
          iftmp.21 = 8B;
          goto <D.49895>;
          <D.49894>:
          iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.49895>:
          D.49866 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.49866, iftmp.21);
        }
    }
  catch
    {
      if (1 != 0) goto <D.49896>; else goto <D.49897>;
      <D.49896>:
      D.49860 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.49860);
      goto <D.49898>;
      <D.49897>:
      <D.49898>:
    }
}


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

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


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.49905;
  int (*__vtbl_ptr_type) () * iftmp.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.49914;
  int (*__vtbl_ptr_type) () * D.49915;
  long int D.49916;
  struct basic_ios * D.49918;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  struct basic_ios * D.49927;

  if (0 != 0) goto <D.49903>; else goto <D.49904>;
  <D.49903>:
  D.49905 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.49905);
  goto <D.49906>;
  <D.49904>:
  <D.49906>:
  try
    {
      if (0 == 0) goto <D.49908>; else goto <D.49909>;
      <D.49908>:
      iftmp.22 = *__vtt_parm;
      goto <D.49910>;
      <D.49909>:
      iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
      <D.49910>:
      this->_vptr.basic_ostream = iftmp.22;
      if (0 == 0) goto <D.49912>; else goto <D.49913>;
      <D.49912>:
      D.49914 = this->_vptr.basic_ostream;
      D.49915 = D.49914 + 18446744073709551592;
      D.49916 = MEM[(long int *)D.49915];
      iftmp.23 = (sizetype) D.49916;
      goto <D.49917>;
      <D.49913>:
      iftmp.23 = 8;
      <D.49917>:
      D.49918 = this + iftmp.23;
      if (0 == 0) goto <D.49920>; else goto <D.49921>;
      <D.49920>:
      iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.49922>;
      <D.49921>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
      <D.49922>:
      D.49918->D.19008._vptr.ios_base = iftmp.24;
      if (0 == 0) goto <D.49924>; else goto <D.49925>;
      <D.49924>:
      D.49914 = this->_vptr.basic_ostream;
      D.49915 = D.49914 + 18446744073709551592;
      D.49916 = MEM[(long int *)D.49915];
      iftmp.25 = (sizetype) D.49916;
      goto <D.49926>;
      <D.49925>:
      iftmp.25 = 8;
      <D.49926>:
      D.49927 = this + iftmp.25;
      std::basic_ios<char>::init (D.49927, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.49928>; else goto <D.49929>;
      <D.49928>:
      D.49905 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.49905);
      goto <D.49930>;
      <D.49929>:
      <D.49930>:
    }
}


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

  __a.26 = (int) __a;
  __b.27 = (int) __b;
  D.49935 = __a.26 | __b.27;
  D.49932 = (_Ios_Openmode) D.49935;
  return D.49932;
}


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.49937;
  struct __string_type * D.49938;

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

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


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

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

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


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.49463;
  struct _Rep & D.49941;
  char * D.49942;
  struct _Alloc_hider * D.49943;

  std::allocator<char>::allocator (&D.49463);
  try
    {
      D.49941 = std::basic_string<char>::_S_empty_rep ();
      D.49942 = std::basic_string<char>::_Rep::_M_refdata (D.49941);
      D.49943 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.49943, D.49942, &D.49463);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.49463);
      D.49463 = {CLOBBER};
    }
  try
    {

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


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

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


_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.49949;
  void * D.49950;

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


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


