Glib::Checksum::Checksum(Glib::Checksum::ChecksumType) (struct Checksum * const this, ChecksumType type)
{
  struct GChecksum * D.86645;

  D.86645 = g_checksum_new (type);
  this->gobject_ = D.86645;
}


Glib::Checksum::operator bool() const (const struct Checksum * const this)
{
  bool D.86647;
  struct GChecksum * D.86648;

  D.86648 = this->gobject_;
  D.86647 = D.86648 != 0B;
  return D.86647;
}


static gssize Glib::Checksum::get_length(Glib::Checksum::ChecksumType) (ChecksumType checksum_type)
{
  gssize D.86650;

  D.86650 = g_checksum_type_get_length (checksum_type);
  return D.86650;
}


static std::string Glib::Checksum::compute_checksum(Glib::Checksum::ChecksumType, const string&) (ChecksumType checksum_type, const struct string & data)
{
  struct ustring D.85931;
  long unsigned int D.86654;
  long int D.86655;
  const char * D.86656;
  gchar * D.86657;

  D.86654 = std::basic_string<char>::size (data);
  D.86655 = (long int) D.86654;
  D.86656 = std::basic_string<char>::c_str (data);
  D.86657 = g_compute_checksum_for_string (checksum_type, D.86656, D.86655);
  D.85931 = Glib::convert_return_gchar_ptr_to_ustring (D.86657); [return slot optimization]
  try
    {
      *<retval> = Glib::ustring::operator std::string (&D.85931); [return slot optimization]
      return <retval>;
    }
  finally
    {
      Glib::ustring::~ustring (&D.85931);
      D.85931 = {CLOBBER};
    }
}


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.86665;
  struct _Rep * D.86666;

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


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.86669;
  char * D.86670;

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


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

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


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

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


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.0;
  char * D.86684;
  struct ustring * D.86685;

  cleanup.0 = 0;
  try
    {
      if (str != 0B) goto <D.86679>; else goto <D.86680>;
      <D.86679>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.0 = 1;
      D.86684 = Glib::ScopedPtr<char>::get (&D.78974);
      D.86685 = <retval>;
      Glib::ustring::ustring (D.86685, D.86684);
      goto <D.86686>;
      <D.86680>:
      D.86685 = <retval>;
      Glib::ustring::ustring (D.86685);
      <D.86686>:
      return <retval>;
    }
  finally
    {
      if (cleanup.0 != 0) goto <D.86682>; else goto <D.86683>;
      <D.86682>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.86683>:
    }
}


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

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


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

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


Glib::ustring::operator std::string() const (const struct ustring * const this)
{
  const struct string * D.86697;

  D.86697 = &this->string_;
  std::basic_string<char>::basic_string (<retval>, D.86697);
  return <retval>;
}


void Glib::Checksum::update(const string&) (struct Checksum * const this, const struct string & data)
{
  long unsigned int D.86699;
  long int D.86700;
  const char * D.86701;
  struct GChecksum * D.86702;

  D.86699 = std::basic_string<char>::size (data);
  D.86700 = (long int) D.86699;
  D.86701 = std::basic_string<char>::c_str (data);
  D.86702 = Glib::Checksum::gobj (this);
  g_checksum_update (D.86702, D.86701, D.86700);
}


GChecksum* Glib::Checksum::gobj() (struct Checksum * const this)
{
  struct GChecksum * D.86705;

  D.86705 = this->gobject_;
  return D.86705;
}


Glib::Checksum Glib::wrap(GChecksum*, bool) (struct GChecksum * object, bool take_copy)
{
  int D.86708;

  D.86708 = (int) take_copy;
  Glib::Checksum::Checksum (<retval>, object, D.86708);
  return <retval>;
}


Glib::Checksum::Checksum() (struct Checksum * const this)
{
  this->gobject_ = 0B;
}


