std::string Glib::uri_unescape_string(const string&, const string&) (const struct string & escaped_string, const struct string & illegal_characters)
{
  const char * D.86573;
  const char * D.86574;
  gchar * cresult;

  D.86573 = std::basic_string<char>::c_str (illegal_characters);
  D.86574 = std::basic_string<char>::c_str (escaped_string);
  cresult = g_uri_unescape_string (D.86574, D.86573);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (cresult); [return slot optimization]
  return <retval>;
}


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

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


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

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


std::string Glib::convert_return_gchar_ptr_to_stdstring(char*) (char * str)
{
  struct allocator D.78983;
  bool cleanup.0;
  struct ScopedPtr D.78981;
  bool cleanup.1;
  char * D.86593;
  struct string * D.86594;

  cleanup.0 = 0;
  try
    {
      cleanup.1 = 0;
      try
        {
          if (str != 0B) goto <D.86585>; else goto <D.86586>;
          <D.86585>:
          std::allocator<char>::allocator (&D.78983);
          cleanup.0 = 1;
          Glib::ScopedPtr<char>::ScopedPtr (&D.78981, str);
          cleanup.1 = 1;
          D.86593 = Glib::ScopedPtr<char>::get (&D.78981);
          D.86594 = <retval>;
          std::basic_string<char>::basic_string (D.86594, D.86593, &D.78983);
          goto <D.86595>;
          <D.86586>:
          D.86594 = <retval>;
          std::basic_string<char>::basic_string (D.86594);
          <D.86595>:
          return <retval>;
        }
      finally
        {
          if (cleanup.1 != 0) goto <D.86591>; else goto <D.86592>;
          <D.86591>:
          Glib::ScopedPtr<char>::~ScopedPtr (&D.78981);
          D.78981 = {CLOBBER};
          <D.86592>:
        }
    }
  finally
    {
      if (cleanup.0 != 0) goto <D.86588>; else goto <D.86589>;
      <D.86588>:
      std::allocator<char>::~allocator (&D.78983);
      D.78983 = {CLOBBER};
      <D.86589>:
    }
}


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

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

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


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

  try
    {
      {

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


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

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


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.86228;
  struct _Rep & D.86610;
  char * D.86611;
  struct _Alloc_hider * D.86612;

  std::allocator<char>::allocator (&D.86228);
  try
    {
      D.86610 = std::basic_string<char>::_S_empty_rep ();
      D.86611 = std::basic_string<char>::_Rep::_M_refdata (D.86610);
      D.86612 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.86612, D.86611, &D.86228);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.86228);
      D.86228 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.86620;
  void * D.86621;

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


std::basic_string<_CharT, _Traits, _Alloc>::_Alloc_hider::_Alloc_hider(_CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Alloc_hider * const this, char * __dat, const struct allocator & __a)
{
  std::allocator<char>::allocator (this, __a);
  try
    {
      this->_M_p = __dat;
    }
  catch
    {
      std::allocator<char>::~allocator (this);
    }
}


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

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


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

  try
    {
      {

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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::string Glib::uri_parse_scheme(const string&) (const struct string & uri)
{
  const char * D.86630;
  char * D.86631;

  D.86630 = std::basic_string<char>::c_str (uri);
  D.86631 = g_uri_parse_scheme (D.86630);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.86631); [return slot optimization]
  return <retval>;
}


std::string Glib::uri_escape_string(const string&, const string&, bool) (const struct string & unescaped, const struct string & reserved_chars_allowed, bool allow_utf8)
{
  int D.86636;
  const char * D.86637;
  const char * D.86638;
  gchar * cresult;

  D.86636 = (int) allow_utf8;
  D.86637 = std::basic_string<char>::c_str (reserved_chars_allowed);
  D.86638 = std::basic_string<char>::c_str (unescaped);
  cresult = g_uri_escape_string (D.86638, D.86637, D.86636);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (cresult); [return slot optimization]
  return <retval>;
}