Glib::Module::Module(const string&, Glib::ModuleFlags) (struct Module * const this, const struct string & file_name, ModuleFlags flags)
{
  const char * D.86632;
  struct GModule * D.86633;

  this->_vptr.Module = &MEM[(void *)&_ZTVN4Glib6ModuleE + 16B];
  D.86632 = std::basic_string<char>::c_str (file_name);
  D.86633 = g_module_open (D.86632, flags);
  this->gobject_ = D.86633;
}


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

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


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

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


Glib::Module::~Module() (struct Module * const this)
{
  struct GModule * D.86641;
  int D.86645;

  {
    this->_vptr.Module = &MEM[(void *)&_ZTVN4Glib6ModuleE + 16B];
    try
      {
        D.86641 = this->gobject_;
        if (D.86641 != 0B) goto <D.86642>; else goto <D.86643>;
        <D.86642>:
        D.86641 = this->gobject_;
        g_module_close (D.86641);
        goto <D.86644>;
        <D.86643>:
        <D.86644>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.85955>:
  D.86645 = 0;
  if (D.86645 != 0) goto <D.86646>; else goto <D.86647>;
  <D.86646>:
  operator delete (this);
  goto <D.86648>;
  <D.86647>:
  <D.86648>:
}


virtual Glib::Module::~Module() (struct Module * const this)
{
  Glib::Module::~Module (this);
  <D.85959>:
  operator delete (this);
}


Glib::Module::operator bool() const (const struct Module * const this)
{
  bool D.86651;
  struct GModule * D.86652;

  D.86652 = this->gobject_;
  D.86651 = D.86652 != 0B;
  return D.86651;
}


static bool Glib::Module::get_supported() ()
{
  bool D.86654;
  int D.86655;

  D.86655 = g_module_supported ();
  D.86654 = D.86655 != 0;
  return D.86654;
}


void Glib::Module::make_resident() (struct Module * const this)
{
  struct GModule * D.86658;

  D.86658 = Glib::Module::gobj (this);
  g_module_make_resident (D.86658);
}


GModule* Glib::Module::gobj() (struct Module * const this)
{
  struct GModule * D.86659;

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


static std::string Glib::Module::get_last_error() ()
{
  const gchar * D.86662;

  D.86662 = g_module_error ();
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.86662); [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.0;
  struct string * D.86671;

  cleanup.0 = 0;
  try
    {
      if (str != 0B) goto <D.86666>; else goto <D.86667>;
      <D.86666>:
      std::allocator<char>::allocator (&D.78923);
      cleanup.0 = 1;
      D.86671 = <retval>;
      std::basic_string<char>::basic_string (D.86671, str, &D.78923);
      goto <D.86672>;
      <D.86667>:
      D.86671 = <retval>;
      std::basic_string<char>::basic_string (D.86671);
      <D.86672>:
      return <retval>;
    }
  finally
    {
      if (cleanup.0 != 0) goto <D.86669>; else goto <D.86670>;
      <D.86669>:
      std::allocator<char>::~allocator (&D.78923);
      D.78923 = {CLOBBER};
      <D.86670>:
    }
}


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

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

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


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

  try
    {
      {

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


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.86286;
  struct _Rep & D.86680;
  char * D.86681;
  struct _Alloc_hider * D.86682;

  std::allocator<char>::allocator (&D.86286);
  try
    {
      D.86680 = std::basic_string<char>::_S_empty_rep ();
      D.86681 = std::basic_string<char>::_Rep::_M_refdata (D.86680);
      D.86682 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.86682, D.86681, &D.86286);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.86286);
      D.86286 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.86690;
  void * D.86691;

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


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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


bool Glib::Module::get_symbol(const string&, void*&) const (const struct Module * const this, const struct string & symbol_name, void * & symbol)
{
  bool D.86697;
  const char * D.86698;
  const struct GModule * D.86699;
  int D.86700;

  D.86698 = std::basic_string<char>::c_str (symbol_name);
  D.86699 = Glib::Module::gobj (this);
  D.86700 = g_module_symbol (D.86699, D.86698, symbol);
  D.86697 = D.86700 != 0;
  return D.86697;
}


const GModule* Glib::Module::gobj() const (const struct Module * const this)
{
  const struct GModule * D.86704;

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


std::string Glib::Module::get_name() const (const struct Module * const this)
{
  const struct GModule * D.86707;
  const gchar * D.86708;

  D.86707 = Glib::Module::gobj (this);
  D.86708 = g_module_name (D.86707);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.86708); [return slot optimization]
  return <retval>;
}


static std::string Glib::Module::build_path(const string&, const string&) (const struct string & directory, const struct string & module_name)
{
  const char * D.86712;
  const char * D.86713;
  gchar * D.86714;

  D.86712 = std::basic_string<char>::c_str (module_name);
  D.86713 = std::basic_string<char>::c_str (directory);
  D.86714 = g_module_build_path (D.86713, D.86712);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.86714); [return slot optimization]
  return <retval>;
}


std::string Glib::convert_return_gchar_ptr_to_stdstring(char*) (char * str)
{
  struct allocator D.78983;
  bool cleanup.1;
  struct ScopedPtr D.78981;
  bool cleanup.2;
  char * D.86728;
  struct string * D.86729;

  cleanup.1 = 0;
  try
    {
      cleanup.2 = 0;
      try
        {
          if (str != 0B) goto <D.86720>; else goto <D.86721>;
          <D.86720>:
          std::allocator<char>::allocator (&D.78983);
          cleanup.1 = 1;
          Glib::ScopedPtr<char>::ScopedPtr (&D.78981, str);
          cleanup.2 = 1;
          D.86728 = Glib::ScopedPtr<char>::get (&D.78981);
          D.86729 = <retval>;
          std::basic_string<char>::basic_string (D.86729, D.86728, &D.78983);
          goto <D.86730>;
          <D.86721>:
          D.86729 = <retval>;
          std::basic_string<char>::basic_string (D.86729);
          <D.86730>:
          return <retval>;
        }
      finally
        {
          if (cleanup.2 != 0) goto <D.86726>; else goto <D.86727>;
          <D.86726>:
          Glib::ScopedPtr<char>::~ScopedPtr (&D.78981);
          D.78981 = {CLOBBER};
          <D.86727>:
        }
    }
  finally
    {
      if (cleanup.1 != 0) goto <D.86723>; else goto <D.86724>;
      <D.86723>:
      std::allocator<char>::~allocator (&D.78983);
      D.78983 = {CLOBBER};
      <D.86724>:
    }
}


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

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


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

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