Glib::Checksum::Checksum(const Glib::Checksum&) (struct Checksum * const this, const struct Checksum & src)
{
  struct GChecksum * iftmp.1;
  struct GChecksum * D.86711;

  D.86711 = src->gobject_;
  if (D.86711 != 0B) goto <D.86712>; else goto <D.86713>;
  <D.86712>:
  D.86711 = src->gobject_;
  iftmp.1 = g_checksum_copy (D.86711);
  goto <D.86714>;
  <D.86713>:
  iftmp.1 = 0B;
  <D.86714>:
  this->gobject_ = iftmp.1;
}


Glib::Checksum::Checksum(GChecksum*, bool) (struct Checksum * const this, struct GChecksum * castitem, bool make_a_copy)
{
  bool D.86716;
  struct GChecksum * D.86722;

  D.86716 = ~make_a_copy;
  if (D.86716 != 0) goto <D.86717>; else goto <D.86718>;
  <D.86717>:
  this->gobject_ = castitem;
  goto <D.86719>;
  <D.86718>:
  if (castitem != 0B) goto <D.86720>; else goto <D.86721>;
  <D.86720>:
  D.86722 = g_checksum_copy (castitem);
  this->gobject_ = D.86722;
  goto <D.86723>;
  <D.86721>:
  this->gobject_ = 0B;
  <D.86723>:
  <D.86719>:
}


Glib::Checksum& Glib::Checksum::operator=(const Glib::Checksum&) (struct Checksum * const this, const struct Checksum & src)
{
  struct GChecksum * iftmp.2;
  struct GChecksum * D.86726;
  struct GChecksum * D.86730;
  struct Checksum & D.86734;
  struct GChecksum * const new_gobject;

  D.86726 = src->gobject_;
  if (D.86726 != 0B) goto <D.86727>; else goto <D.86728>;
  <D.86727>:
  D.86726 = src->gobject_;
  iftmp.2 = g_checksum_copy (D.86726);
  goto <D.86729>;
  <D.86728>:
  iftmp.2 = 0B;
  <D.86729>:
  new_gobject = iftmp.2;
  D.86730 = this->gobject_;
  if (D.86730 != 0B) goto <D.86731>; else goto <D.86732>;
  <D.86731>:
  D.86730 = this->gobject_;
  g_checksum_free (D.86730);
  goto <D.86733>;
  <D.86732>:
  <D.86733>:
  this->gobject_ = new_gobject;
  D.86734 = this;
  return D.86734;
}


