bool Glib::str_has_prefix(const string&, const string&) (const struct string & str, const struct string & prefix)
{
  bool D.32726;
  const char * D.32727;
  const char * D.32728;
  int D.32729;

  D.32727 = std::basic_string<char>::c_str (prefix);
  D.32728 = std::basic_string<char>::c_str (str);
  D.32729 = g_str_has_prefix (D.32728, D.32727);
  D.32726 = D.32729 != 0;
  return D.32726;
}


const _CharT* std::basic_string<_CharT, _Traits, _Alloc>::c_str() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  const char * D.32734;

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


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

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


bool Glib::str_has_suffix(const string&, const string&) (const struct string & str, const struct string & suffix)
{
  bool D.32739;
  const char * D.32740;
  const char * D.32741;
  int D.32742;

  D.32740 = std::basic_string<char>::c_str (suffix);
  D.32741 = std::basic_string<char>::c_str (str);
  D.32742 = g_str_has_suffix (D.32741, D.32740);
  D.32739 = D.32742 != 0;
  return D.32739;
}


double Glib::Ascii::strtod(const string&) (const struct string & str)
{
  double D.32747;
  size_type dummy;

  try
    {
      D.32747 = Glib::Ascii::strtod (str, &dummy, 0);
      return D.32747;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


double Glib::Ascii::strtod(const string&, std::basic_string<char>::size_type&, std::basic_string<char>::size_type) (const struct string & str, size_type & end_index, size_type start_index)
{
  bool retval.0;
  long unsigned int D.32754;
  void * D.32483;
  const struct string D.32479;
  struct allocator D.32478;
  const char * D.32757;
  int * D.32758;
  bool retval.1;
  int retval.2;
  long int D.32766;
  long int D.32767;
  double D.32771;
  void * D.32522;
  const struct string D.32520;
  struct allocator D.32519;
  void * D.32533;
  const struct string D.32531;
  struct allocator D.32530;
  void * D.32547;
  const struct string D.32545;
  struct allocator D.32544;
  char * endptr.3;
  long int endptr.4;
  long int bufptr.5;
  long int D.32781;
  long unsigned int D.32782;
  long unsigned int D.32784;
  const char * const bufptr;
  char * endptr;
  const double result;
  const int err_no;
  static const char __PRETTY_FUNCTION__[115] = "double Glib::Ascii::strtod(const string&, std::basic_string<char>::size_type&, std::basic_string<char>::size_type)";

  try
    {
      D.32754 = std::basic_string<char>::size (str);
      retval.0 = D.32754 <= start_index;
      if (retval.0 != 0) goto <D.32755>; else goto <D.32756>;
      <D.32755>:
      D.32483 = __cxa_allocate_exception (16);
      try
        {
          std::allocator<char>::allocator (&D.32478);
          try
            {
              std::basic_string<char>::basic_string (&D.32479, "out of range (strtod): start_index > str.size()", &D.32478);
              try
                {
                  std::out_of_range::out_of_range (D.32483, &D.32479);
                }
              finally
                {
                  try
                    {
                      std::basic_string<char>::~basic_string (&D.32479);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.32479 = {CLOBBER};
                }
            }
          finally
            {
              try
                {
                  std::allocator<char>::~allocator (&D.32478);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.32478 = {CLOBBER};
            }
        }
      catch
        {
          __cxa_free_exception (D.32483);
        }
      __cxa_throw (D.32483, &_ZTISt12out_of_range, __comp_dtor );
      <D.32756>:
      bufptr = std::basic_string<char>::c_str (str);
      endptr = 0B;
      D.32757 = bufptr + start_index;
      result = g_ascii_strtod (D.32757, &endptr);
      D.32758 = __errno_location ();
      err_no = *D.32758;
      {
        if (err_no != 0) goto <D.32759>; else goto <D.32760>;
        <D.32759>:
        {
          {
            {
              {
                int _g_boolean_var_;

                if (err_no == 34) goto <D.32763>; else goto <D.32764>;
                <D.32763>:
                _g_boolean_var_ = 1;
                goto <D.32765>;
                <D.32764>:
                _g_boolean_var_ = 0;
                <D.32765>:
                retval.2 = _g_boolean_var_;
              }
              D.32766 = (long int) retval.2;
              D.32767 = __builtin_expect (D.32766, 1);
              retval.1 = D.32767 != 0;
              if (retval.1 != 0) goto <D.32768>; else goto <D.32769>;
              <D.32768>:
              goto <D.32770>;
              <D.32769>:
              g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "err_no == ERANGE");
              D.32771 = result;
              return D.32771;
              <D.32770>:
            }
          }
          if (result > 0.0) goto <D.32772>; else goto <D.32773>;
          <D.32772>:
          D.32522 = __cxa_allocate_exception (16);
          try
            {
              std::allocator<char>::allocator (&D.32519);
              try
                {
                  std::basic_string<char>::basic_string (&D.32520, "overflow (strtod): positive number too large", &D.32519);
                  try
                    {
                      std::overflow_error::overflow_error (D.32522, &D.32520);
                    }
                  finally
                    {
                      try
                        {
                          std::basic_string<char>::~basic_string (&D.32520);
                        }
                      catch
                        {
                          <<<eh_must_not_throw (terminate)>>>
                        }
                      D.32520 = {CLOBBER};
                    }
                }
              finally
                {
                  try
                    {
                      std::allocator<char>::~allocator (&D.32519);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.32519 = {CLOBBER};
                }
            }
          catch
            {
              __cxa_free_exception (D.32522);
            }
          __cxa_throw (D.32522, &_ZTISt14overflow_error, __comp_dtor );
          <D.32773>:
          if (result < 0.0) goto <D.32774>; else goto <D.32775>;
          <D.32774>:
          D.32533 = __cxa_allocate_exception (16);
          try
            {
              std::allocator<char>::allocator (&D.32530);
              try
                {
                  std::basic_string<char>::basic_string (&D.32531, "overflow (strtod): negative number too large", &D.32530);
                  try
                    {
                      std::overflow_error::overflow_error (D.32533, &D.32531);
                    }
                  finally
                    {
                      try
                        {
                          std::basic_string<char>::~basic_string (&D.32531);
                        }
                      catch
                        {
                          <<<eh_must_not_throw (terminate)>>>
                        }
                      D.32531 = {CLOBBER};
                    }
                }
              finally
                {
                  try
                    {
                      std::allocator<char>::~allocator (&D.32530);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.32530 = {CLOBBER};
                }
            }
          catch
            {
              __cxa_free_exception (D.32533);
            }
          __cxa_throw (D.32533, &_ZTISt14overflow_error, __comp_dtor );
          <D.32775>:
          D.32547 = __cxa_allocate_exception (16);
          try
            {
              std::allocator<char>::allocator (&D.32544);
              try
                {
                  std::basic_string<char>::basic_string (&D.32545, "underflow (strtod): number too small", &D.32544);
                  try
                    {
                      std::underflow_error::underflow_error (D.32547, &D.32545);
                    }
                  finally
                    {
                      try
                        {
                          std::basic_string<char>::~basic_string (&D.32545);
                        }
                      catch
                        {
                          <<<eh_must_not_throw (terminate)>>>
                        }
                      D.32545 = {CLOBBER};
                    }
                }
              finally
                {
                  try
                    {
                      std::allocator<char>::~allocator (&D.32544);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.32544 = {CLOBBER};
                }
            }
          catch
            {
              __cxa_free_exception (D.32547);
            }
          __cxa_throw (D.32547, &_ZTISt15underflow_error, __comp_dtor );
        }
        <D.32760>:
      }
      endptr.3 = endptr;
      if (endptr.3 != 0B) goto <D.32777>; else goto <D.32778>;
      <D.32777>:
      endptr.3 = endptr;
      endptr.4 = (long int) endptr.3;
      bufptr.5 = (long int) bufptr;
      D.32781 = endptr.4 - bufptr.5;
      D.32782 = (long unsigned int) D.32781;
      *end_index = D.32782;
      goto <D.32783>;
      <D.32778>:
      D.32784 = std::basic_string<char>::size (str);
      *end_index = D.32784;
      <D.32783>:
      D.32771 = result;
      return D.32771;
    }
  finally
    {
      endptr = {CLOBBER};
    }
}


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

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

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


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

  try
    {
      {

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


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.32806;
  struct _Rep * D.32807;

  D.32807 = std::basic_string<char>::_M_rep (this);
  D.32806 = D.32807->D.18966._M_length;
  return D.32806;
}


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.32810;
  char * D.32811;

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


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.32638;
  struct _Rep * D.32814;
  struct _Alloc_hider * D.32815;

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


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

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

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


__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.14983)
{
  void * D.32824;

  try
    {
      {

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


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.6;
  struct _Rep & D.32826;
  bool D.32827;
  long int D.32828;
  long int D.32829;
  bool retval.7;
  _Atomic_word * D.32833;
  int D.32834;

  D.32826 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.32827 = D.32826 != this;
  D.32828 = (long int) D.32827;
  D.32829 = __builtin_expect (D.32828, 0);
  retval.6 = D.32829 != 0;
  if (retval.6 != 0) goto <D.32830>; else goto <D.32831>;
  <D.32830>:
  D.32833 = &this->D.18966._M_refcount;
  D.32834 = __gnu_cxx::__exchange_and_add_dispatch (D.32833, -1);
  retval.7 = D.32834 <= 0;
  if (retval.7 != 0) goto <D.32835>; else goto <D.32836>;
  <D.32835>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.32837>;
  <D.32836>:
  <D.32837>:
  goto <D.32838>;
  <D.32831>:
  <D.32838>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.8;
  int D.32843;
  _Atomic_word D.32846;

  D.32843 = __gthread_active_p ();
  retval.8 = D.32843 != 0;
  if (retval.8 != 0) goto <D.32844>; else goto <D.32845>;
  <D.32844>:
  D.32846 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.32846;
  <D.32845>:
  D.32846 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.32846;
}


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

  D.32849 = __gthrw___pthread_key_create != 0B;
  D.32848 = (int) D.32849;
  return D.32848;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.32851;
  unsigned int __val.9;
  unsigned int D.32853;

  __val.9 = (unsigned int) __val;
  D.32853 = __atomic_fetch_add_4 (__mem, __val.9, 4);
  D.32851 = (_Atomic_word) D.32853;
  return D.32851;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.32855;
  int D.32856;
  _Atomic_word D.32857;
  _Atomic_word __result;

  __result = *__mem;
  D.32855 = *__mem;
  D.32856 = D.32855 + __val;
  *__mem = D.32856;
  D.32857 = __result;
  return D.32857;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::string Glib::Ascii::dtostr(double) (double d)
{
  struct allocator D.32558;
  int D.32862;
  gchar * D.32863;
  char buf[39];

  try
    {
      std::allocator<char>::allocator (&D.32558);
      try
        {
          D.32862 = 39;
          D.32863 = g_ascii_dtostr (&buf, D.32862, d);
          std::basic_string<char>::basic_string (<retval>, D.32863, &D.32558);
          return <retval>;
        }
      finally
        {
          std::allocator<char>::~allocator (&D.32558);
          D.32558 = {CLOBBER};
        }
    }
  finally
    {
      buf = {CLOBBER};
    }
}


std::string Glib::strescape(const string&) (const struct string & source)
{
  const char * D.32871;
  gchar * D.32872;
  struct allocator D.32565;
  char * D.32873;
  const struct ScopedPtr buf;

  try
    {
      D.32871 = std::basic_string<char>::c_str (source);
      D.32872 = g_strescape (D.32871, 0B);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.32872);
      try
        {
          std::allocator<char>::allocator (&D.32565);
          try
            {
              D.32873 = Glib::ScopedPtr<char>::get (&buf);
              std::basic_string<char>::basic_string (<retval>, D.32873, &D.32565);
              return <retval>;
            }
          finally
            {
              std::allocator<char>::~allocator (&D.32565);
              D.32565 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {CLOBBER};
    }
}


Glib::ScopedPtr<T>::ScopedPtr(T*) [with T = char] (struct ScopedPtr * const this, char * ptr)
{
  this->ptr_ = ptr;
}


T* Glib::ScopedPtr<T>::get() const [with T = char] (const struct ScopedPtr * const this)
{
  char * D.32883;

  D.32883 = this->ptr_;
  return D.32883;
}


Glib::ScopedPtr<T>::~ScopedPtr() [with T = char] (struct ScopedPtr * const this)
{
  char * D.32885;

  {
    try
      {
        D.32885 = this->ptr_;
        g_free (D.32885);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.32682>:
}


std::string Glib::strescape(const string&, const string&) (const struct string & source, const struct string & exceptions)
{
  const char * D.32888;
  const char * D.32889;
  gchar * D.32890;
  struct allocator D.32573;
  char * D.32891;
  const struct ScopedPtr buf;

  try
    {
      D.32888 = std::basic_string<char>::c_str (exceptions);
      D.32889 = std::basic_string<char>::c_str (source);
      D.32890 = g_strescape (D.32889, D.32888);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.32890);
      try
        {
          std::allocator<char>::allocator (&D.32573);
          try
            {
              D.32891 = Glib::ScopedPtr<char>::get (&buf);
              std::basic_string<char>::basic_string (<retval>, D.32891, &D.32573);
              return <retval>;
            }
          finally
            {
              std::allocator<char>::~allocator (&D.32573);
              D.32573 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {CLOBBER};
    }
}


std::string Glib::strcompress(const string&) (const struct string & source)
{
  const char * D.32903;
  gchar * D.32904;
  struct allocator D.32580;
  char * D.32905;
  const struct ScopedPtr buf;

  try
    {
      D.32903 = std::basic_string<char>::c_str (source);
      D.32904 = g_strcompress (D.32903);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.32904);
      try
        {
          std::allocator<char>::allocator (&D.32580);
          try
            {
              D.32905 = Glib::ScopedPtr<char>::get (&buf);
              std::basic_string<char>::basic_string (<retval>, D.32905, &D.32580);
              return <retval>;
            }
          finally
            {
              std::allocator<char>::~allocator (&D.32580);
              D.32580 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {CLOBBER};
    }
}


Glib::ustring Glib::strerror(int) (int errnum)
{
  const gchar * D.32916;

  D.32916 = g_strerror (errnum);
  Glib::ustring::ustring (<retval>, D.32916);
  return <retval>;
}


Glib::ustring Glib::strsignal(int) (int signum)
{
  const gchar * D.32920;

  D.32920 = g_strsignal (signum);
  Glib::ustring::ustring (<retval>, D.32920);
  return <retval>;
}