std::string Glib::Base64::encode(const string&, bool) (const struct string & source, bool break_lines)
{
  long unsigned int D.32511;
  long unsigned int D.32512;
  long unsigned int D.32513;
  long unsigned int D.32514;
  long unsigned int D.32515;
  long unsigned int D.32516;
  void * D.32517;
  char * D.32518;
  int D.32519;
  long unsigned int D.32520;
  gsize D.32178;
  char * D.32521;
  char * D.32522;
  struct allocator D.32195;
  char * D.32523;
  char * D.32524;
  char * D.32525;
  gsize length;
  const struct ScopedPtr buf;
  gint state;
  gint save;
  const guchar * src;
  gsize out;

  try
    {
      D.32511 = std::basic_string<char>::length (source);
      D.32512 = D.32511 / 3;
      D.32513 = D.32512 + 1;
      D.32514 = D.32513 * 4;
      length = D.32514 + 1;
      D.32515 = length / 72;
      D.32516 = D.32515 + length;
      length = D.32516 + 1;
      D.32517 = g_malloc (length);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.32517);
      try
        {
          state = 0;
          save = 0;
          src = std::basic_string<char>::data (source);
          D.32518 = Glib::ScopedPtr<char>::get (&buf);
          D.32519 = (int) break_lines;
          D.32520 = std::basic_string<char>::length (source);
          out = g_base64_encode_step (src, D.32520, D.32519, D.32518, &state, &save);
          D.32521 = Glib::ScopedPtr<char>::get (&buf);
          D.32522 = D.32521 + out;
          D.32519 = (int) break_lines;
          D.32178 = g_base64_encode_close (D.32519, D.32522, &state, &save);
          out = out + D.32178;
          std::allocator<char>::allocator (&D.32195);
          try
            {
              D.32523 = Glib::ScopedPtr<char>::get (&buf);
              D.32524 = D.32523 + out;
              D.32525 = Glib::ScopedPtr<char>::get (&buf);
              std::basic_string<char>::basic_string<char*> (<retval>, D.32525, D.32524, &D.32195);
              return <retval>;
            }
          finally
            {
              std::allocator<char>::~allocator (&D.32195);
              D.32195 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {CLOBBER};
      state = {CLOBBER};
      save = {CLOBBER};
    }
}


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


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

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


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

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


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::length() 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.32545;
  struct _Rep * D.32546;

  D.32546 = std::basic_string<char>::_M_rep (this);
  D.32545 = D.32546->D.11865._M_length;
  return D.32545;
}


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.32549;
  char * D.32550;

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


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

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

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


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

  try
    {
      {

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


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

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


std::basic_string<_CharT, _Traits, _Alloc>::basic_string(_InputIterator, _InputIterator, const _Alloc&) [with _InputIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, char * __beg, char * __end, const struct allocator & __a)
{
  char * D.32557;
  struct _Alloc_hider * D.32558;

  D.32557 = std::basic_string<char>::_S_construct<char*> (__beg, __end, __a);
  D.32558 = &this->_M_dataplus;
  std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.32558, D.32557, __a);
  try
    {

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


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&) [with _InIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a)
{
  char * D.32560;
  struct _Integral D.32349;
  struct __false_type D.32561;
  typedef struct _Integral _Integral;

  try
    {
      D.32560 = std::basic_string<char>::_S_construct_aux<char*> (__beg, __end, __a, D.32561);
      return D.32560;
    }
  finally
    {
      D.32349 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct_aux(_InIterator, _InIterator, const _Alloc&, std::__false_type) [with _InIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a, struct __false_type D.32369)
{
  char * D.32566;
  struct forward_iterator_tag D.32430;
  struct _Tag D.32404;
  struct _Tag * D.32567;
  struct forward_iterator_tag D.32568;
  typedef struct _Tag _Tag;

  try
    {
      D.32567 = &D.32404;
      D.32566 = std::basic_string<char>::_S_construct<char*> (__beg, __end, __a, D.32568);
      return D.32566;
    }
  finally
    {
      D.32404 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&, std::forward_iterator_tag) [with _FwdIterator = char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __beg, char * __end, const struct allocator & __a, struct forward_iterator_tag D.32409)
{
  bool retval.0;
  bool iftmp.1;
  struct allocator D.32438;
  bool cleanup.2;
  bool D.32581;
  char * D.32585;
  struct _Rep & D.32586;
  bool retval.3;
  bool iftmp.4;
  bool D.32591;
  long int D.32596;
  char * D.32597;
  void * D.32598;
  const size_type __dnew;
  struct _Rep * __r;

  cleanup.2 = 0;
  try
    {
      if (__beg == __end) goto <D.32577>; else goto <D.32575>;
      <D.32577>:
      std::allocator<char>::allocator (&D.32438);
      cleanup.2 = 1;
      D.32581 = std::operator==<char> (__a, &D.32438);
      if (D.32581 != 0) goto <D.32582>; else goto <D.32575>;
      <D.32582>:
      iftmp.1 = 1;
      goto <D.32576>;
      <D.32575>:
      iftmp.1 = 0;
      <D.32576>:
      retval.0 = iftmp.1;
    }
  finally
    {
      if (cleanup.2 != 0) goto <D.32579>; else goto <D.32580>;
      <D.32579>:
      std::allocator<char>::~allocator (&D.32438);
      D.32438 = {CLOBBER};
      <D.32580>:
    }
  if (retval.0 != 0) goto <D.32583>; else goto <D.32584>;
  <D.32583>:
  D.32586 = std::basic_string<char>::_S_empty_rep ();
  D.32585 = std::basic_string<char>::_Rep::_M_refdata (D.32586);
  return D.32585;
  <D.32584>:
  D.32591 = __gnu_cxx::__is_null_pointer<char> (__beg);
  if (D.32591 != 0) goto <D.32592>; else goto <D.32589>;
  <D.32592>:
  if (__beg != __end) goto <D.32593>; else goto <D.32589>;
  <D.32593>:
  iftmp.4 = 1;
  goto <D.32590>;
  <D.32589>:
  iftmp.4 = 0;
  <D.32590>:
  retval.3 = iftmp.4;
  if (retval.3 != 0) goto <D.32594>; else goto <D.32595>;
  <D.32594>:
  std::__throw_logic_error ("basic_string::_S_construct null not valid");
  <D.32595>:
  D.32596 = std::distance<char*> (__beg, __end);
  __dnew = (const size_type) D.32596;
  __r = std::basic_string<char>::_Rep::_S_create (__dnew, 0, __a);
  try
    {
      D.32597 = std::basic_string<char>::_Rep::_M_refdata (__r);
      std::basic_string<char>::_S_copy_chars (D.32597, __beg, __end);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.32598 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.32598);
              std::basic_string<char>::_Rep::_M_destroy (__r, __a);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  std::basic_string<char>::_Rep::_M_set_length_and_sharable (__r, __dnew);
  D.32585 = std::basic_string<char>::_Rep::_M_refdata (__r);
  return D.32585;
}


bool std::operator==(const std::allocator<_CharT>&, const std::allocator<_CharT>&) [with _Tp = char] (const struct allocator & D.32443, const struct allocator & D.32444)
{
  bool D.32606;

  D.32606 = 1;
  return D.32606;
}


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

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


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

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


bool __gnu_cxx::__is_null_pointer(_Type*) [with _Type = char] (char * __ptr)
{
  bool D.32613;

  D.32613 = __ptr == 0B;
  return D.32613;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (char * __first, char * __last)
{
  difference_type D.32615;
  struct iterator_category D.32479;
  struct random_access_iterator_tag D.32616;
  char * __first.5;

  std::__iterator_category<char*> (&__first);
  try
    {
      __first.5 = __first;
      D.32615 = std::__distance<char*> (__first.5, __last, D.32616);
      return D.32615;
    }
  finally
    {
      D.32479 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = char*; typename std::iterator_traits<_Iterator>::iterator_category = std::random_access_iterator_tag] (char * const & D.32478)
{
  struct iterator_category D.32620;

  return D.32620;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_RandomAccessIterator, _RandomAccessIterator, std::random_access_iterator_tag) [with _RandomAccessIterator = char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (char * __first, char * __last, struct random_access_iterator_tag D.32483)
{
  difference_type D.32622;
  long int __last.6;
  long int __first.7;

  __last.6 = (long int) __last;
  __first.7 = (long int) __first;
  D.32622 = __last.6 - __first.7;
  return D.32622;
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_S_copy_chars(_CharT*, _CharT*, _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __p, char * __k1, char * __k2)
{
  long int __k2.8;
  long int __k1.9;
  long int D.32628;
  long unsigned int D.32629;

  __k2.8 = (long int) __k2;
  __k1.9 = (long int) __k1;
  D.32628 = __k2.8 - __k1.9;
  D.32629 = (long unsigned int) D.32628;
  std::basic_string<char>::_M_copy (__p, __k1, D.32629);
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_M_copy(_CharT*, const _CharT*, std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (char * __d, const char * __s, size_type __n)
{
  if (__n == 1) goto <D.32630>; else goto <D.32631>;
  <D.32630>:
  std::char_traits<char>::assign (__d, __s);
  goto <D.32632>;
  <D.32631>:
  std::char_traits<char>::copy (__d, __s, __n);
  <D.32632>:
}


static void std::char_traits<char>::assign(std::char_traits<char>::char_type&, const char_type&) (char_type & __c1, const char_type & __c2)
{
  char D.32633;

  D.32633 = *__c2;
  *__c1 = D.32633;
}


static std::char_traits<char>::char_type* std::char_traits<char>::copy(std::char_traits<char>::char_type*, const char_type*, std::size_t) (char_type * __s1, const char_type * __s2, size_t __n)
{
  char_type * D.32634;

  D.32634 = __builtin_memcpy (__s1, __s2, __n);
  return D.32634;
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_length_and_sharable(std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (struct _Rep * const this, size_type __n)
{
  bool retval.10;
  struct _Rep & D.32637;
  bool D.32638;
  long int D.32639;
  long int D.32640;
  char * D.32643;
  char * D.32644;

  D.32637 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.32638 = D.32637 != this;
  D.32639 = (long int) D.32638;
  D.32640 = __builtin_expect (D.32639, 0);
  retval.10 = D.32640 != 0;
  if (retval.10 != 0) goto <D.32641>; else goto <D.32642>;
  <D.32641>:
  std::basic_string<char>::_Rep::_M_set_sharable (this);
  this->D.11865._M_length = __n;
  D.32643 = std::basic_string<char>::_Rep::_M_refdata (this);
  D.32644 = D.32643 + __n;
  std::char_traits<char>::assign (D.32644, &_S_terminal);
  goto <D.32645>;
  <D.32642>:
  <D.32645>:
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_sharable() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  this->D.11865._M_refcount = 0;
}


_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.32647;
  void * D.32648;

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


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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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


std::string Glib::Base64::decode(const string&) (const struct string & source)
{
  const char * D.32657;
  guchar * D.32658;
  struct allocator D.32203;
  char * D.32659;
  long unsigned int size.11;
  char * D.32661;
  char * D.32662;
  gsize size;
  const struct ScopedPtr buf;

  try
    {
      D.32657 = std::basic_string<char>::c_str (source);
      D.32658 = g_base64_decode (D.32657, &size);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.32658);
      try
        {
          std::allocator<char>::allocator (&D.32203);
          try
            {
              D.32659 = Glib::ScopedPtr<char>::get (&buf);
              size.11 = size;
              D.32661 = D.32659 + size.11;
              D.32662 = Glib::ScopedPtr<char>::get (&buf);
              std::basic_string<char>::basic_string<char*> (<retval>, D.32662, D.32661, &D.32203);
              return <retval>;
            }
          finally
            {
              std::allocator<char>::~allocator (&D.32203);
              D.32203 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      size = {CLOBBER};
      buf = {CLOBBER};
    }
}


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

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