Glib::Checksum::~Checksum() (struct Checksum * const this)
{
  struct GChecksum * D.86737;

  {
    try
      {
        D.86737 = this->gobject_;
        if (D.86737 != 0B) goto <D.86738>; else goto <D.86739>;
        <D.86738>:
        D.86737 = this->gobject_;
        g_checksum_free (D.86737);
        goto <D.86740>;
        <D.86739>:
        <D.86740>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.85973>:
}


GChecksum* Glib::Checksum::gobj_copy() const (const struct Checksum * const this)
{
  struct GChecksum * D.86742;
  struct GChecksum * D.86743;

  D.86743 = this->gobject_;
  D.86742 = g_checksum_copy (D.86743);
  return D.86742;
}


void Glib::Checksum::reset() (struct Checksum * const this)
{
  struct GChecksum * D.86746;

  D.86746 = Glib::Checksum::gobj (this);
  g_checksum_reset (D.86746);
}


void Glib::Checksum::update(const guchar*, gsize) (struct Checksum * const this, const guchar * data, gsize length)
{
  long int length.3;
  struct GChecksum * D.86748;

  length.3 = (long int) length;
  D.86748 = Glib::Checksum::gobj (this);
  g_checksum_update (D.86748, data, length.3);
}


void Glib::Checksum::get_digest(guint8*, gsize*) const (const struct Checksum * const this, guint8 * buffer, gsize * digest_len)
{
  const struct GChecksum * D.86749;

  D.86749 = Glib::Checksum::gobj (this);
  g_checksum_get_digest (D.86749, buffer, digest_len);
}


const GChecksum* Glib::Checksum::gobj() const (const struct Checksum * const this)
{
  const struct GChecksum * D.86750;

  D.86750 = this->gobject_;
  return D.86750;
}


std::string Glib::Checksum::get_string() const (const struct Checksum * const this)
{
  const struct GChecksum * D.86753;
  const gchar * D.86754;

  D.86753 = Glib::Checksum::gobj (this);
  D.86754 = g_checksum_get_string (D.86753);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.86754); [return slot optimization]
  return <retval>;
}


std::string Glib::convert_const_gchar_ptr_to_stdstring(const char*) (const char * str)
{
  struct allocator D.78923;
  bool cleanup.4;
  struct string * D.86763;

  cleanup.4 = 0;
  try
    {
      if (str != 0B) goto <D.86758>; else goto <D.86759>;
      <D.86758>:
      std::allocator<char>::allocator (&D.78923);
      cleanup.4 = 1;
      D.86763 = <retval>;
      std::basic_string<char>::basic_string (D.86763, str, &D.78923);
      goto <D.86764>;
      <D.86759>:
      D.86763 = <retval>;
      std::basic_string<char>::basic_string (D.86763);
      <D.86764>:
      return <retval>;
    }
  finally
    {
      if (cleanup.4 != 0) goto <D.86761>; else goto <D.86762>;
      <D.86761>:
      std::allocator<char>::~allocator (&D.78923);
      D.78923 = {CLOBBER};
      <D.86762>:
    }
}


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

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

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


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

  try
    {
      {

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


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.86300;
  struct _Rep & D.86772;
  char * D.86773;
  struct _Alloc_hider * D.86774;

  std::allocator<char>::allocator (&D.86300);
  try
    {
      D.86772 = std::basic_string<char>::_S_empty_rep ();
      D.86773 = std::basic_string<char>::_Rep::_M_refdata (D.86772);
      D.86774 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.86774, D.86773, &D.86300);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.86300);
      D.86300 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.86782;
  void * D.86783;

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


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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


static std::string Glib::Checksum::compute_checksum(Glib::Checksum::ChecksumType, const guchar*, gsize) (ChecksumType checksum_type, const guchar * data, gsize length)
{
  gchar * D.86790;

  D.86790 = g_compute_checksum_for_data (checksum_type, data, length);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.86790); [return slot optimization]
  return <retval>;
}


std::string Glib::convert_return_gchar_ptr_to_stdstring(char*) (char * str)
{
  struct allocator D.78983;
  bool cleanup.5;
  struct ScopedPtr D.78981;
  bool cleanup.6;
  char * D.86802;
  struct string * D.86803;

  cleanup.5 = 0;
  try
    {
      cleanup.6 = 0;
      try
        {
          if (str != 0B) goto <D.86794>; else goto <D.86795>;
          <D.86794>:
          std::allocator<char>::allocator (&D.78983);
          cleanup.5 = 1;
          Glib::ScopedPtr<char>::ScopedPtr (&D.78981, str);
          cleanup.6 = 1;
          D.86802 = Glib::ScopedPtr<char>::get (&D.78981);
          D.86803 = <retval>;
          std::basic_string<char>::basic_string (D.86803, D.86802, &D.78983);
          goto <D.86804>;
          <D.86795>:
          D.86803 = <retval>;
          std::basic_string<char>::basic_string (D.86803);
          <D.86804>:
          return <retval>;
        }
      finally
        {
          if (cleanup.6 != 0) goto <D.86800>; else goto <D.86801>;
          <D.86800>:
          Glib::ScopedPtr<char>::~ScopedPtr (&D.78981);
          D.78981 = {CLOBBER};
          <D.86801>:
        }
    }
  finally
    {
      if (cleanup.5 != 0) goto <D.86797>; else goto <D.86798>;
      <D.86797>:
      std::allocator<char>::~allocator (&D.78983);
      D.78983 = {CLOBBER};
      <D.86798>:
    }
}