static Glib::RefPtr<Gio::File> Gio::File::create_for_path(const string&) (const struct string & path)
{
  const char * D.106886;
  long unsigned int D.106887;
  struct GTypeInstance * D.106888;
  struct GFile * cfile;

  D.106886 = std::basic_string<char>::c_str (path);
  cfile = g_file_new_for_path (D.106886);
  D.106887 = g_file_get_type ();
  D.106888 = g_type_check_instance_cast (cfile, D.106887);
  *<retval> = Glib::wrap (D.106888, 0); [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.106894;

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


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

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


static Glib::RefPtr<Gio::File> Gio::File::create_for_uri(const string&) (const struct string & uri)
{
  const char * D.106900;
  long unsigned int D.106901;
  struct GTypeInstance * D.106902;
  struct GFile * cfile;

  D.106900 = std::basic_string<char>::c_str (uri);
  cfile = g_file_new_for_uri (D.106900);
  D.106901 = g_file_get_type ();
  D.106902 = g_type_check_instance_cast (cfile, D.106901);
  *<retval> = Glib::wrap (D.106902, 0); [return slot optimization]
  return <retval>;
}


static Glib::RefPtr<Gio::File> Gio::File::create_for_commandline_arg(const string&) (const struct string & arg)
{
  const char * D.106909;
  long unsigned int D.106910;
  struct GTypeInstance * D.106911;
  struct GFile * cfile;

  D.106909 = std::basic_string<char>::c_str (arg);
  cfile = g_file_new_for_commandline_arg (D.106909);
  D.106910 = g_file_get_type ();
  D.106911 = g_type_check_instance_cast (cfile, D.106910);
  *<retval> = Glib::wrap (D.106911, 0); [return slot optimization]
  return <retval>;
}


static Glib::RefPtr<Gio::File> Gio::File::create_for_parse_name(const Glib::ustring&) (const struct ustring & parse_name)
{
  const char * D.106918;
  long unsigned int D.106919;
  struct GTypeInstance * D.106920;
  struct GFile * cfile;

  D.106918 = Glib::ustring::c_str (parse_name);
  cfile = g_file_parse_name (D.106918);
  D.106919 = g_file_get_type ();
  D.106920 = g_type_check_instance_cast (cfile, D.106919);
  *<retval> = Glib::wrap (D.106920, 0); [return slot optimization]
  return <retval>;
}


void Gio::File::read_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.0;
  struct GFile * D.106926;
  struct SlotAsyncReady * slot_copy;

  slot_copy.0 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.0, slot);
    }
  catch
    {
      operator delete (slot_copy.0);
    }
  slot_copy = slot_copy.0;
  D.106926 = Gio::File::gobj (this);
  g_file_read_async (D.106926, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.106930;

  D.106930 = &this->D.102172;
  sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::slot1 (D.106930, src);
  try
    {

    }
  catch
    {
      D.106930 = &this->D.102172;
      sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot1 (D.106930);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.106931;
  struct slot_base * D.106932;

  D.106931 = &src->D.102130;
  D.106932 = &this->D.102130;
  sigc::slot_base::slot_base (D.106932, D.106931);
  try
    {

    }
  catch
    {
      D.106932 = &this->D.102130;
      sigc::slot_base::~slot_base (D.106932);
    }
}


GFile* Gio::File::gobj() (struct File * const this)
{
  struct GFile * D.106933;
  int (*__vtbl_ptr_type) () * D.106934;
  int (*__vtbl_ptr_type) () * D.106935;
  long int D.106936;
  sizetype D.106937;
  struct ObjectBase * D.106938;

  D.106934 = this->D.101656._vptr.Interface;
  D.106935 = D.106934 + 18446744073709551592;
  D.106936 = MEM[(long int *)D.106935];
  D.106937 = (sizetype) D.106936;
  D.106938 = this + D.106937;
  D.106933 = D.106938->gobject_;
  return D.106933;
}


void Gio::File::read_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.1;
  struct BaseObjectType * D.106940;
  struct GFile * D.106941;
  struct SlotAsyncReady * slot_copy;

  slot_copy.1 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.1, slot);
    }
  catch
    {
      operator delete (slot_copy.1);
    }
  slot_copy = slot_copy.1;
  D.106940 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106941 = Gio::File::gobj (this);
  g_file_read_async (D.106941, io_priority, D.106940, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.106945;
  struct BaseObjectType * iftmp.2;
  bool D.106947;
  struct Cancellable * D.106950;

  D.106947 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.106947 != 0) goto <D.106948>; else goto <D.106949>;
  <D.106948>:
  D.106950 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.2 = Gio::Cancellable::gobj (D.106950);
  goto <D.106951>;
  <D.106949>:
  iftmp.2 = 0B;
  <D.106951>:
  D.106945 = iftmp.2;
  return D.106945;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Cancellable] (const struct RefPtr * const this)
{
  bool D.106953;
  struct Cancellable * D.106954;

  D.106954 = this->pCppObject_;
  D.106953 = D.106954 != 0B;
  return D.106953;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = Gio::Cancellable] (const struct RefPtr * const this)
{
  struct Cancellable * D.106956;

  D.106956 = this->pCppObject_;
  return D.106956;
}


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.106958;
  int (*__vtbl_ptr_type) () * D.106959;
  int (*__vtbl_ptr_type) () * D.106960;
  long int D.106961;
  sizetype D.106962;
  struct ObjectBase * D.106963;

  D.106959 = this->D.97300._vptr.Object;
  D.106960 = D.106959 + 18446744073709551592;
  D.106961 = MEM[(long int *)D.106960];
  D.106962 = (sizetype) D.106961;
  D.106963 = this + D.106962;
  D.106958 = D.106963->gobject_;
  return D.106958;
}


void Gio::File::append_to_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.3;
  struct BaseObjectType * D.106965;
  struct GFile * D.106966;
  struct SlotAsyncReady * slot_copy;

  slot_copy.3 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.3, slot);
    }
  catch
    {
      operator delete (slot_copy.3);
    }
  slot_copy = slot_copy.3;
  D.106965 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106966 = Gio::File::gobj (this);
  g_file_append_to_async (D.106966, flags, io_priority, D.106965, SignalProxy_async_callback, slot_copy);
}


void Gio::File::append_to_async(const SlotAsyncReady&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.4;
  struct GFile * D.106970;
  struct SlotAsyncReady * slot_copy;

  slot_copy.4 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.4, slot);
    }
  catch
    {
      operator delete (slot_copy.4);
    }
  slot_copy = slot_copy.4;
  D.106970 = Gio::File::gobj (this);
  g_file_append_to_async (D.106970, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::create_file_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.5;
  struct BaseObjectType * D.106973;
  struct GFile * D.106974;
  struct SlotAsyncReady * slot_copy;

  slot_copy.5 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.5, slot);
    }
  catch
    {
      operator delete (slot_copy.5);
    }
  slot_copy = slot_copy.5;
  D.106973 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106974 = Gio::File::gobj (this);
  g_file_create_async (D.106974, flags, io_priority, D.106973, SignalProxy_async_callback, slot_copy);
}


void Gio::File::create_file_async(const SlotAsyncReady&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.6;
  struct GFile * D.106978;
  struct SlotAsyncReady * slot_copy;

  slot_copy.6 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.6, slot);
    }
  catch
    {
      operator delete (slot_copy.6);
    }
  slot_copy = slot_copy.6;
  D.106978 = Gio::File::gobj (this);
  g_file_create_async (D.106978, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::create_file_readwrite_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.7;
  struct BaseObjectType * D.106981;
  struct GFile * D.106982;
  struct SlotAsyncReady * slot_copy;

  slot_copy.7 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.7, slot);
    }
  catch
    {
      operator delete (slot_copy.7);
    }
  slot_copy = slot_copy.7;
  D.106981 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106982 = Gio::File::gobj (this);
  g_file_create_async (D.106982, flags, io_priority, D.106981, SignalProxy_async_callback, slot_copy);
}


void Gio::File::create_file_readwrite_async(const SlotAsyncReady&, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.8;
  struct GFile * D.106986;
  struct SlotAsyncReady * slot_copy;

  slot_copy.8 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.8, slot);
    }
  catch
    {
      operator delete (slot_copy.8);
    }
  slot_copy = slot_copy.8;
  D.106986 = Gio::File::gobj (this);
  g_file_create_readwrite_async (D.106986, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, bool, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & etag, bool make_backup, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.9;
  struct BaseObjectType * D.106989;
  int D.106990;
  const char * iftmp.10;
  bool D.106992;
  struct GFile * D.106996;
  struct SlotAsyncReady * slot_copy;

  slot_copy.9 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.9, slot);
    }
  catch
    {
      operator delete (slot_copy.9);
    }
  slot_copy = slot_copy.9;
  D.106989 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106990 = (int) make_backup;
  D.106992 = std::basic_string<char>::empty (etag);
  if (D.106992 != 0) goto <D.106993>; else goto <D.106994>;
  <D.106993>:
  iftmp.10 = 0B;
  goto <D.106995>;
  <D.106994>:
  iftmp.10 = std::basic_string<char>::c_str (etag);
  <D.106995>:
  D.106996 = Gio::File::gobj (this);
  g_file_replace_async (D.106996, iftmp.10, D.106990, flags, io_priority, D.106989, SignalProxy_async_callback, slot_copy);
}


bool std::basic_string<_CharT, _Traits, _Alloc>::empty() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  bool D.107002;
  long unsigned int D.107003;

  D.107003 = std::basic_string<char>::size (this);
  D.107002 = D.107003 == 0;
  return D.107002;
}


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.107006;
  struct _Rep * D.107007;

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


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.107010;
  char * D.107011;

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


void Gio::File::replace_async(const SlotAsyncReady&, const string&, bool, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct string & etag, bool make_backup, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.11;
  int D.107014;
  const char * iftmp.12;
  bool D.107016;
  struct GFile * D.107020;
  struct SlotAsyncReady * slot_copy;

  slot_copy.11 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.11, slot);
    }
  catch
    {
      operator delete (slot_copy.11);
    }
  slot_copy = slot_copy.11;
  D.107014 = (int) make_backup;
  D.107016 = std::basic_string<char>::empty (etag);
  if (D.107016 != 0) goto <D.107017>; else goto <D.107018>;
  <D.107017>:
  iftmp.12 = 0B;
  goto <D.107019>;
  <D.107018>:
  iftmp.12 = std::basic_string<char>::c_str (etag);
  <D.107019>:
  D.107020 = Gio::File::gobj (this);
  g_file_replace_async (D.107020, iftmp.12, D.107014, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::open_readwrite_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.13;
  struct GFile * D.107025;
  struct SlotAsyncReady * slot_copy;

  slot_copy.13 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.13, slot);
    }
  catch
    {
      operator delete (slot_copy.13);
    }
  slot_copy = slot_copy.13;
  D.107025 = Gio::File::gobj (this);
  g_file_open_readwrite_async (D.107025, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::open_readwrite_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.14;
  struct BaseObjectType * D.107028;
  struct GFile * D.107029;
  struct SlotAsyncReady * slot_copy;

  slot_copy.14 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.14, slot);
    }
  catch
    {
      operator delete (slot_copy.14);
    }
  slot_copy = slot_copy.14;
  D.107028 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107029 = Gio::File::gobj (this);
  g_file_open_readwrite_async (D.107029, io_priority, D.107028, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_readwrite_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, bool, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & etag, bool make_backup, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.15;
  struct BaseObjectType * D.107033;
  int D.107034;
  const char * iftmp.16;
  bool D.107036;
  struct GFile * D.107040;
  struct SlotAsyncReady * slot_copy;

  slot_copy.15 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.15, slot);
    }
  catch
    {
      operator delete (slot_copy.15);
    }
  slot_copy = slot_copy.15;
  D.107033 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107034 = (int) make_backup;
  D.107036 = std::basic_string<char>::empty (etag);
  if (D.107036 != 0) goto <D.107037>; else goto <D.107038>;
  <D.107037>:
  iftmp.16 = 0B;
  goto <D.107039>;
  <D.107038>:
  iftmp.16 = std::basic_string<char>::c_str (etag);
  <D.107039>:
  D.107040 = Gio::File::gobj (this);
  g_file_replace_readwrite_async (D.107040, iftmp.16, D.107034, flags, io_priority, D.107033, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_readwrite_async(const SlotAsyncReady&, const string&, bool, Gio::FileCreateFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct string & etag, bool make_backup, FileCreateFlags flags, int io_priority)
{
  void * slot_copy.17;
  int D.107046;
  const char * iftmp.18;
  bool D.107048;
  struct GFile * D.107052;
  struct SlotAsyncReady * slot_copy;

  slot_copy.17 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.17, slot);
    }
  catch
    {
      operator delete (slot_copy.17);
    }
  slot_copy = slot_copy.17;
  D.107046 = (int) make_backup;
  D.107048 = std::basic_string<char>::empty (etag);
  if (D.107048 != 0) goto <D.107049>; else goto <D.107050>;
  <D.107049>:
  iftmp.18 = 0B;
  goto <D.107051>;
  <D.107050>:
  iftmp.18 = std::basic_string<char>::c_str (etag);
  <D.107051>:
  D.107052 = Gio::File::gobj (this);
  g_file_replace_readwrite_async (D.107052, iftmp.18, D.107046, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


Gio::FileType Gio::File::query_file_type(Gio::FileQueryInfoFlags) const (const struct File * const this, FileQueryInfoFlags flags)
{
  FileType D.107057;
  const struct GFile * D.107058;

  D.107058 = Gio::File::gobj (this);
  D.107057 = g_file_query_file_type (D.107058, flags, 0B);
  return D.107057;
}


const GFile* Gio::File::gobj() const (const struct File * const this)
{
  const struct GFile * D.107061;
  int (*__vtbl_ptr_type) () * D.107062;
  int (*__vtbl_ptr_type) () * D.107063;
  long int D.107064;
  sizetype D.107065;
  const struct ObjectBase * D.107066;

  D.107062 = this->D.101656._vptr.Interface;
  D.107063 = D.107062 + 18446744073709551592;
  D.107064 = MEM[(long int *)D.107063];
  D.107065 = (sizetype) D.107064;
  D.107066 = this + D.107065;
  D.107061 = D.107066->gobject_;
  return D.107061;
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_info(const Glib::RefPtr<Gio::Cancellable>&, const string&, Gio::FileQueryInfoFlags) const (const struct File * const this, const struct RefPtr & cancellable, const struct string & attributes, FileQueryInfoFlags flags)
{
  struct BaseObjectType * D.107069;
  const char * D.107070;
  const struct GFile * D.107071;
  struct GFileInfo * D.107072;
  struct GError * gerror.19;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107069 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107070 = std::basic_string<char>::c_str (attributes);
      D.107071 = Gio::File::gobj (this);
      D.107072 = g_file_query_info (D.107071, D.107070, flags, D.107069, &gerror);
      *<retval> = Glib::wrap (D.107072, 0); [return slot optimization]
      try
        {
          gerror.19 = gerror;
          if (gerror.19 != 0B) goto <D.107074>; else goto <D.107075>;
          <D.107074>:
          gerror.19 = gerror;
          Glib::Error::throw_exception (gerror.19);
          <D.107075>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileInfo] (struct RefPtr * const this)
{
  struct FileInfo * D.107083;
  int (*__vtbl_ptr_type) () * D.107086;
  int (*__vtbl_ptr_type) () * D.107087;
  long int D.107088;
  sizetype D.107089;
  struct ObjectBase * D.107090;
  int (*__vtbl_ptr_type) () * D.107091;
  int (*__vtbl_ptr_type) () * D.107092;
  int (*__vtbl_ptr_type) () D.107093;

  {
    try
      {
        D.107083 = this->pCppObject_;
        if (D.107083 != 0B) goto <D.107084>; else goto <D.107085>;
        <D.107084>:
        D.107083 = this->pCppObject_;
        D.107083 = this->pCppObject_;
        D.107086 = D.107083->D.97654._vptr.Object;
        D.107087 = D.107086 + 18446744073709551592;
        D.107088 = MEM[(long int *)D.107087];
        D.107089 = (sizetype) D.107088;
        D.107090 = D.107083 + D.107089;
        D.107083 = this->pCppObject_;
        D.107083 = this->pCppObject_;
        D.107086 = D.107083->D.97654._vptr.Object;
        D.107087 = D.107086 + 18446744073709551592;
        D.107088 = MEM[(long int *)D.107087];
        D.107089 = (sizetype) D.107088;
        D.107090 = D.107083 + D.107089;
        D.107091 = D.107090->_vptr.ObjectBase;
        D.107092 = D.107091 + 24;
        D.107093 = *D.107092;
        D.107083 = this->pCppObject_;
        D.107083 = this->pCppObject_;
        D.107086 = D.107083->D.97654._vptr.Object;
        D.107087 = D.107086 + 18446744073709551592;
        D.107088 = MEM[(long int *)D.107087];
        D.107089 = (sizetype) D.107088;
        D.107090 = D.107083 + D.107089;
        OBJ_TYPE_REF(D.107093;(const struct ObjectBase)D.107090->3) (D.107090);
        goto <D.107094>;
        <D.107085>:
        <D.107094>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106410>:
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_info(const string&, Gio::FileQueryInfoFlags) const (const struct File * const this, const struct string & attributes, FileQueryInfoFlags flags)
{
  const char * D.107097;
  const struct GFile * D.107098;
  struct GFileInfo * D.107099;
  struct GError * gerror.20;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107097 = std::basic_string<char>::c_str (attributes);
      D.107098 = Gio::File::gobj (this);
      D.107099 = g_file_query_info (D.107098, D.107097, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.107099, 0); [return slot optimization]
      try
        {
          gerror.20 = gerror;
          if (gerror.20 != 0B) goto <D.107101>; else goto <D.107102>;
          <D.107101>:
          gerror.20 = gerror;
          Glib::Error::throw_exception (gerror.20);
          <D.107102>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::query_info_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, Gio::FileQueryInfoFlags, int) const (const struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & attributes, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.21;
  struct BaseObjectType * D.107109;
  const char * D.107110;
  const struct GFile * D.107111;
  struct SlotAsyncReady * slot_copy;

  slot_copy.21 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.21, slot);
    }
  catch
    {
      operator delete (slot_copy.21);
    }
  slot_copy = slot_copy.21;
  D.107109 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107110 = std::basic_string<char>::c_str (attributes);
  D.107111 = Gio::File::gobj (this);
  g_file_query_info_async (D.107111, D.107110, flags, io_priority, D.107109, SignalProxy_async_callback, slot_copy);
}


void Gio::File::query_info_async(const SlotAsyncReady&, const string&, Gio::FileQueryInfoFlags, int) const (const struct File * const this, const struct SlotAsyncReady & slot, const struct string & attributes, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.22;
  const char * D.107116;
  const struct GFile * D.107117;
  struct SlotAsyncReady * slot_copy;

  slot_copy.22 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.22, slot);
    }
  catch
    {
      operator delete (slot_copy.22);
    }
  slot_copy = slot_copy.22;
  D.107116 = std::basic_string<char>::c_str (attributes);
  D.107117 = Gio::File::gobj (this);
  g_file_query_info_async (D.107117, D.107116, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_filesystem_info(const Glib::RefPtr<Gio::Cancellable>&, const string&) (struct File * const this, const struct RefPtr & cancellable, const struct string & attributes)
{
  struct BaseObjectType * D.107122;
  const char * D.107123;
  struct GFile * D.107124;
  struct GFileInfo * D.107125;
  struct GError * gerror.23;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107122 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107123 = std::basic_string<char>::c_str (attributes);
      D.107124 = Gio::File::gobj (this);
      D.107125 = g_file_query_filesystem_info (D.107124, D.107123, D.107122, &gerror);
      *<retval> = Glib::wrap (D.107125, 0); [return slot optimization]
      try
        {
          gerror.23 = gerror;
          if (gerror.23 != 0B) goto <D.107127>; else goto <D.107128>;
          <D.107127>:
          gerror.23 = gerror;
          Glib::Error::throw_exception (gerror.23);
          <D.107128>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_filesystem_info(const string&) (struct File * const this, const struct string & attributes)
{
  const char * D.107137;
  struct GFile * D.107138;
  struct GFileInfo * D.107139;
  struct GError * gerror.24;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107137 = std::basic_string<char>::c_str (attributes);
      D.107138 = Gio::File::gobj (this);
      D.107139 = g_file_query_filesystem_info (D.107138, D.107137, 0B, &gerror);
      *<retval> = Glib::wrap (D.107139, 0); [return slot optimization]
      try
        {
          gerror.24 = gerror;
          if (gerror.24 != 0B) goto <D.107141>; else goto <D.107142>;
          <D.107141>:
          gerror.24 = gerror;
          Glib::Error::throw_exception (gerror.24);
          <D.107142>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::query_filesystem_info_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, int) const (const struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & attributes, int io_priority)
{
  void * slot_copy.25;
  struct BaseObjectType * D.107149;
  const char * D.107150;
  const struct GFile * D.107151;
  struct SlotAsyncReady * slot_copy;

  slot_copy.25 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.25, slot);
    }
  catch
    {
      operator delete (slot_copy.25);
    }
  slot_copy = slot_copy.25;
  D.107149 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107150 = std::basic_string<char>::c_str (attributes);
  D.107151 = Gio::File::gobj (this);
  g_file_query_filesystem_info_async (D.107151, D.107150, io_priority, D.107149, SignalProxy_async_callback, slot_copy);
}


void Gio::File::query_filesystem_info_async(const SlotAsyncReady&, const string&, int) const (const struct File * const this, const struct SlotAsyncReady & slot, const struct string & attributes, int io_priority)
{
  void * slot_copy.26;
  const char * D.107156;
  const struct GFile * D.107157;
  struct SlotAsyncReady * slot_copy;

  slot_copy.26 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.26, slot);
    }
  catch
    {
      operator delete (slot_copy.26);
    }
  slot_copy = slot_copy.26;
  D.107156 = std::basic_string<char>::c_str (attributes);
  D.107157 = Gio::File::gobj (this);
  g_file_query_filesystem_info_async (D.107157, D.107156, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::FileEnumerator> Gio::File::enumerate_children(const Glib::RefPtr<Gio::Cancellable>&, const string&, Gio::FileQueryInfoFlags) (struct File * const this, const struct RefPtr & cancellable, const struct string & attributes, FileQueryInfoFlags flags)
{
  struct BaseObjectType * D.107162;
  const char * D.107163;
  struct GFile * D.107164;
  struct GFileEnumerator * D.107165;
  struct GError * gerror.27;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107162 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107163 = std::basic_string<char>::c_str (attributes);
      D.107164 = Gio::File::gobj (this);
      D.107165 = g_file_enumerate_children (D.107164, D.107163, flags, D.107162, &gerror);
      *<retval> = Glib::wrap (D.107165, 0); [return slot optimization]
      try
        {
          gerror.27 = gerror;
          if (gerror.27 != 0B) goto <D.107167>; else goto <D.107168>;
          <D.107167>:
          gerror.27 = gerror;
          Glib::Error::throw_exception (gerror.27);
          <D.107168>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileEnumerator>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileEnumerator] (struct RefPtr * const this)
{
  struct FileEnumerator * D.107176;
  int (*__vtbl_ptr_type) () * D.107179;
  int (*__vtbl_ptr_type) () * D.107180;
  long int D.107181;
  sizetype D.107182;
  struct ObjectBase * D.107183;
  int (*__vtbl_ptr_type) () * D.107184;
  int (*__vtbl_ptr_type) () * D.107185;
  int (*__vtbl_ptr_type) () D.107186;

  {
    try
      {
        D.107176 = this->pCppObject_;
        if (D.107176 != 0B) goto <D.107177>; else goto <D.107178>;
        <D.107177>:
        D.107176 = this->pCppObject_;
        D.107176 = this->pCppObject_;
        D.107179 = D.107176->D.97811._vptr.Object;
        D.107180 = D.107179 + 18446744073709551592;
        D.107181 = MEM[(long int *)D.107180];
        D.107182 = (sizetype) D.107181;
        D.107183 = D.107176 + D.107182;
        D.107176 = this->pCppObject_;
        D.107176 = this->pCppObject_;
        D.107179 = D.107176->D.97811._vptr.Object;
        D.107180 = D.107179 + 18446744073709551592;
        D.107181 = MEM[(long int *)D.107180];
        D.107182 = (sizetype) D.107181;
        D.107183 = D.107176 + D.107182;
        D.107184 = D.107183->_vptr.ObjectBase;
        D.107185 = D.107184 + 24;
        D.107186 = *D.107185;
        D.107176 = this->pCppObject_;
        D.107176 = this->pCppObject_;
        D.107179 = D.107176->D.97811._vptr.Object;
        D.107180 = D.107179 + 18446744073709551592;
        D.107181 = MEM[(long int *)D.107180];
        D.107182 = (sizetype) D.107181;
        D.107183 = D.107176 + D.107182;
        OBJ_TYPE_REF(D.107186;(const struct ObjectBase)D.107183->3) (D.107183);
        goto <D.107187>;
        <D.107178>:
        <D.107187>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106420>:
}


Glib::RefPtr<Gio::FileEnumerator> Gio::File::enumerate_children(const string&, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attributes, FileQueryInfoFlags flags)
{
  const char * D.107190;
  struct GFile * D.107191;
  struct GFileEnumerator * D.107192;
  struct GError * gerror.28;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107190 = std::basic_string<char>::c_str (attributes);
      D.107191 = Gio::File::gobj (this);
      D.107192 = g_file_enumerate_children (D.107191, D.107190, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.107192, 0); [return slot optimization]
      try
        {
          gerror.28 = gerror;
          if (gerror.28 != 0B) goto <D.107194>; else goto <D.107195>;
          <D.107194>:
          gerror.28 = gerror;
          Glib::Error::throw_exception (gerror.28);
          <D.107195>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileEnumerator>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::enumerate_children_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, Gio::FileQueryInfoFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & attributes, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.29;
  struct BaseObjectType * D.107202;
  const char * D.107203;
  struct GFile * D.107204;
  struct SlotAsyncReady * slot_copy;

  slot_copy.29 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.29, slot);
    }
  catch
    {
      operator delete (slot_copy.29);
    }
  slot_copy = slot_copy.29;
  D.107202 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107203 = std::basic_string<char>::c_str (attributes);
  D.107204 = Gio::File::gobj (this);
  g_file_enumerate_children_async (D.107204, D.107203, flags, io_priority, D.107202, SignalProxy_async_callback, slot_copy);
}


void Gio::File::enumerate_children_async(const SlotAsyncReady&, const string&, Gio::FileQueryInfoFlags, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct string & attributes, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.30;
  const char * D.107209;
  struct GFile * D.107210;
  struct SlotAsyncReady * slot_copy;

  slot_copy.30 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.30, slot);
    }
  catch
    {
      operator delete (slot_copy.30);
    }
  slot_copy = slot_copy.30;
  D.107209 = std::basic_string<char>::c_str (attributes);
  D.107210 = Gio::File::gobj (this);
  g_file_enumerate_children_async (D.107210, D.107209, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::set_display_name_async(const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct ustring & display_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.31;
  struct BaseObjectType * D.107214;
  const char * D.107215;
  struct GFile * D.107216;
  struct SlotAsyncReady * slot_copy;

  slot_copy.31 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.31, slot);
    }
  catch
    {
      operator delete (slot_copy.31);
    }
  slot_copy = slot_copy.31;
  D.107214 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107215 = Glib::ustring::c_str (display_name);
  D.107216 = Gio::File::gobj (this);
  g_file_set_display_name_async (D.107216, D.107215, io_priority, D.107214, SignalProxy_async_callback, slot_copy);
}


void Gio::File::set_display_name_async(const Glib::ustring&, const SlotAsyncReady&, int) (struct File * const this, const struct ustring & display_name, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.32;
  const char * D.107221;
  struct GFile * D.107222;
  struct SlotAsyncReady * slot_copy;

  slot_copy.32 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.32, slot);
    }
  catch
    {
      operator delete (slot_copy.32);
    }
  slot_copy = slot_copy.32;
  D.107221 = Glib::ustring::c_str (display_name);
  D.107222 = Gio::File::gobj (this);
  g_file_set_display_name_async (D.107222, D.107221, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


bool Gio::File::copy(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot, const struct RefPtr & cancellable, FileCopyFlags flags)
{
  void * slot_copy.33;
  struct BaseObjectType * D.107226;
  struct BaseObjectType * D.107227;
  struct GFile * D.107228;
  int D.107229;
  struct SlotFileProgress * slot_copy.34;
  struct GError * gerror.35;
  bool D.107237;
  struct GError * gerror;
  bool res;
  struct SlotFileProgress * slot_copy;

  try
    {
      gerror = 0B;
      slot_copy.33 = operator new (16);
      try
        {
          sigc::slot<void, long int, long int>::slot (slot_copy.33, slot);
        }
      catch
        {
          operator delete (slot_copy.33);
        }
      slot_copy = slot_copy.33;
      D.107226 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107227 = Glib::unwrap<Gio::File> (destination);
      D.107228 = Gio::File::gobj (this);
      D.107229 = g_file_copy (D.107228, D.107227, flags, D.107226, SignalProxy_file_progress_callback, slot_copy, &gerror);
      res = D.107229 != 0;
      slot_copy.34 = slot_copy;
      if (slot_copy.34 != 0B) goto <D.107231>; else goto <D.107232>;
      <D.107231>:
      sigc::slot<void, long int, long int>::~slot (slot_copy.34);
      operator delete (slot_copy.34);
      goto <D.107233>;
      <D.107232>:
      <D.107233>:
      gerror.35 = gerror;
      if (gerror.35 != 0B) goto <D.107235>; else goto <D.107236>;
      <D.107235>:
      gerror.35 = gerror;
      Glib::Error::throw_exception (gerror.35);
      <D.107236>:
      D.107237 = res;
      return D.107237;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void {anonymous}::SignalProxy_file_progress_callback(goffset, goffset, gpointer) (goffset current_num_bytes, goffset total_num_bytes, void * data)
{
  struct slot2 * D.107246;
  void * D.107247;
  struct SlotFileProgress * the_slot;

  the_slot = data;
  try
    {
      D.107246 = &the_slot->D.102011;
      sigc::slot2<void, long int, long int>::operator() (D.107246, &current_num_bytes, &total_num_bytes);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.107247 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.107247);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = void; T_arg1 = long int; T_arg2 = long int; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const long int&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const long int&] (const struct slot2 * const this, const long int & _A_a1, const long int & _A_a2)
{
  bool retval.36;
  bool iftmp.37;
  const struct slot_base * D.107255;
  bool D.107256;
  bool D.107257;
  bool D.107259;
  bool D.107260;
  struct rep_type * D.107264;
  void * (*<T605>) (void *) D.107265;

  D.107255 = &this->D.101969;
  D.107256 = sigc::slot_base::empty (D.107255);
  D.107257 = ~D.107256;
  if (D.107257 != 0) goto <D.107258>; else goto <D.107253>;
  <D.107258>:
  D.107255 = &this->D.101969;
  D.107259 = sigc::slot_base::blocked (D.107255);
  D.107260 = ~D.107259;
  if (D.107260 != 0) goto <D.107261>; else goto <D.107253>;
  <D.107261>:
  iftmp.37 = 1;
  goto <D.107254>;
  <D.107253>:
  iftmp.37 = 0;
  <D.107254>:
  retval.36 = iftmp.37;
  if (retval.36 != 0) goto <D.107262>; else goto <D.107263>;
  <D.107262>:
  D.107264 = this->D.101969.rep_;
  D.107265 = D.107264->call_;
  D.107264 = this->D.101969.rep_;
  D.107265 (D.107264, _A_a1, _A_a2);
  return;
  <D.107263>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.107267;
  bool iftmp.38;
  struct rep_type * D.107272;
  void * (*<T605>) (void *) D.107274;

  D.107272 = this->rep_;
  if (D.107272 == 0B) goto <D.107269>; else goto <D.107273>;
  <D.107273>:
  D.107272 = this->rep_;
  D.107274 = D.107272->call_;
  if (D.107274 == 0B) goto <D.107269>; else goto <D.107270>;
  <D.107269>:
  iftmp.38 = 1;
  goto <D.107271>;
  <D.107270>:
  iftmp.38 = 0;
  <D.107271>:
  D.107267 = iftmp.38;
  return D.107267;
}


bool sigc::slot_base::blocked() const (const struct slot_base * const this)
{
  bool D.107276;

  D.107276 = this->blocked_;
  return D.107276;
}


sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = long int; T_arg2 = long int] (struct slot * const this, const struct slot & src)
{
  struct slot2 * D.107278;

  D.107278 = &this->D.102011;
  sigc::slot2<void, long int, long int>::slot2 (D.107278, src);
  try
    {

    }
  catch
    {
      D.107278 = &this->D.102011;
      sigc::slot2<void, long int, long int>::~slot2 (D.107278);
    }
}


sigc::slot2<T_return, T_arg1, T_arg2>::slot2(const sigc::slot2<T_return, T_arg1, T_arg2>&) [with T_return = void; T_arg1 = long int; T_arg2 = long int] (struct slot2 * const this, const struct slot2 & src)
{
  const struct slot_base * D.107279;
  struct slot_base * D.107280;

  D.107279 = &src->D.101969;
  D.107280 = &this->D.101969;
  sigc::slot_base::slot_base (D.107280, D.107279);
  try
    {

    }
  catch
    {
      D.107280 = &this->D.101969;
      sigc::slot_base::~slot_base (D.107280);
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::File; typename T::BaseObjectType = _GFile] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.107281;
  struct BaseObjectType * iftmp.39;
  bool D.107283;
  struct File * D.107286;

  D.107283 = Glib::RefPtr<Gio::File>::operator bool (ptr);
  if (D.107283 != 0) goto <D.107284>; else goto <D.107285>;
  <D.107284>:
  D.107286 = Glib::RefPtr<Gio::File>::operator-> (ptr);
  iftmp.39 = Gio::File::gobj (D.107286);
  goto <D.107287>;
  <D.107285>:
  iftmp.39 = 0B;
  <D.107287>:
  D.107281 = iftmp.39;
  return D.107281;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::File] (const struct RefPtr * const this)
{
  bool D.107289;
  struct File * D.107290;

  D.107290 = this->pCppObject_;
  D.107289 = D.107290 != 0B;
  return D.107289;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = Gio::File] (const struct RefPtr * const this)
{
  struct File * D.107292;

  D.107292 = this->pCppObject_;
  return D.107292;
}


sigc::slot<void, long int, long int>::~slot() (struct slot * const this)
{
  struct slot2 * D.107294;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107294 = &this->D.102011;
            sigc::slot2<void, long int, long int>::~slot2 (D.107294);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102370>:
}


sigc::slot2<void, long int, long int>::~slot2() (struct slot2 * const this)
{
  struct slot_base * D.107296;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107296 = &this->D.101969;
            sigc::slot_base::~slot_base (D.107296);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102365>:
}


bool Gio::File::copy(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot, FileCopyFlags flags)
{
  void * slot_copy.40;
  struct BaseObjectType * D.107298;
  struct GFile * D.107299;
  int D.107300;
  struct SlotFileProgress * slot_copy.41;
  struct GError * gerror.42;
  bool D.107308;
  struct GError * gerror;
  bool res;
  struct SlotFileProgress * slot_copy;

  try
    {
      gerror = 0B;
      slot_copy.40 = operator new (16);
      try
        {
          sigc::slot<void, long int, long int>::slot (slot_copy.40, slot);
        }
      catch
        {
          operator delete (slot_copy.40);
        }
      slot_copy = slot_copy.40;
      D.107298 = Glib::unwrap<Gio::File> (destination);
      D.107299 = Gio::File::gobj (this);
      D.107300 = g_file_copy (D.107299, D.107298, flags, 0B, SignalProxy_file_progress_callback, slot_copy, &gerror);
      res = D.107300 != 0;
      slot_copy.41 = slot_copy;
      if (slot_copy.41 != 0B) goto <D.107302>; else goto <D.107303>;
      <D.107302>:
      sigc::slot<void, long int, long int>::~slot (slot_copy.41);
      operator delete (slot_copy.41);
      goto <D.107304>;
      <D.107303>:
      <D.107304>:
      gerror.42 = gerror;
      if (gerror.42 != 0B) goto <D.107306>; else goto <D.107307>;
      <D.107306>:
      gerror.42 = gerror;
      Glib::Error::throw_exception (gerror.42);
      <D.107307>:
      D.107308 = res;
      return D.107308;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::copy(const Glib::RefPtr<Gio::File>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, FileCopyFlags flags)
{
  struct BaseObjectType * D.107316;
  struct GFile * D.107317;
  int D.107318;
  struct GError * gerror.43;
  bool D.107322;
  struct GError * gerror;
  bool res;

  try
    {
      gerror = 0B;
      D.107316 = Glib::unwrap<Gio::File> (destination);
      D.107317 = Gio::File::gobj (this);
      D.107318 = g_file_copy (D.107317, D.107316, flags, 0B, 0B, 0B, &gerror);
      res = D.107318 != 0;
      gerror.43 = gerror;
      if (gerror.43 != 0B) goto <D.107320>; else goto <D.107321>;
      <D.107320>:
      gerror.43 = gerror;
      Glib::Error::throw_exception (gerror.43);
      <D.107321>:
      D.107322 = res;
      return D.107322;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::copy_async(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCopyFlags, int) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot_progress, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, FileCopyFlags flags, int io_priority)
{
  void * slots.44;
  void * slot_progress_copy.45;
  void * slot_ready_copy.46;
  struct BaseObjectType * D.107328;
  struct BaseObjectType * D.107329;
  struct GFile * D.107330;
  struct CopySlots * slots;
  struct SlotFileProgress * slot_progress_copy;
  struct SlotAsyncReady * slot_ready_copy;

  slots.44 = operator new (16);
  try
    {
      std::pair<sigc::slot<void, long int, long int>*, sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*>::pair (slots.44);
    }
  catch
    {
      operator delete (slots.44);
    }
  slots = slots.44;
  slot_progress_copy.45 = operator new (16);
  try
    {
      sigc::slot<void, long int, long int>::slot (slot_progress_copy.45, slot_progress);
    }
  catch
    {
      operator delete (slot_progress_copy.45);
    }
  slot_progress_copy = slot_progress_copy.45;
  slot_ready_copy.46 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.46, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.46);
    }
  slot_ready_copy = slot_ready_copy.46;
  slots->first = slot_progress_copy;
  slots->second = slot_ready_copy;
  D.107328 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107329 = Glib::unwrap<Gio::File> (destination);
  D.107330 = Gio::File::gobj (this);
  g_file_copy_async (D.107330, D.107329, flags, io_priority, D.107328, SignalProxy_file_progress_callback, slot_progress_copy, SignalProxy_file_copy_async_callback, slots);
}


void {anonymous}::SignalProxy_file_copy_async_callback(GObject*, GAsyncResult*, void*) (struct GObject * D.102013, struct GAsyncResult * res, void * data)
{
  bool retval.47;
  struct slot_base * D.107339;
  struct slot1 * D.107342;
  void * D.107344;
  struct SlotAsyncReady * the_slot.48;
  struct slot * D.107349;
  struct CopySlots * slot_pair;
  struct SlotAsyncReady * the_slot;

  slot_pair = data;
  the_slot = slot_pair->second;
  try
    {
      {
        {
          D.107339 = &the_slot->D.102172.D.102130;
          retval.47 = sigc::slot_base::operator bool (D.107339);
          if (retval.47 != 0) goto <D.107340>; else goto <D.107341>;
          <D.107340>:
          {
            struct RefPtr result;

            try
              {
                result = Glib::wrap (res, 1); [return slot optimization]
                try
                  {
                    D.107342 = &the_slot->D.102172;
                    sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::operator() (D.107342, &result);
                  }
                finally
                  {
                    Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&result);
                  }
              }
            finally
              {
                result = {CLOBBER};
              }
          }
          goto <D.107343>;
          <D.107341>:
          <D.107343>:
        }
      }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.107344 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.107344);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  the_slot.48 = the_slot;
  if (the_slot.48 != 0B) goto <D.107346>; else goto <D.107347>;
  <D.107346>:
  sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot (the_slot.48);
  operator delete (the_slot.48);
  goto <D.107348>;
  <D.107347>:
  <D.107348>:
  D.107349 = slot_pair->first;
  if (D.107349 != 0B) goto <D.107350>; else goto <D.107351>;
  <D.107350>:
  sigc::slot<void, long int, long int>::~slot (D.107349);
  operator delete (D.107349);
  goto <D.107352>;
  <D.107351>:
  <D.107352>:
  operator delete (slot_pair);
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = Glib::RefPtr<Gio::AsyncResult>&] (const struct slot1 * const this, struct RefPtr & _A_a1)
{
  bool retval.49;
  bool iftmp.50;
  const struct slot_base * D.107363;
  bool D.107364;
  bool D.107365;
  bool D.107367;
  bool D.107368;
  struct rep_type * D.107372;
  void * (*<T605>) (void *) D.107373;

  D.107363 = &this->D.102130;
  D.107364 = sigc::slot_base::empty (D.107363);
  D.107365 = ~D.107364;
  if (D.107365 != 0) goto <D.107366>; else goto <D.107361>;
  <D.107366>:
  D.107363 = &this->D.102130;
  D.107367 = sigc::slot_base::blocked (D.107363);
  D.107368 = ~D.107367;
  if (D.107368 != 0) goto <D.107369>; else goto <D.107361>;
  <D.107369>:
  iftmp.50 = 1;
  goto <D.107362>;
  <D.107361>:
  iftmp.50 = 0;
  <D.107362>:
  retval.49 = iftmp.50;
  if (retval.49 != 0) goto <D.107370>; else goto <D.107371>;
  <D.107370>:
  D.107372 = this->D.102130.rep_;
  D.107373 = D.107372->call_;
  D.107372 = this->D.102130.rep_;
  D.107373 (D.107372, _A_a1);
  return;
  <D.107371>:
  return;
}


sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot() (struct slot * const this)
{
  struct slot1 * D.107375;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107375 = &this->D.102172;
            sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot1 (D.107375);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102338>:
}


sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.107377;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107377 = &this->D.102130;
            sigc::slot_base::~slot_base (D.107377);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102333>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::AsyncResult] (struct RefPtr * const this)
{
  struct AsyncResult * D.107379;
  int (*__vtbl_ptr_type) () * D.107382;
  int (*__vtbl_ptr_type) () * D.107383;
  long int D.107384;
  sizetype D.107385;
  struct ObjectBase * D.107386;
  int (*__vtbl_ptr_type) () * D.107387;
  int (*__vtbl_ptr_type) () * D.107388;
  int (*__vtbl_ptr_type) () D.107389;

  {
    try
      {
        D.107379 = this->pCppObject_;
        if (D.107379 != 0B) goto <D.107380>; else goto <D.107381>;
        <D.107380>:
        D.107379 = this->pCppObject_;
        D.107379 = this->pCppObject_;
        D.107382 = D.107379->D.86546._vptr.Interface;
        D.107383 = D.107382 + 18446744073709551592;
        D.107384 = MEM[(long int *)D.107383];
        D.107385 = (sizetype) D.107384;
        D.107386 = D.107379 + D.107385;
        D.107379 = this->pCppObject_;
        D.107379 = this->pCppObject_;
        D.107382 = D.107379->D.86546._vptr.Interface;
        D.107383 = D.107382 + 18446744073709551592;
        D.107384 = MEM[(long int *)D.107383];
        D.107385 = (sizetype) D.107384;
        D.107386 = D.107379 + D.107385;
        D.107387 = D.107386->_vptr.ObjectBase;
        D.107388 = D.107387 + 24;
        D.107389 = *D.107388;
        D.107379 = this->pCppObject_;
        D.107379 = this->pCppObject_;
        D.107382 = D.107379->D.86546._vptr.Interface;
        D.107383 = D.107382 + 18446744073709551592;
        D.107384 = MEM[(long int *)D.107383];
        D.107385 = (sizetype) D.107384;
        D.107386 = D.107379 + D.107385;
        OBJ_TYPE_REF(D.107389;(const struct ObjectBase)D.107386->3) (D.107386);
        goto <D.107390>;
        <D.107381>:
        <D.107390>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106383>:
}


std::pair<_T1, _T2>::pair() [with _T1 = sigc::slot<void, long int, long int>*; _T2 = sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*] (struct pair * const this)
{
  this->first = 0B;
  this->second = 0B;
}


void Gio::File::copy_async(const Glib::RefPtr<Gio::File>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCopyFlags, int) (struct File * const this, const struct RefPtr & destination, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, FileCopyFlags flags, int io_priority)
{
  void * slot_ready_copy.51;
  struct BaseObjectType * D.107392;
  struct BaseObjectType * D.107393;
  struct GFile * D.107394;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.51 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.51, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.51);
    }
  slot_ready_copy = slot_ready_copy.51;
  D.107392 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107393 = Glib::unwrap<Gio::File> (destination);
  D.107394 = Gio::File::gobj (this);
  g_file_copy_async (D.107394, D.107393, flags, io_priority, D.107392, 0B, 0B, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::copy_async(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, const SlotAsyncReady&, Gio::FileCopyFlags, int) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot_progress, const struct SlotAsyncReady & slot_ready, FileCopyFlags flags, int io_priority)
{
  void * slots.52;
  void * slot_progress_copy.53;
  void * slot_ready_copy.54;
  struct BaseObjectType * D.107399;
  struct GFile * D.107400;
  struct CopySlots * slots;
  struct SlotFileProgress * slot_progress_copy;
  struct SlotAsyncReady * slot_ready_copy;

  slots.52 = operator new (16);
  try
    {
      std::pair<sigc::slot<void, long int, long int>*, sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*>::pair (slots.52);
    }
  catch
    {
      operator delete (slots.52);
    }
  slots = slots.52;
  slot_progress_copy.53 = operator new (16);
  try
    {
      sigc::slot<void, long int, long int>::slot (slot_progress_copy.53, slot_progress);
    }
  catch
    {
      operator delete (slot_progress_copy.53);
    }
  slot_progress_copy = slot_progress_copy.53;
  slot_ready_copy.54 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.54, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.54);
    }
  slot_ready_copy = slot_ready_copy.54;
  slots->first = slot_progress_copy;
  slots->second = slot_ready_copy;
  D.107399 = Glib::unwrap<Gio::File> (destination);
  D.107400 = Gio::File::gobj (this);
  g_file_copy_async (D.107400, D.107399, flags, io_priority, 0B, SignalProxy_file_progress_callback, slot_progress_copy, SignalProxy_file_copy_async_callback, slots);
}


void Gio::File::copy_async(const Glib::RefPtr<Gio::File>&, const SlotAsyncReady&, Gio::FileCopyFlags, int) (struct File * const this, const struct RefPtr & destination, const struct SlotAsyncReady & slot_ready, FileCopyFlags flags, int io_priority)
{
  void * slot_ready_copy.55;
  struct BaseObjectType * D.107407;
  struct GFile * D.107408;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.55 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.55, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.55);
    }
  slot_ready_copy = slot_ready_copy.55;
  D.107407 = Glib::unwrap<Gio::File> (destination);
  D.107408 = Gio::File::gobj (this);
  g_file_copy_async (D.107408, D.107407, flags, io_priority, 0B, 0B, 0B, SignalProxy_async_callback, slot_ready_copy);
}


bool Gio::File::move(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot, const struct RefPtr & cancellable, FileCopyFlags flags)
{
  void * slot_copy.56;
  struct BaseObjectType * D.107412;
  struct BaseObjectType * D.107413;
  struct GFile * D.107414;
  int D.107415;
  struct SlotFileProgress * slot_copy.57;
  struct GError * gerror.58;
  bool D.107423;
  struct GError * gerror;
  bool res;
  struct SlotFileProgress * slot_copy;

  try
    {
      gerror = 0B;
      slot_copy.56 = operator new (16);
      try
        {
          sigc::slot<void, long int, long int>::slot (slot_copy.56, slot);
        }
      catch
        {
          operator delete (slot_copy.56);
        }
      slot_copy = slot_copy.56;
      D.107412 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107413 = Glib::unwrap<Gio::File> (destination);
      D.107414 = Gio::File::gobj (this);
      D.107415 = g_file_move (D.107414, D.107413, flags, D.107412, SignalProxy_file_progress_callback, slot_copy, &gerror);
      res = D.107415 != 0;
      slot_copy.57 = slot_copy;
      if (slot_copy.57 != 0B) goto <D.107417>; else goto <D.107418>;
      <D.107417>:
      sigc::slot<void, long int, long int>::~slot (slot_copy.57);
      operator delete (slot_copy.57);
      goto <D.107419>;
      <D.107418>:
      <D.107419>:
      gerror.58 = gerror;
      if (gerror.58 != 0B) goto <D.107421>; else goto <D.107422>;
      <D.107421>:
      gerror.58 = gerror;
      Glib::Error::throw_exception (gerror.58);
      <D.107422>:
      D.107423 = res;
      return D.107423;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::move(const Glib::RefPtr<Gio::File>&, const SlotFileProgress&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, const struct SlotFileProgress & slot, FileCopyFlags flags)
{
  void * slot_copy.59;
  struct BaseObjectType * D.107432;
  struct GFile * D.107433;
  int D.107434;
  struct SlotFileProgress * slot_copy.60;
  struct GError * gerror.61;
  bool D.107442;
  struct GError * gerror;
  bool res;
  struct SlotFileProgress * slot_copy;

  try
    {
      gerror = 0B;
      slot_copy.59 = operator new (16);
      try
        {
          sigc::slot<void, long int, long int>::slot (slot_copy.59, slot);
        }
      catch
        {
          operator delete (slot_copy.59);
        }
      slot_copy = slot_copy.59;
      D.107432 = Glib::unwrap<Gio::File> (destination);
      D.107433 = Gio::File::gobj (this);
      D.107434 = g_file_move (D.107433, D.107432, flags, 0B, SignalProxy_file_progress_callback, slot_copy, &gerror);
      res = D.107434 != 0;
      slot_copy.60 = slot_copy;
      if (slot_copy.60 != 0B) goto <D.107436>; else goto <D.107437>;
      <D.107436>:
      sigc::slot<void, long int, long int>::~slot (slot_copy.60);
      operator delete (slot_copy.60);
      goto <D.107438>;
      <D.107437>:
      <D.107438>:
      gerror.61 = gerror;
      if (gerror.61 != 0B) goto <D.107440>; else goto <D.107441>;
      <D.107440>:
      gerror.61 = gerror;
      Glib::Error::throw_exception (gerror.61);
      <D.107441>:
      D.107442 = res;
      return D.107442;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::move(const Glib::RefPtr<Gio::File>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, FileCopyFlags flags)
{
  struct BaseObjectType * D.107450;
  struct GFile * D.107451;
  int D.107452;
  struct GError * gerror.62;
  bool D.107456;
  struct GError * gerror;
  bool res;

  try
    {
      gerror = 0B;
      D.107450 = Glib::unwrap<Gio::File> (destination);
      D.107451 = Gio::File::gobj (this);
      D.107452 = g_file_move (D.107451, D.107450, flags, 0B, 0B, 0B, &gerror);
      res = D.107452 != 0;
      gerror.62 = gerror;
      if (gerror.62 != 0B) goto <D.107454>; else goto <D.107455>;
      <D.107454>:
      gerror.62 = gerror;
      Glib::Error::throw_exception (gerror.62);
      <D.107455>:
      D.107456 = res;
      return D.107456;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::set_attributes_async(const Glib::RefPtr<Gio::FileInfo>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileQueryInfoFlags, int) (struct File * const this, const struct RefPtr & info, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.63;
  struct BaseObjectType * D.107462;
  struct BaseObjectType * D.107463;
  struct GFile * D.107464;
  struct SlotAsyncReady * slot_copy;

  slot_copy.63 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.63, slot);
    }
  catch
    {
      operator delete (slot_copy.63);
    }
  slot_copy = slot_copy.63;
  D.107462 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107463 = Glib::unwrap<Gio::FileInfo> (info);
  D.107464 = Gio::File::gobj (this);
  g_file_set_attributes_async (D.107464, D.107463, flags, io_priority, D.107462, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::FileInfo; typename T::BaseObjectType = _GFileInfo] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.107469;
  struct BaseObjectType * iftmp.64;
  bool D.107471;
  struct FileInfo * D.107474;

  D.107471 = Glib::RefPtr<Gio::FileInfo>::operator bool (ptr);
  if (D.107471 != 0) goto <D.107472>; else goto <D.107473>;
  <D.107472>:
  D.107474 = Glib::RefPtr<Gio::FileInfo>::operator-> (ptr);
  iftmp.64 = Gio::FileInfo::gobj (D.107474);
  goto <D.107475>;
  <D.107473>:
  iftmp.64 = 0B;
  <D.107475>:
  D.107469 = iftmp.64;
  return D.107469;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::FileInfo] (const struct RefPtr * const this)
{
  bool D.107477;
  struct FileInfo * D.107478;

  D.107478 = this->pCppObject_;
  D.107477 = D.107478 != 0B;
  return D.107477;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = Gio::FileInfo] (const struct RefPtr * const this)
{
  struct FileInfo * D.107480;

  D.107480 = this->pCppObject_;
  return D.107480;
}


GFileInfo* Gio::FileInfo::gobj() (struct FileInfo * const this)
{
  struct GFileInfo * D.107482;
  int (*__vtbl_ptr_type) () * D.107483;
  int (*__vtbl_ptr_type) () * D.107484;
  long int D.107485;
  sizetype D.107486;
  struct ObjectBase * D.107487;

  D.107483 = this->D.97654._vptr.Object;
  D.107484 = D.107483 + 18446744073709551592;
  D.107485 = MEM[(long int *)D.107484];
  D.107486 = (sizetype) D.107485;
  D.107487 = this + D.107486;
  D.107482 = D.107487->gobject_;
  return D.107482;
}


void Gio::File::set_attributes_async(const Glib::RefPtr<Gio::FileInfo>&, const SlotAsyncReady&, Gio::FileQueryInfoFlags, int) (struct File * const this, const struct RefPtr & info, const struct SlotAsyncReady & slot, FileQueryInfoFlags flags, int io_priority)
{
  void * slot_copy.65;
  struct BaseObjectType * D.107489;
  struct GFile * D.107490;
  struct SlotAsyncReady * slot_copy;

  slot_copy.65 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.65, slot);
    }
  catch
    {
      operator delete (slot_copy.65);
    }
  slot_copy = slot_copy.65;
  D.107489 = Glib::unwrap<Gio::FileInfo> (info);
  D.107490 = Gio::File::gobj (this);
  g_file_set_attributes_async (D.107490, D.107489, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


bool Gio::File::set_attributes_finish(const Glib::RefPtr<Gio::AsyncResult>&, const Glib::RefPtr<Gio::FileInfo>&) (struct File * const this, const struct RefPtr & result, const struct RefPtr & info)
{
  struct BaseObjectType * cinfo.66;
  struct BaseObjectType * D.107495;
  struct GFile * D.107496;
  int D.107497;
  struct GError * gerror.67;
  bool D.107501;
  struct GError * gerror;
  struct GFileInfo * cinfo;
  bool res;

  try
    {
      gerror = 0B;
      cinfo.66 = Glib::unwrap<Gio::FileInfo> (info);
      cinfo = cinfo.66;
      D.107495 = Glib::unwrap<Gio::AsyncResult> (result);
      D.107496 = Gio::File::gobj (this);
      D.107497 = g_file_set_attributes_finish (D.107496, D.107495, &cinfo, &gerror);
      res = D.107497 != 0;
      gerror.67 = gerror;
      if (gerror.67 != 0B) goto <D.107499>; else goto <D.107500>;
      <D.107499>:
      gerror.67 = gerror;
      Glib::Error::throw_exception (gerror.67);
      <D.107500>:
      D.107501 = res;
      return D.107501;
    }
  finally
    {
      gerror = {CLOBBER};
      cinfo = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::AsyncResult; typename T::BaseObjectType = _GAsyncResult] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.107508;
  struct BaseObjectType * iftmp.68;
  bool D.107510;
  struct AsyncResult * D.107513;

  D.107510 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.107510 != 0) goto <D.107511>; else goto <D.107512>;
  <D.107511>:
  D.107513 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.68 = Gio::AsyncResult::gobj (D.107513);
  goto <D.107514>;
  <D.107512>:
  iftmp.68 = 0B;
  <D.107514>:
  D.107508 = iftmp.68;
  return D.107508;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::AsyncResult] (const struct RefPtr * const this)
{
  bool D.107516;
  struct AsyncResult * D.107517;

  D.107517 = this->pCppObject_;
  D.107516 = D.107517 != 0B;
  return D.107516;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = Gio::AsyncResult] (const struct RefPtr * const this)
{
  struct AsyncResult * D.107519;

  D.107519 = this->pCppObject_;
  return D.107519;
}


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.107521;
  int (*__vtbl_ptr_type) () * D.107522;
  int (*__vtbl_ptr_type) () * D.107523;
  long int D.107524;
  sizetype D.107525;
  struct ObjectBase * D.107526;

  D.107522 = this->D.86546._vptr.Interface;
  D.107523 = D.107522 + 18446744073709551592;
  D.107524 = MEM[(long int *)D.107523];
  D.107525 = (sizetype) D.107524;
  D.107526 = this + D.107525;
  D.107521 = D.107526->gobject_;
  return D.107521;
}


void Gio::File::mount_mountable(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountMountFlags) (struct File * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountMountFlags flags)
{
  void * slot_copy.69;
  struct BaseObjectType * D.107528;
  struct BaseObjectType * D.107529;
  struct GFile * D.107530;
  struct SlotAsyncReady * slot_copy;

  slot_copy.69 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.69, slot);
    }
  catch
    {
      operator delete (slot_copy.69);
    }
  slot_copy = slot_copy.69;
  D.107528 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107529 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107530 = Gio::File::gobj (this);
  g_file_mount_mountable (D.107530, flags, D.107529, D.107528, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::MountOperation; typename T::BaseObjectType = _GMountOperation] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.107535;
  struct BaseObjectType * iftmp.70;
  bool D.107537;
  struct MountOperation * D.107540;

  D.107537 = Glib::RefPtr<Gio::MountOperation>::operator bool (ptr);
  if (D.107537 != 0) goto <D.107538>; else goto <D.107539>;
  <D.107538>:
  D.107540 = Glib::RefPtr<Gio::MountOperation>::operator-> (ptr);
  iftmp.70 = Gio::MountOperation::gobj (D.107540);
  goto <D.107541>;
  <D.107539>:
  iftmp.70 = 0B;
  <D.107541>:
  D.107535 = iftmp.70;
  return D.107535;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::MountOperation] (const struct RefPtr * const this)
{
  bool D.107543;
  struct MountOperation * D.107544;

  D.107544 = this->pCppObject_;
  D.107543 = D.107544 != 0B;
  return D.107543;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = Gio::MountOperation] (const struct RefPtr * const this)
{
  struct MountOperation * D.107546;

  D.107546 = this->pCppObject_;
  return D.107546;
}


GMountOperation* Gio::MountOperation::gobj() (struct MountOperation * const this)
{
  struct GMountOperation * D.107548;
  int (*__vtbl_ptr_type) () * D.107549;
  int (*__vtbl_ptr_type) () * D.107550;
  long int D.107551;
  sizetype D.107552;
  struct ObjectBase * D.107553;

  D.107549 = this->D.99371._vptr.Object;
  D.107550 = D.107549 + 18446744073709551592;
  D.107551 = MEM[(long int *)D.107550];
  D.107552 = (sizetype) D.107551;
  D.107553 = this + D.107552;
  D.107548 = D.107553->gobject_;
  return D.107548;
}


void Gio::File::mount_mountable(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, Gio::MountMountFlags) (struct File * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, MountMountFlags flags)
{
  void * slot_copy.71;
  struct BaseObjectType * D.107555;
  struct GFile * D.107556;
  struct SlotAsyncReady * slot_copy;

  slot_copy.71 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.71, slot);
    }
  catch
    {
      operator delete (slot_copy.71);
    }
  slot_copy = slot_copy.71;
  D.107555 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107556 = Gio::File::gobj (this);
  g_file_mount_mountable (D.107556, flags, D.107555, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::mount_mountable(const SlotAsyncReady&, Gio::MountMountFlags) (struct File * const this, const struct SlotAsyncReady & slot, MountMountFlags flags)
{
  void * slot_copy.72;
  struct GFile * D.107560;
  struct SlotAsyncReady * slot_copy;

  slot_copy.72 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.72, slot);
    }
  catch
    {
      operator delete (slot_copy.72);
    }
  slot_copy = slot_copy.72;
  D.107560 = Gio::File::gobj (this);
  g_file_mount_mountable (D.107560, flags, 0B, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::mount_mountable(Gio::MountMountFlags) (struct File * const this, MountMountFlags flags)
{
  struct GFile * D.107563;

  D.107563 = Gio::File::gobj (this);
  g_file_mount_mountable (D.107563, flags, 0B, 0B, 0B, 0B);
}


void Gio::File::unmount_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountUnmountFlags flags)
{
  void * slot_copy.73;
  struct BaseObjectType * D.107564;
  struct GFile * D.107565;
  struct SlotAsyncReady * slot_copy;

  slot_copy.73 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.73, slot);
    }
  catch
    {
      operator delete (slot_copy.73);
    }
  slot_copy = slot_copy.73;
  D.107564 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107565 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107565, flags, 0B, D.107564, SignalProxy_async_callback, slot_copy);
}


void Gio::File::unmount_mountable(const SlotAsyncReady&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, MountUnmountFlags flags)
{
  void * slot_copy.74;
  struct GFile * D.107569;
  struct SlotAsyncReady * slot_copy;

  slot_copy.74 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.74, slot);
    }
  catch
    {
      operator delete (slot_copy.74);
    }
  slot_copy = slot_copy.74;
  D.107569 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107569, flags, 0B, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::unmount_mountable(Gio::MountUnmountFlags) (struct File * const this, MountUnmountFlags flags)
{
  struct GFile * D.107572;

  D.107572 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107572, flags, 0B, 0B, 0B, 0B);
}


void Gio::File::unmount_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  void * slot_copy.75;
  struct BaseObjectType * D.107573;
  struct BaseObjectType * D.107574;
  struct GFile * D.107575;
  struct SlotAsyncReady * slot_copy;

  slot_copy.75 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.75, slot);
    }
  catch
    {
      operator delete (slot_copy.75);
    }
  slot_copy = slot_copy.75;
  D.107573 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107574 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107575 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107575, flags, D.107574, D.107573, SignalProxy_async_callback, slot_copy);
}


void Gio::File::unmount_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  void * slot_copy.76;
  struct BaseObjectType * D.107580;
  struct GFile * D.107581;
  struct SlotAsyncReady * slot_copy;

  slot_copy.76 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.76, slot);
    }
  catch
    {
      operator delete (slot_copy.76);
    }
  slot_copy = slot_copy.76;
  D.107580 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107581 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107581, flags, D.107580, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::unmount_mountable(const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  struct BaseObjectType * D.107585;
  struct GFile * D.107586;

  D.107585 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107586 = Gio::File::gobj (this);
  g_file_unmount_mountable_with_operation (D.107586, flags, D.107585, 0B, 0B, 0B);
}


void Gio::File::mount_enclosing_volume(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountMountFlags) (struct File * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountMountFlags flags)
{
  void * slot_copy.77;
  struct BaseObjectType * D.107588;
  struct BaseObjectType * D.107589;
  struct GFile * D.107590;
  struct SlotAsyncReady * slot_copy;

  slot_copy.77 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.77, slot);
    }
  catch
    {
      operator delete (slot_copy.77);
    }
  slot_copy = slot_copy.77;
  D.107588 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107589 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107590 = Gio::File::gobj (this);
  g_file_mount_enclosing_volume (D.107590, flags, D.107589, D.107588, SignalProxy_async_callback, slot_copy);
}


void Gio::File::mount_enclosing_volume(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, Gio::MountMountFlags) (struct File * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, MountMountFlags flags)
{
  void * slot_copy.78;
  struct BaseObjectType * D.107595;
  struct GFile * D.107596;
  struct SlotAsyncReady * slot_copy;

  slot_copy.78 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.78, slot);
    }
  catch
    {
      operator delete (slot_copy.78);
    }
  slot_copy = slot_copy.78;
  D.107595 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107596 = Gio::File::gobj (this);
  g_file_mount_enclosing_volume (D.107596, flags, D.107595, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::mount_enclosing_volume(const SlotAsyncReady&, Gio::MountMountFlags) (struct File * const this, const struct SlotAsyncReady & slot, MountMountFlags flags)
{
  void * slot_copy.79;
  struct GFile * D.107600;
  struct SlotAsyncReady * slot_copy;

  slot_copy.79 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.79, slot);
    }
  catch
    {
      operator delete (slot_copy.79);
    }
  slot_copy = slot_copy.79;
  D.107600 = Gio::File::gobj (this);
  g_file_mount_enclosing_volume (D.107600, flags, 0B, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::mount_enclosing_volume(Gio::MountMountFlags) (struct File * const this, MountMountFlags flags)
{
  struct GFile * D.107603;

  D.107603 = Gio::File::gobj (this);
  g_file_mount_enclosing_volume (D.107603, flags, 0B, 0B, 0B, 0B);
}


void Gio::File::eject_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  void * slot_copy.80;
  struct BaseObjectType * D.107604;
  struct BaseObjectType * D.107605;
  struct GFile * D.107606;
  struct SlotAsyncReady * slot_copy;

  slot_copy.80 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.80, slot);
    }
  catch
    {
      operator delete (slot_copy.80);
    }
  slot_copy = slot_copy.80;
  D.107604 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107605 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107606 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107606, flags, D.107605, D.107604, SignalProxy_async_callback, slot_copy);
}


void Gio::File::eject_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  void * slot_copy.81;
  struct BaseObjectType * D.107611;
  struct GFile * D.107612;
  struct SlotAsyncReady * slot_copy;

  slot_copy.81 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.81, slot);
    }
  catch
    {
      operator delete (slot_copy.81);
    }
  slot_copy = slot_copy.81;
  D.107611 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107612 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107612, flags, D.107611, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::eject_mountable(const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  struct BaseObjectType * D.107616;
  struct GFile * D.107617;

  D.107616 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.107617 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107617, flags, D.107616, 0B, 0B, 0B);
}


void Gio::File::eject_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountUnmountFlags flags)
{
  void * slot_copy.82;
  struct BaseObjectType * D.107619;
  struct GFile * D.107620;
  struct SlotAsyncReady * slot_copy;

  slot_copy.82 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.82, slot);
    }
  catch
    {
      operator delete (slot_copy.82);
    }
  slot_copy = slot_copy.82;
  D.107619 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107620 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107620, flags, 0B, D.107619, SignalProxy_async_callback, slot_copy);
}


void Gio::File::eject_mountable(const SlotAsyncReady&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, MountUnmountFlags flags)
{
  void * slot_copy.83;
  struct GFile * D.107624;
  struct SlotAsyncReady * slot_copy;

  slot_copy.83 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.83, slot);
    }
  catch
    {
      operator delete (slot_copy.83);
    }
  slot_copy = slot_copy.83;
  D.107624 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107624, flags, 0B, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::eject_mountable(Gio::MountUnmountFlags) (struct File * const this, MountUnmountFlags flags)
{
  struct GFile * D.107627;

  D.107627 = Gio::File::gobj (this);
  g_file_eject_mountable_with_operation (D.107627, flags, 0B, 0B, 0B, 0B);
}


void Gio::File::load_contents_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable)
{
  void * slot_copy.84;
  struct BaseObjectType * D.107628;
  struct GFile * D.107629;
  struct SlotAsyncReady * slot_copy;

  slot_copy.84 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.84, slot);
    }
  catch
    {
      operator delete (slot_copy.84);
    }
  slot_copy = slot_copy.84;
  D.107628 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107629 = Gio::File::gobj (this);
  g_file_load_contents_async (D.107629, D.107628, SignalProxy_async_callback, slot_copy);
}


void Gio::File::load_contents_async(const SlotAsyncReady&) (struct File * const this, const struct SlotAsyncReady & slot)
{
  void * slot_copy.85;
  struct GFile * D.107633;
  struct SlotAsyncReady * slot_copy;

  slot_copy.85 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.85, slot);
    }
  catch
    {
      operator delete (slot_copy.85);
    }
  slot_copy = slot_copy.85;
  D.107633 = Gio::File::gobj (this);
  g_file_load_contents_async (D.107633, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::load_partial_contents_async(const SlotReadMore&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct SlotReadMore & slot_read_more, const struct SlotAsyncReady & slot_async_ready, const struct RefPtr & cancellable)
{
  void * slots.86;
  void * slot_read_more_copy.87;
  void * slot_async_copy.88;
  struct BaseObjectType * D.107636;
  struct GFile * D.107637;
  struct LoadPartialSlots * slots;
  struct SlotReadMore * slot_read_more_copy;
  struct SlotAsyncReady * slot_async_copy;

  slots.86 = operator new (16);
  try
    {
      std::pair<sigc::slot<bool, const char*, long int>*, sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*>::pair (slots.86);
    }
  catch
    {
      operator delete (slots.86);
    }
  slots = slots.86;
  slot_read_more_copy.87 = operator new (16);
  try
    {
      sigc::slot<bool, const char*, long int>::slot (slot_read_more_copy.87, slot_read_more);
    }
  catch
    {
      operator delete (slot_read_more_copy.87);
    }
  slot_read_more_copy = slot_read_more_copy.87;
  slot_async_copy.88 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_async_copy.88, slot_async_ready);
    }
  catch
    {
      operator delete (slot_async_copy.88);
    }
  slot_async_copy = slot_async_copy.88;
  slots->first = slot_read_more_copy;
  slots->second = slot_async_copy;
  D.107636 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107637 = Gio::File::gobj (this);
  g_file_load_partial_contents_async (D.107637, D.107636, SignalProxy_load_partial_contents_read_more_callback, SignalProxy_load_partial_contents_ready_callback, slots);
}


void {anonymous}::SignalProxy_load_partial_contents_ready_callback(GObject*, GAsyncResult*, void*) (struct GObject * D.102745, struct GAsyncResult * res, void * data)
{
  struct slot1 * D.107644;
  void * D.107645;
  struct SlotAsyncReady * the_slot.89;
  struct slot * D.107650;
  struct LoadPartialSlots * slot_pair;
  struct SlotAsyncReady * the_slot;

  slot_pair = data;
  the_slot = slot_pair->second;
  try
    {
      {
        struct RefPtr result;

        try
          {
            result = Glib::wrap (res, 1); [return slot optimization]
            try
              {
                D.107644 = &the_slot->D.102172;
                sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::operator() (D.107644, &result);
              }
            finally
              {
                Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&result);
              }
          }
        finally
          {
            result = {CLOBBER};
          }
      }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.107645 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.107645);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  the_slot.89 = the_slot;
  if (the_slot.89 != 0B) goto <D.107647>; else goto <D.107648>;
  <D.107647>:
  sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot (the_slot.89);
  operator delete (the_slot.89);
  goto <D.107649>;
  <D.107648>:
  <D.107649>:
  D.107650 = slot_pair->first;
  if (D.107650 != 0B) goto <D.107651>; else goto <D.107652>;
  <D.107651>:
  sigc::slot<bool, const char*, long int>::~slot (D.107650);
  operator delete (D.107650);
  goto <D.107653>;
  <D.107652>:
  <D.107653>:
  operator delete (slot_pair);
}


sigc::slot<bool, const char*, long int>::~slot() (struct slot * const this)
{
  struct slot2 * D.107659;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107659 = &this->D.102743;
            sigc::slot2<bool, const char*, long int>::~slot2 (D.107659);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102783>:
}


sigc::slot2<bool, const char*, long int>::~slot2() (struct slot2 * const this)
{
  struct slot_base * D.107661;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.107661 = &this->D.102701;
            sigc::slot_base::~slot_base (D.107661);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102778>:
}


gboolean {anonymous}::SignalProxy_load_partial_contents_read_more_callback(const char*, goffset, gpointer) (const char * file_contents, goffset file_size, void * data)
{
  struct slot2 * D.107663;
  void * D.107664;
  gboolean D.107665;
  struct LoadPartialSlots * slot_pair;
  struct SlotReadMore * the_slot;
  bool result;

  slot_pair = data;
  the_slot = slot_pair->first;
  result = 0;
  try
    {
      D.107663 = &the_slot->D.102743;
      result = sigc::slot2<bool, const char*, long int>::operator() (D.107663, &file_contents, &file_size);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.107664 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.107664);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.107665 = (gboolean) result;
  return D.107665;
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = bool; T_arg1 = const char*; T_arg2 = long int; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const char* const&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const long int&] (const struct slot2 * const this, const char * const & _A_a1, const long int & _A_a2)
{
  bool retval.90;
  bool iftmp.91;
  const struct slot_base * D.107675;
  bool D.107676;
  bool D.107677;
  bool D.107679;
  bool D.107680;
  bool D.107684;
  struct rep_type * D.107685;
  void * (*<T605>) (void *) D.107686;

  D.107675 = &this->D.102701;
  D.107676 = sigc::slot_base::empty (D.107675);
  D.107677 = ~D.107676;
  if (D.107677 != 0) goto <D.107678>; else goto <D.107673>;
  <D.107678>:
  D.107675 = &this->D.102701;
  D.107679 = sigc::slot_base::blocked (D.107675);
  D.107680 = ~D.107679;
  if (D.107680 != 0) goto <D.107681>; else goto <D.107673>;
  <D.107681>:
  iftmp.91 = 1;
  goto <D.107674>;
  <D.107673>:
  iftmp.91 = 0;
  <D.107674>:
  retval.90 = iftmp.91;
  if (retval.90 != 0) goto <D.107682>; else goto <D.107683>;
  <D.107682>:
  D.107685 = this->D.102701.rep_;
  D.107686 = D.107685->call_;
  D.107685 = this->D.102701.rep_;
  D.107684 = D.107686 (D.107685, _A_a1, _A_a2);
  return D.107684;
  <D.107683>:
  D.107684 = 0;
  return D.107684;
}


std::pair<_T1, _T2>::pair() [with _T1 = sigc::slot<bool, const char*, long int>*; _T2 = sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*] (struct pair * const this)
{
  this->first = 0B;
  this->second = 0B;
}


sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, T_arg2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = bool; T_arg1 = const char*; T_arg2 = long int] (struct slot * const this, const struct slot & src)
{
  struct slot2 * D.107689;

  D.107689 = &this->D.102743;
  sigc::slot2<bool, const char*, long int>::slot2 (D.107689, src);
  try
    {

    }
  catch
    {
      D.107689 = &this->D.102743;
      sigc::slot2<bool, const char*, long int>::~slot2 (D.107689);
    }
}


sigc::slot2<T_return, T_arg1, T_arg2>::slot2(const sigc::slot2<T_return, T_arg1, T_arg2>&) [with T_return = bool; T_arg1 = const char*; T_arg2 = long int] (struct slot2 * const this, const struct slot2 & src)
{
  const struct slot_base * D.107690;
  struct slot_base * D.107691;

  D.107690 = &src->D.102701;
  D.107691 = &this->D.102701;
  sigc::slot_base::slot_base (D.107691, D.107690);
  try
    {

    }
  catch
    {
      D.107691 = &this->D.102701;
      sigc::slot_base::~slot_base (D.107691);
    }
}


void Gio::File::load_partial_contents_async(const SlotReadMore&, const SlotAsyncReady&) (struct File * const this, const struct SlotReadMore & slot_read_more, const struct SlotAsyncReady & slot_async_ready)
{
  void * slots.92;
  void * slot_read_more_copy.93;
  void * slot_async_copy.94;
  struct GFile * D.107692;
  struct LoadPartialSlots * slots;
  struct SlotReadMore * slot_read_more_copy;
  struct SlotAsyncReady * slot_async_copy;

  slots.92 = operator new (16);
  try
    {
      std::pair<sigc::slot<bool, const char*, long int>*, sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*>::pair (slots.92);
    }
  catch
    {
      operator delete (slots.92);
    }
  slots = slots.92;
  slot_read_more_copy.93 = operator new (16);
  try
    {
      sigc::slot<bool, const char*, long int>::slot (slot_read_more_copy.93, slot_read_more);
    }
  catch
    {
      operator delete (slot_read_more_copy.93);
    }
  slot_read_more_copy = slot_read_more_copy.93;
  slot_async_copy.94 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_async_copy.94, slot_async_ready);
    }
  catch
    {
      operator delete (slot_async_copy.94);
    }
  slot_async_copy = slot_async_copy.94;
  slots->first = slot_read_more_copy;
  slots->second = slot_async_copy;
  D.107692 = Gio::File::gobj (this);
  g_file_load_partial_contents_async (D.107692, 0B, SignalProxy_load_partial_contents_read_more_callback, SignalProxy_load_partial_contents_ready_callback, slots);
}


void Gio::File::replace_contents(const char*, gsize, const string&, std::string&, const Glib::RefPtr<Gio::Cancellable>&, bool, Gio::FileCreateFlags) (struct File * const this, const char * contents, gsize length, const struct string & etag, struct string & new_etag, const struct RefPtr & cancellable, bool make_backup, FileCreateFlags flags)
{
  struct BaseObjectType * D.107698;
  int D.107699;
  const char * iftmp.95;
  bool D.107701;
  struct GFile * D.107705;
  struct GError * gerror.96;
  gchar * c_etag_new.97;
  struct string D.103961;
  struct GError * gerror;
  gchar * c_etag_new;

  try
    {
      gerror = 0B;
      c_etag_new = 0B;
      D.107698 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107699 = (int) make_backup;
      D.107701 = std::basic_string<char>::empty (etag);
      if (D.107701 != 0) goto <D.107702>; else goto <D.107703>;
      <D.107702>:
      iftmp.95 = 0B;
      goto <D.107704>;
      <D.107703>:
      iftmp.95 = std::basic_string<char>::c_str (etag);
      <D.107704>:
      D.107705 = Gio::File::gobj (this);
      g_file_replace_contents (D.107705, contents, length, iftmp.95, D.107699, flags, &c_etag_new, D.107698, &gerror);
      gerror.96 = gerror;
      if (gerror.96 != 0B) goto <D.107707>; else goto <D.107708>;
      <D.107707>:
      gerror.96 = gerror;
      Glib::Error::throw_exception (gerror.96);
      <D.107708>:
      c_etag_new.97 = c_etag_new;
      if (c_etag_new.97 != 0B) goto <D.107710>; else goto <D.107711>;
      <D.107710>:
      c_etag_new.97 = c_etag_new;
      std::basic_string<char>::operator= (new_etag, c_etag_new.97);
      goto <D.107712>;
      <D.107711>:
      std::basic_string<char>::basic_string (&D.103961);
      try
        {
          std::basic_string<char>::operator= (new_etag, &D.103961);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.103961);
          D.103961 = {CLOBBER};
        }
      <D.107712>:
    }
  finally
    {
      gerror = {CLOBBER};
      c_etag_new = {CLOBBER};
    }
}


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

  D.107718 = std::basic_string<char>::assign (this, __s);
  return D.107718;
}


std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::assign(const _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, const char * __s)
{
  struct basic_string & D.107721;
  long unsigned int D.107722;

  D.107722 = std::char_traits<char>::length (__s);
  D.107721 = std::basic_string<char>::assign (this, __s, D.107722);
  return D.107721;
}


static std::size_t std::char_traits<char>::length(const char_type*) (const char_type * __s)
{
  size_t D.107725;

  D.107725 = __builtin_strlen (__s);
  return D.107725;
}


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.106307;
  struct _Rep & D.107727;
  char * D.107728;
  struct _Alloc_hider * D.107729;

  std::allocator<char>::allocator (&D.106307);
  try
    {
      D.107727 = std::basic_string<char>::_S_empty_rep ();
      D.107728 = std::basic_string<char>::_Rep::_M_refdata (D.107727);
      D.107729 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.107729, D.107728, &D.106307);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.106307);
      D.106307 = {CLOBBER};
    }
  try
    {

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


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

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

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


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

  try
    {
      {

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


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

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


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

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


_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.107739;
  void * D.107740;

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


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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.107746 = std::basic_string<char>::assign (this, __str);
  return D.107746;
}


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.106058;
  struct _Rep * D.107749;
  struct _Alloc_hider * D.107750;

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


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

  D.107756 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.107756);
  return <retval>;
}


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.98;
  struct _Rep & D.107759;
  bool D.107760;
  long int D.107761;
  long int D.107762;
  bool retval.99;
  _Atomic_word * D.107766;
  int D.107767;

  D.107759 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.107760 = D.107759 != this;
  D.107761 = (long int) D.107760;
  D.107762 = __builtin_expect (D.107761, 0);
  retval.98 = D.107762 != 0;
  if (retval.98 != 0) goto <D.107763>; else goto <D.107764>;
  <D.107763>:
  D.107766 = &this->D.18966._M_refcount;
  D.107767 = __gnu_cxx::__exchange_and_add_dispatch (D.107766, -1);
  retval.99 = D.107767 <= 0;
  if (retval.99 != 0) goto <D.107768>; else goto <D.107769>;
  <D.107768>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.107770>;
  <D.107769>:
  <D.107770>:
  goto <D.107771>;
  <D.107764>:
  <D.107771>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.100;
  int D.107774;
  _Atomic_word D.107777;

  D.107774 = __gthread_active_p ();
  retval.100 = D.107774 != 0;
  if (retval.100 != 0) goto <D.107775>; else goto <D.107776>;
  <D.107775>:
  D.107777 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.107777;
  <D.107776>:
  D.107777 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.107777;
}


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

  D.107780 = __gthrw___pthread_key_create != 0B;
  D.107779 = (int) D.107780;
  return D.107779;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.107782;
  unsigned int __val.101;
  unsigned int D.107784;

  __val.101 = (unsigned int) __val;
  D.107784 = __atomic_fetch_add_4 (__mem, __val.101, 4);
  D.107782 = (_Atomic_word) D.107784;
  return D.107782;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.107786;
  int D.107787;
  _Atomic_word D.107788;
  _Atomic_word __result;

  __result = *__mem;
  D.107786 = *__mem;
  D.107787 = D.107786 + __val;
  *__mem = D.107787;
  D.107788 = __result;
  return D.107788;
}


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


void Gio::File::replace_contents(const char*, gsize, const string&, std::string&, bool, Gio::FileCreateFlags) (struct File * const this, const char * contents, gsize length, const struct string & etag, struct string & new_etag, bool make_backup, FileCreateFlags flags)
{
  int D.107790;
  const char * iftmp.102;
  bool D.107792;
  struct GFile * D.107796;
  struct GError * gerror.103;
  gchar * c_etag_new.104;
  struct string D.103973;
  struct GError * gerror;
  gchar * c_etag_new;

  try
    {
      gerror = 0B;
      c_etag_new = 0B;
      D.107790 = (int) make_backup;
      D.107792 = std::basic_string<char>::empty (etag);
      if (D.107792 != 0) goto <D.107793>; else goto <D.107794>;
      <D.107793>:
      iftmp.102 = 0B;
      goto <D.107795>;
      <D.107794>:
      iftmp.102 = std::basic_string<char>::c_str (etag);
      <D.107795>:
      D.107796 = Gio::File::gobj (this);
      g_file_replace_contents (D.107796, contents, length, iftmp.102, D.107790, flags, &c_etag_new, 0B, &gerror);
      gerror.103 = gerror;
      if (gerror.103 != 0B) goto <D.107798>; else goto <D.107799>;
      <D.107798>:
      gerror.103 = gerror;
      Glib::Error::throw_exception (gerror.103);
      <D.107799>:
      c_etag_new.104 = c_etag_new;
      if (c_etag_new.104 != 0B) goto <D.107801>; else goto <D.107802>;
      <D.107801>:
      c_etag_new.104 = c_etag_new;
      std::basic_string<char>::operator= (new_etag, c_etag_new.104);
      goto <D.107803>;
      <D.107802>:
      std::basic_string<char>::basic_string (&D.103973);
      try
        {
          std::basic_string<char>::operator= (new_etag, &D.103973);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.103973);
          D.103973 = {CLOBBER};
        }
      <D.107803>:
    }
  finally
    {
      gerror = {CLOBBER};
      c_etag_new = {CLOBBER};
    }
}


void Gio::File::replace_contents(const string&, const string&, std::string&, const Glib::RefPtr<Gio::Cancellable>&, bool, Gio::FileCreateFlags) (struct File * const this, const struct string & contents, const struct string & etag, struct string & new_etag, const struct RefPtr & cancellable, bool make_backup, FileCreateFlags flags)
{
  struct BaseObjectType * D.107808;
  int D.107809;
  const char * iftmp.105;
  bool D.107811;
  long unsigned int D.107815;
  const char * D.107816;
  struct GFile * D.107817;
  struct GError * gerror.106;
  gchar * c_etag_new.107;
  struct string D.103985;
  struct GError * gerror;
  gchar * c_etag_new;

  try
    {
      gerror = 0B;
      c_etag_new = 0B;
      D.107808 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107809 = (int) make_backup;
      D.107811 = std::basic_string<char>::empty (etag);
      if (D.107811 != 0) goto <D.107812>; else goto <D.107813>;
      <D.107812>:
      iftmp.105 = 0B;
      goto <D.107814>;
      <D.107813>:
      iftmp.105 = std::basic_string<char>::c_str (etag);
      <D.107814>:
      D.107815 = std::basic_string<char>::size (contents);
      D.107816 = std::basic_string<char>::c_str (contents);
      D.107817 = Gio::File::gobj (this);
      g_file_replace_contents (D.107817, D.107816, D.107815, iftmp.105, D.107809, flags, &c_etag_new, D.107808, &gerror);
      gerror.106 = gerror;
      if (gerror.106 != 0B) goto <D.107819>; else goto <D.107820>;
      <D.107819>:
      gerror.106 = gerror;
      Glib::Error::throw_exception (gerror.106);
      <D.107820>:
      c_etag_new.107 = c_etag_new;
      if (c_etag_new.107 != 0B) goto <D.107822>; else goto <D.107823>;
      <D.107822>:
      c_etag_new.107 = c_etag_new;
      std::basic_string<char>::operator= (new_etag, c_etag_new.107);
      goto <D.107824>;
      <D.107823>:
      std::basic_string<char>::basic_string (&D.103985);
      try
        {
          std::basic_string<char>::operator= (new_etag, &D.103985);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.103985);
          D.103985 = {CLOBBER};
        }
      <D.107824>:
    }
  finally
    {
      gerror = {CLOBBER};
      c_etag_new = {CLOBBER};
    }
}


void Gio::File::replace_contents(const string&, const string&, std::string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct string & contents, const struct string & etag, struct string & new_etag, bool make_backup, FileCreateFlags flags)
{
  int D.107832;
  const char * iftmp.108;
  bool D.107834;
  long unsigned int D.107838;
  const char * D.107839;
  struct GFile * D.107840;
  struct GError * gerror.109;
  gchar * c_etag_new.110;
  struct string D.103996;
  struct GError * gerror;
  gchar * c_etag_new;

  try
    {
      gerror = 0B;
      c_etag_new = 0B;
      D.107832 = (int) make_backup;
      D.107834 = std::basic_string<char>::empty (etag);
      if (D.107834 != 0) goto <D.107835>; else goto <D.107836>;
      <D.107835>:
      iftmp.108 = 0B;
      goto <D.107837>;
      <D.107836>:
      iftmp.108 = std::basic_string<char>::c_str (etag);
      <D.107837>:
      D.107838 = std::basic_string<char>::size (contents);
      D.107839 = std::basic_string<char>::c_str (contents);
      D.107840 = Gio::File::gobj (this);
      g_file_replace_contents (D.107840, D.107839, D.107838, iftmp.108, D.107832, flags, &c_etag_new, 0B, &gerror);
      gerror.109 = gerror;
      if (gerror.109 != 0B) goto <D.107842>; else goto <D.107843>;
      <D.107842>:
      gerror.109 = gerror;
      Glib::Error::throw_exception (gerror.109);
      <D.107843>:
      c_etag_new.110 = c_etag_new;
      if (c_etag_new.110 != 0B) goto <D.107845>; else goto <D.107846>;
      <D.107845>:
      c_etag_new.110 = c_etag_new;
      std::basic_string<char>::operator= (new_etag, c_etag_new.110);
      goto <D.107847>;
      <D.107846>:
      std::basic_string<char>::basic_string (&D.103996);
      try
        {
          std::basic_string<char>::operator= (new_etag, &D.103996);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.103996);
          D.103996 = {CLOBBER};
        }
      <D.107847>:
    }
  finally
    {
      gerror = {CLOBBER};
      c_etag_new = {CLOBBER};
    }
}


void Gio::File::replace_contents_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const char*, gsize, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const char * contents, gsize length, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  void * slot_copy.111;
  struct BaseObjectType * D.107854;
  int D.107855;
  const char * iftmp.112;
  bool D.107857;
  struct GFile * D.107861;
  struct SlotAsyncReady * slot_copy;

  slot_copy.111 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.111, slot);
    }
  catch
    {
      operator delete (slot_copy.111);
    }
  slot_copy = slot_copy.111;
  D.107854 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107855 = (int) make_backup;
  D.107857 = std::basic_string<char>::empty (etag);
  if (D.107857 != 0) goto <D.107858>; else goto <D.107859>;
  <D.107858>:
  iftmp.112 = 0B;
  goto <D.107860>;
  <D.107859>:
  iftmp.112 = std::basic_string<char>::c_str (etag);
  <D.107860>:
  D.107861 = Gio::File::gobj (this);
  g_file_replace_contents_async (D.107861, contents, length, iftmp.112, D.107855, flags, D.107854, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_contents_async(const SlotAsyncReady&, const char*, gsize, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct SlotAsyncReady & slot, const char * contents, gsize length, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  void * slot_copy.113;
  int D.107867;
  const char * iftmp.114;
  bool D.107869;
  struct GFile * D.107873;
  struct SlotAsyncReady * slot_copy;

  slot_copy.113 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.113, slot);
    }
  catch
    {
      operator delete (slot_copy.113);
    }
  slot_copy = slot_copy.113;
  D.107867 = (int) make_backup;
  D.107869 = std::basic_string<char>::empty (etag);
  if (D.107869 != 0) goto <D.107870>; else goto <D.107871>;
  <D.107870>:
  iftmp.114 = 0B;
  goto <D.107872>;
  <D.107871>:
  iftmp.114 = std::basic_string<char>::c_str (etag);
  <D.107872>:
  D.107873 = Gio::File::gobj (this);
  g_file_replace_contents_async (D.107873, contents, length, iftmp.114, D.107867, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_contents_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const string&, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct string & contents, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  void * slot_copy.115;
  struct BaseObjectType * D.107878;
  int D.107879;
  const char * iftmp.116;
  bool D.107881;
  long unsigned int D.107885;
  const char * D.107886;
  struct GFile * D.107887;
  struct SlotAsyncReady * slot_copy;

  slot_copy.115 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.115, slot);
    }
  catch
    {
      operator delete (slot_copy.115);
    }
  slot_copy = slot_copy.115;
  D.107878 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107879 = (int) make_backup;
  D.107881 = std::basic_string<char>::empty (etag);
  if (D.107881 != 0) goto <D.107882>; else goto <D.107883>;
  <D.107882>:
  iftmp.116 = 0B;
  goto <D.107884>;
  <D.107883>:
  iftmp.116 = std::basic_string<char>::c_str (etag);
  <D.107884>:
  D.107885 = std::basic_string<char>::size (contents);
  D.107886 = std::basic_string<char>::c_str (contents);
  D.107887 = Gio::File::gobj (this);
  g_file_replace_contents_async (D.107887, D.107886, D.107885, iftmp.116, D.107879, flags, D.107878, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_contents_async(const SlotAsyncReady&, const string&, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct string & contents, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  void * slot_copy.117;
  int D.107895;
  const char * iftmp.118;
  bool D.107897;
  long unsigned int D.107901;
  const char * D.107902;
  struct GFile * D.107903;
  struct SlotAsyncReady * slot_copy;

  slot_copy.117 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.117, slot);
    }
  catch
    {
      operator delete (slot_copy.117);
    }
  slot_copy = slot_copy.117;
  D.107895 = (int) make_backup;
  D.107897 = std::basic_string<char>::empty (etag);
  if (D.107897 != 0) goto <D.107898>; else goto <D.107899>;
  <D.107898>:
  iftmp.118 = 0B;
  goto <D.107900>;
  <D.107899>:
  iftmp.118 = std::basic_string<char>::c_str (etag);
  <D.107900>:
  D.107901 = std::basic_string<char>::size (contents);
  D.107902 = std::basic_string<char>::c_str (contents);
  D.107903 = Gio::File::gobj (this);
  g_file_replace_contents_async (D.107903, D.107902, D.107901, iftmp.118, D.107895, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::replace_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&, std::string&) (struct File * const this, const struct RefPtr & result, struct string & new_etag)
{
  struct BaseObjectType * D.107910;
  struct GFile * D.107911;
  struct GError * gerror.119;
  gchar * c_new_etag.120;
  struct string D.104048;
  struct GError * gerror;
  gchar * c_new_etag;

  try
    {
      gerror = 0B;
      c_new_etag = 0B;
      D.107910 = Glib::unwrap<Gio::AsyncResult> (result);
      D.107911 = Gio::File::gobj (this);
      g_file_replace_contents_finish (D.107911, D.107910, &c_new_etag, &gerror);
      gerror.119 = gerror;
      if (gerror.119 != 0B) goto <D.107913>; else goto <D.107914>;
      <D.107913>:
      gerror.119 = gerror;
      Glib::Error::throw_exception (gerror.119);
      <D.107914>:
      c_new_etag.120 = c_new_etag;
      if (c_new_etag.120 != 0B) goto <D.107916>; else goto <D.107917>;
      <D.107916>:
      c_new_etag.120 = c_new_etag;
      std::basic_string<char>::operator= (new_etag, c_new_etag.120);
      goto <D.107918>;
      <D.107917>:
      std::basic_string<char>::basic_string (&D.104048);
      try
        {
          std::basic_string<char>::operator= (new_etag, &D.104048);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.104048);
          D.104048 = {CLOBBER};
        }
      <D.107918>:
    }
  finally
    {
      gerror = {CLOBBER};
      c_new_etag = {CLOBBER};
    }
}


void Gio::File::replace_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.107922;
  struct GFile * D.107923;
  struct GError * gerror.121;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.107922 = Glib::unwrap<Gio::AsyncResult> (result);
      D.107923 = Gio::File::gobj (this);
      g_file_replace_contents_finish (D.107923, D.107922, 0B, &gerror);
      gerror.121 = gerror;
      if (gerror.121 != 0B) goto <D.107925>; else goto <D.107926>;
      <D.107925>:
      gerror.121 = gerror;
      Glib::Error::throw_exception (gerror.121);
      <D.107926>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::replace(const Glib::RefPtr<Gio::Cancellable>&, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct RefPtr & cancellable, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  struct BaseObjectType * D.107930;
  int D.107931;
  const char * iftmp.122;
  bool D.107933;
  struct GFile * D.107937;
  struct GFileOutputStream * D.107938;
  struct GError * gerror.123;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107930 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107931 = (int) make_backup;
      D.107933 = std::basic_string<char>::empty (etag);
      if (D.107933 != 0) goto <D.107934>; else goto <D.107935>;
      <D.107934>:
      iftmp.122 = 0B;
      goto <D.107936>;
      <D.107935>:
      iftmp.122 = std::basic_string<char>::c_str (etag);
      <D.107936>:
      D.107937 = Gio::File::gobj (this);
      D.107938 = g_file_replace (D.107937, iftmp.122, D.107931, flags, D.107930, &gerror);
      *<retval> = Glib::wrap (D.107938, 0); [return slot optimization]
      try
        {
          gerror.123 = gerror;
          if (gerror.123 != 0B) goto <D.107940>; else goto <D.107941>;
          <D.107940>:
          gerror.123 = gerror;
          Glib::Error::throw_exception (gerror.123);
          <D.107941>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileOutputStream] (struct RefPtr * const this)
{
  struct FileOutputStream * D.107950;
  int (*__vtbl_ptr_type) () * D.107953;
  int (*__vtbl_ptr_type) () * D.107954;
  long int D.107955;
  sizetype D.107956;
  struct ObjectBase * D.107957;
  int (*__vtbl_ptr_type) () * D.107958;
  int (*__vtbl_ptr_type) () * D.107959;
  int (*__vtbl_ptr_type) () D.107960;

  {
    try
      {
        D.107950 = this->pCppObject_;
        if (D.107950 != 0B) goto <D.107951>; else goto <D.107952>;
        <D.107951>:
        D.107950 = this->pCppObject_;
        D.107950 = this->pCppObject_;
        D.107953 = D.107950->D.99109.D.98539._vptr.Object;
        D.107954 = D.107953 + 18446744073709551592;
        D.107955 = MEM[(long int *)D.107954];
        D.107956 = (sizetype) D.107955;
        D.107957 = D.107950 + D.107956;
        D.107950 = this->pCppObject_;
        D.107950 = this->pCppObject_;
        D.107953 = D.107950->D.99109.D.98539._vptr.Object;
        D.107954 = D.107953 + 18446744073709551592;
        D.107955 = MEM[(long int *)D.107954];
        D.107956 = (sizetype) D.107955;
        D.107957 = D.107950 + D.107956;
        D.107958 = D.107957->_vptr.ObjectBase;
        D.107959 = D.107958 + 24;
        D.107960 = *D.107959;
        D.107950 = this->pCppObject_;
        D.107950 = this->pCppObject_;
        D.107953 = D.107950->D.99109.D.98539._vptr.Object;
        D.107954 = D.107953 + 18446744073709551592;
        D.107955 = MEM[(long int *)D.107954];
        D.107956 = (sizetype) D.107955;
        D.107957 = D.107950 + D.107956;
        OBJ_TYPE_REF(D.107960;(const struct ObjectBase)D.107957->3) (D.107957);
        goto <D.107961>;
        <D.107952>:
        <D.107961>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106466>:
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::replace(const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  int D.107964;
  const char * iftmp.124;
  bool D.107966;
  struct GFile * D.107970;
  struct GFileOutputStream * D.107971;
  struct GError * gerror.125;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107964 = (int) make_backup;
      D.107966 = std::basic_string<char>::empty (etag);
      if (D.107966 != 0) goto <D.107967>; else goto <D.107968>;
      <D.107967>:
      iftmp.124 = 0B;
      goto <D.107969>;
      <D.107968>:
      iftmp.124 = std::basic_string<char>::c_str (etag);
      <D.107969>:
      D.107970 = Gio::File::gobj (this);
      D.107971 = g_file_replace (D.107970, iftmp.124, D.107964, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.107971, 0); [return slot optimization]
      try
        {
          gerror.125 = gerror;
          if (gerror.125 != 0B) goto <D.107973>; else goto <D.107974>;
          <D.107973>:
          gerror.125 = gerror;
          Glib::Error::throw_exception (gerror.125);
          <D.107974>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::replace_readwrite(const Glib::RefPtr<Gio::Cancellable>&, const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct RefPtr & cancellable, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  struct BaseObjectType * D.107983;
  int D.107984;
  const char * iftmp.126;
  bool D.107986;
  struct GFile * D.107990;
  struct GFileIOStream * D.107991;
  struct GError * gerror.127;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107983 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107984 = (int) make_backup;
      D.107986 = std::basic_string<char>::empty (etag);
      if (D.107986 != 0) goto <D.107987>; else goto <D.107988>;
      <D.107987>:
      iftmp.126 = 0B;
      goto <D.107989>;
      <D.107988>:
      iftmp.126 = std::basic_string<char>::c_str (etag);
      <D.107989>:
      D.107990 = Gio::File::gobj (this);
      D.107991 = g_file_replace_readwrite (D.107990, iftmp.126, D.107984, flags, D.107983, &gerror);
      *<retval> = Glib::wrap (D.107991, 0); [return slot optimization]
      try
        {
          gerror.127 = gerror;
          if (gerror.127 != 0B) goto <D.107993>; else goto <D.107994>;
          <D.107993>:
          gerror.127 = gerror;
          Glib::Error::throw_exception (gerror.127);
          <D.107994>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileIOStream] (struct RefPtr * const this)
{
  struct FileIOStream * D.108003;
  int (*__vtbl_ptr_type) () * D.108006;
  int (*__vtbl_ptr_type) () * D.108007;
  long int D.108008;
  sizetype D.108009;
  struct ObjectBase * D.108010;
  int (*__vtbl_ptr_type) () * D.108011;
  int (*__vtbl_ptr_type) () * D.108012;
  int (*__vtbl_ptr_type) () D.108013;

  {
    try
      {
        D.108003 = this->pCppObject_;
        if (D.108003 != 0B) goto <D.108004>; else goto <D.108005>;
        <D.108004>:
        D.108003 = this->pCppObject_;
        D.108003 = this->pCppObject_;
        D.108006 = D.108003->D.98836.D.98715._vptr.Object;
        D.108007 = D.108006 + 18446744073709551592;
        D.108008 = MEM[(long int *)D.108007];
        D.108009 = (sizetype) D.108008;
        D.108010 = D.108003 + D.108009;
        D.108003 = this->pCppObject_;
        D.108003 = this->pCppObject_;
        D.108006 = D.108003->D.98836.D.98715._vptr.Object;
        D.108007 = D.108006 + 18446744073709551592;
        D.108008 = MEM[(long int *)D.108007];
        D.108009 = (sizetype) D.108008;
        D.108010 = D.108003 + D.108009;
        D.108011 = D.108010->_vptr.ObjectBase;
        D.108012 = D.108011 + 24;
        D.108013 = *D.108012;
        D.108003 = this->pCppObject_;
        D.108003 = this->pCppObject_;
        D.108006 = D.108003->D.98836.D.98715._vptr.Object;
        D.108007 = D.108006 + 18446744073709551592;
        D.108008 = MEM[(long int *)D.108007];
        D.108009 = (sizetype) D.108008;
        D.108010 = D.108003 + D.108009;
        OBJ_TYPE_REF(D.108013;(const struct ObjectBase)D.108010->3) (D.108010);
        goto <D.108014>;
        <D.108005>:
        <D.108014>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106476>:
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::replace_readwrite(const string&, bool, Gio::FileCreateFlags) (struct File * const this, const struct string & etag, bool make_backup, FileCreateFlags flags)
{
  int D.108017;
  const char * iftmp.128;
  bool D.108019;
  struct GFile * D.108023;
  struct GFileIOStream * D.108024;
  struct GError * gerror.129;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108017 = (int) make_backup;
      D.108019 = std::basic_string<char>::empty (etag);
      if (D.108019 != 0) goto <D.108020>; else goto <D.108021>;
      <D.108020>:
      iftmp.128 = 0B;
      goto <D.108022>;
      <D.108021>:
      iftmp.128 = std::basic_string<char>::c_str (etag);
      <D.108022>:
      D.108023 = Gio::File::gobj (this);
      D.108024 = g_file_replace_readwrite (D.108023, iftmp.128, D.108017, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108024, 0); [return slot optimization]
      try
        {
          gerror.129 = gerror;
          if (gerror.129 != 0B) goto <D.108026>; else goto <D.108027>;
          <D.108026>:
          gerror.129 = gerror;
          Glib::Error::throw_exception (gerror.129);
          <D.108027>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor_directory(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileMonitorFlags) (struct File * const this, const struct RefPtr & cancellable, FileMonitorFlags flags)
{
  struct BaseObjectType * D.108036;
  struct GFile * D.108037;
  struct GFileMonitor * D.108038;
  struct GError * gerror.130;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108036 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108037 = Gio::File::gobj (this);
      D.108038 = g_file_monitor_directory (D.108037, flags, D.108036, &gerror);
      *<retval> = Glib::wrap (D.108038, 0); [return slot optimization]
      try
        {
          gerror.130 = gerror;
          if (gerror.130 != 0B) goto <D.108040>; else goto <D.108041>;
          <D.108040>:
          gerror.130 = gerror;
          Glib::Error::throw_exception (gerror.130);
          <D.108041>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileMonitor] (struct RefPtr * const this)
{
  struct FileMonitor * D.108048;
  int (*__vtbl_ptr_type) () * D.108051;
  int (*__vtbl_ptr_type) () * D.108052;
  long int D.108053;
  sizetype D.108054;
  struct ObjectBase * D.108055;
  int (*__vtbl_ptr_type) () * D.108056;
  int (*__vtbl_ptr_type) () * D.108057;
  int (*__vtbl_ptr_type) () D.108058;

  {
    try
      {
        D.108048 = this->pCppObject_;
        if (D.108048 != 0B) goto <D.108049>; else goto <D.108050>;
        <D.108049>:
        D.108048 = this->pCppObject_;
        D.108048 = this->pCppObject_;
        D.108051 = D.108048->D.98987._vptr.Object;
        D.108052 = D.108051 + 18446744073709551592;
        D.108053 = MEM[(long int *)D.108052];
        D.108054 = (sizetype) D.108053;
        D.108055 = D.108048 + D.108054;
        D.108048 = this->pCppObject_;
        D.108048 = this->pCppObject_;
        D.108051 = D.108048->D.98987._vptr.Object;
        D.108052 = D.108051 + 18446744073709551592;
        D.108053 = MEM[(long int *)D.108052];
        D.108054 = (sizetype) D.108053;
        D.108055 = D.108048 + D.108054;
        D.108056 = D.108055->_vptr.ObjectBase;
        D.108057 = D.108056 + 24;
        D.108058 = *D.108057;
        D.108048 = this->pCppObject_;
        D.108048 = this->pCppObject_;
        D.108051 = D.108048->D.98987._vptr.Object;
        D.108052 = D.108051 + 18446744073709551592;
        D.108053 = MEM[(long int *)D.108052];
        D.108054 = (sizetype) D.108053;
        D.108055 = D.108048 + D.108054;
        OBJ_TYPE_REF(D.108058;(const struct ObjectBase)D.108055->3) (D.108055);
        goto <D.108059>;
        <D.108050>:
        <D.108059>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106486>:
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor_directory(Gio::FileMonitorFlags) (struct File * const this, FileMonitorFlags flags)
{
  struct GFile * D.108062;
  struct GFileMonitor * D.108063;
  struct GError * gerror.131;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108062 = Gio::File::gobj (this);
      D.108063 = g_file_monitor_directory (D.108062, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108063, 0); [return slot optimization]
      try
        {
          gerror.131 = gerror;
          if (gerror.131 != 0B) goto <D.108065>; else goto <D.108066>;
          <D.108065>:
          gerror.131 = gerror;
          Glib::Error::throw_exception (gerror.131);
          <D.108066>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor_file(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileMonitorFlags) (struct File * const this, const struct RefPtr & cancellable, FileMonitorFlags flags)
{
  struct BaseObjectType * D.108073;
  struct GFile * D.108074;
  struct GFileMonitor * D.108075;
  struct GError * gerror.132;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108073 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108074 = Gio::File::gobj (this);
      D.108075 = g_file_monitor_file (D.108074, flags, D.108073, &gerror);
      *<retval> = Glib::wrap (D.108075, 0); [return slot optimization]
      try
        {
          gerror.132 = gerror;
          if (gerror.132 != 0B) goto <D.108077>; else goto <D.108078>;
          <D.108077>:
          gerror.132 = gerror;
          Glib::Error::throw_exception (gerror.132);
          <D.108078>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor_file(Gio::FileMonitorFlags) (struct File * const this, FileMonitorFlags flags)
{
  struct GFile * D.108086;
  struct GFileMonitor * D.108087;
  struct GError * gerror.133;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108086 = Gio::File::gobj (this);
      D.108087 = g_file_monitor_file (D.108086, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108087, 0); [return slot optimization]
      try
        {
          gerror.133 = gerror;
          if (gerror.133 != 0B) goto <D.108089>; else goto <D.108090>;
          <D.108089>:
          gerror.133 = gerror;
          Glib::Error::throw_exception (gerror.133);
          <D.108090>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileMonitorFlags) (struct File * const this, const struct RefPtr & cancellable, FileMonitorFlags flags)
{
  struct BaseObjectType * D.108097;
  struct GFile * D.108098;
  struct GFileMonitor * D.108099;
  struct GError * gerror.134;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108097 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108098 = Gio::File::gobj (this);
      D.108099 = g_file_monitor (D.108098, flags, D.108097, &gerror);
      *<retval> = Glib::wrap (D.108099, 0); [return slot optimization]
      try
        {
          gerror.134 = gerror;
          if (gerror.134 != 0B) goto <D.108101>; else goto <D.108102>;
          <D.108101>:
          gerror.134 = gerror;
          Glib::Error::throw_exception (gerror.134);
          <D.108102>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileMonitor> Gio::File::monitor(Gio::FileMonitorFlags) (struct File * const this, FileMonitorFlags flags)
{
  struct GFile * D.108110;
  struct GFileMonitor * D.108111;
  struct GError * gerror.135;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108110 = Gio::File::gobj (this);
      D.108111 = g_file_monitor (D.108110, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108111, 0); [return slot optimization]
      try
        {
          gerror.135 = gerror;
          if (gerror.135 != 0B) goto <D.108113>; else goto <D.108114>;
          <D.108113>:
          gerror.135 = gerror;
          Glib::Error::throw_exception (gerror.135);
          <D.108114>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileMonitor>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::File::measure_disk_usage(const Glib::RefPtr<Gio::Cancellable>&, const SlotFileMeasureProgress&, guint64&, guint64&, guint64&, Gio::FileMeasureFlags) (struct File * const this, const struct RefPtr & cancellable, const struct SlotFileMeasureProgress & slot_progress, guint64 & disk_usage, guint64 & num_dirs, guint64 & num_files, FileMeasureFlags flags)
{
  struct BaseObjectType * D.108120;
  struct GFile * D.108121;
  struct GError * gerror.136;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.108120 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108121 = Gio::File::gobj (this);
      g_file_measure_disk_usage (D.108121, flags, D.108120, SignalProxy_file_measure_progress_callback, slot_progress, disk_usage, num_dirs, num_files, &gerror);
      gerror.136 = gerror;
      if (gerror.136 != 0B) goto <D.108123>; else goto <D.108124>;
      <D.108123>:
      gerror.136 = gerror;
      Glib::Error::throw_exception (gerror.136);
      <D.108124>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void {anonymous}::SignalProxy_file_measure_progress_callback(gboolean, guint64, guint64, guint64, gpointer) (gboolean reporting, guint64 current_size, guint64 num_dirs, guint64 num_files, void * data)
{
  const bool D.102794;
  bool D.108127;
  struct slot4 * D.108128;
  void * D.108129;
  struct SlotFileMeasureProgress * the_slot;

  the_slot = data;
  try
    {
      D.108127 = reporting != 0;
      D.102794 = D.108127;
      try
        {
          D.108128 = &the_slot->D.102547;
          sigc::slot4<void, bool, long unsigned int, long unsigned int, long unsigned int>::operator() (D.108128, &D.102794, &current_size, &num_dirs, &num_files);
        }
      finally
        {
          D.102794 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.108129 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.108129);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


T_return sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::operator()(sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg1_type_, sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg2_type_, sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg3_type_, sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg4_type_) const [with T_return = void; T_arg1 = bool; T_arg2 = long unsigned int; T_arg3 = long unsigned int; T_arg4 = long unsigned int; sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg1_type_ = const bool&; sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg2_type_ = const long unsigned int&; sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg3_type_ = const long unsigned int&; sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::arg4_type_ = const long unsigned int&] (const struct slot4 * const this, const bool & _A_a1, const long unsigned int & _A_a2, const long unsigned int & _A_a3, const long unsigned int & _A_a4)
{
  bool retval.137;
  bool iftmp.138;
  const struct slot_base * D.108138;
  bool D.108139;
  bool D.108140;
  bool D.108142;
  bool D.108143;
  struct rep_type * D.108147;
  void * (*<T605>) (void *) D.108148;

  D.108138 = &this->D.102505;
  D.108139 = sigc::slot_base::empty (D.108138);
  D.108140 = ~D.108139;
  if (D.108140 != 0) goto <D.108141>; else goto <D.108136>;
  <D.108141>:
  D.108138 = &this->D.102505;
  D.108142 = sigc::slot_base::blocked (D.108138);
  D.108143 = ~D.108142;
  if (D.108143 != 0) goto <D.108144>; else goto <D.108136>;
  <D.108144>:
  iftmp.138 = 1;
  goto <D.108137>;
  <D.108136>:
  iftmp.138 = 0;
  <D.108137>:
  retval.137 = iftmp.138;
  if (retval.137 != 0) goto <D.108145>; else goto <D.108146>;
  <D.108145>:
  D.108147 = this->D.102505.rep_;
  D.108148 = D.108147->call_;
  D.108147 = this->D.102505.rep_;
  D.108148 (D.108147, _A_a1, _A_a2, _A_a3, _A_a4);
  return;
  <D.108146>:
  return;
}


void Gio::File::measure_disk_usage_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const SlotFileMeasureProgress&, Gio::FileMeasureFlags, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, const struct SlotFileMeasureProgress & slot_progress, FileMeasureFlags flags, int io_priority)
{
  void * slots.139;
  void * slot_progress_copy.140;
  void * slot_ready_copy.141;
  struct BaseObjectType * D.108150;
  struct GFile * D.108151;
  struct MeasureSlots * slots;
  struct SlotFileMeasureProgress * slot_progress_copy;
  struct SlotAsyncReady * slot_ready_copy;

  slots.139 = operator new (16);
  try
    {
      std::pair<sigc::slot<void, bool, long unsigned int, long unsigned int, long unsigned int>*, sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*>::pair (slots.139);
    }
  catch
    {
      operator delete (slots.139);
    }
  slots = slots.139;
  slot_progress_copy.140 = operator new (16);
  try
    {
      sigc::slot<void, bool, long unsigned int, long unsigned int, long unsigned int>::slot (slot_progress_copy.140, slot_progress);
    }
  catch
    {
      operator delete (slot_progress_copy.140);
    }
  slot_progress_copy = slot_progress_copy.140;
  slot_ready_copy.141 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.141, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.141);
    }
  slot_ready_copy = slot_ready_copy.141;
  slots->first = slot_progress_copy;
  slots->second = slot_ready_copy;
  D.108150 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108151 = Gio::File::gobj (this);
  g_file_measure_disk_usage_async (D.108151, flags, io_priority, D.108150, SignalProxy_file_measure_progress_callback, slot_progress, SignalProxy_file_measure_async_callback, slots);
}


void {anonymous}::SignalProxy_file_measure_async_callback(GObject*, GAsyncResult*, void*) (struct GObject * D.102373, struct GAsyncResult * res, void * data)
{
  bool retval.142;
  struct slot_base * D.108159;
  struct slot1 * D.108162;
  void * D.108164;
  struct SlotAsyncReady * the_slot.143;
  struct slot * D.108169;
  struct MeasureSlots * slot_pair;
  struct SlotAsyncReady * the_slot;

  slot_pair = data;
  the_slot = slot_pair->second;
  try
    {
      {
        {
          D.108159 = &the_slot->D.102172.D.102130;
          retval.142 = sigc::slot_base::operator bool (D.108159);
          if (retval.142 != 0) goto <D.108160>; else goto <D.108161>;
          <D.108160>:
          {
            struct RefPtr result;

            try
              {
                result = Glib::wrap (res, 1); [return slot optimization]
                try
                  {
                    D.108162 = &the_slot->D.102172;
                    sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::operator() (D.108162, &result);
                  }
                finally
                  {
                    Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&result);
                  }
              }
            finally
              {
                result = {CLOBBER};
              }
          }
          goto <D.108163>;
          <D.108161>:
          <D.108163>:
        }
      }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.108164 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.108164);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  the_slot.143 = the_slot;
  if (the_slot.143 != 0B) goto <D.108166>; else goto <D.108167>;
  <D.108166>:
  sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot (the_slot.143);
  operator delete (the_slot.143);
  goto <D.108168>;
  <D.108167>:
  <D.108168>:
  D.108169 = slot_pair->first;
  if (D.108169 != 0B) goto <D.108170>; else goto <D.108171>;
  <D.108170>:
  sigc::slot<void, bool, long unsigned int, long unsigned int, long unsigned int>::~slot (D.108169);
  operator delete (D.108169);
  goto <D.108172>;
  <D.108171>:
  <D.108172>:
  operator delete (slot_pair);
}


sigc::slot<void, bool, long unsigned int, long unsigned int, long unsigned int>::~slot() (struct slot * const this)
{
  struct slot4 * D.108179;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.108179 = &this->D.102547;
            sigc::slot4<void, bool, long unsigned int, long unsigned int, long unsigned int>::~slot4 (D.108179);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102578>:
}


sigc::slot4<void, bool, long unsigned int, long unsigned int, long unsigned int>::~slot4() (struct slot4 * const this)
{
  struct slot_base * D.108181;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.108181 = &this->D.102505;
            sigc::slot_base::~slot_base (D.108181);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102573>:
}


std::pair<_T1, _T2>::pair() [with _T1 = sigc::slot<void, bool, long unsigned int, long unsigned int, long unsigned int>*; _T2 = sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>*] (struct pair * const this)
{
  this->first = 0B;
  this->second = 0B;
}


sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = bool; T_arg2 = long unsigned int; T_arg3 = long unsigned int; T_arg4 = long unsigned int] (struct slot * const this, const struct slot & src)
{
  struct slot4 * D.108183;

  D.108183 = &this->D.102547;
  sigc::slot4<void, bool, long unsigned int, long unsigned int, long unsigned int>::slot4 (D.108183, src);
  try
    {

    }
  catch
    {
      D.108183 = &this->D.102547;
      sigc::slot4<void, bool, long unsigned int, long unsigned int, long unsigned int>::~slot4 (D.108183);
    }
}


sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>::slot4(const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>&) [with T_return = void; T_arg1 = bool; T_arg2 = long unsigned int; T_arg3 = long unsigned int; T_arg4 = long unsigned int] (struct slot4 * const this, const struct slot4 & src)
{
  const struct slot_base * D.108184;
  struct slot_base * D.108185;

  D.108184 = &src->D.102505;
  D.108185 = &this->D.102505;
  sigc::slot_base::slot_base (D.108185, D.108184);
  try
    {

    }
  catch
    {
      D.108185 = &this->D.102505;
      sigc::slot_base::~slot_base (D.108185);
    }
}


void Gio::File::start_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::MountOperation>&, Gio::DriveStartFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & start_operation, DriveStartFlags flags)
{
  void * slot_copy.144;
  struct BaseObjectType * D.108186;
  struct BaseObjectType * D.108187;
  struct GFile * D.108188;
  struct SlotAsyncReady * slot_copy;

  slot_copy.144 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.144, slot);
    }
  catch
    {
      operator delete (slot_copy.144);
    }
  slot_copy = slot_copy.144;
  D.108186 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108187 = Glib::unwrap<Gio::MountOperation> (start_operation);
  D.108188 = Gio::File::gobj (this);
  g_file_start_mountable (D.108188, flags, D.108187, D.108186, SignalProxy_async_callback, slot_copy);
}


void Gio::File::start_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::MountOperation>&, Gio::DriveStartFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & start_operation, DriveStartFlags flags)
{
  void * slot_copy.145;
  struct BaseObjectType * D.108193;
  struct GFile * D.108194;
  struct SlotAsyncReady * slot_copy;

  slot_copy.145 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.145, slot);
    }
  catch
    {
      operator delete (slot_copy.145);
    }
  slot_copy = slot_copy.145;
  D.108193 = Glib::unwrap<Gio::MountOperation> (start_operation);
  D.108194 = Gio::File::gobj (this);
  g_file_start_mountable (D.108194, flags, D.108193, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::stop_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & start_operation, MountUnmountFlags flags)
{
  void * slot_copy.146;
  struct BaseObjectType * D.108198;
  struct BaseObjectType * D.108199;
  struct GFile * D.108200;
  struct SlotAsyncReady * slot_copy;

  slot_copy.146 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.146, slot);
    }
  catch
    {
      operator delete (slot_copy.146);
    }
  slot_copy = slot_copy.146;
  D.108198 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108199 = Glib::unwrap<Gio::MountOperation> (start_operation);
  D.108200 = Gio::File::gobj (this);
  g_file_stop_mountable (D.108200, flags, D.108199, D.108198, SignalProxy_async_callback, slot_copy);
}


void Gio::File::stop_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & start_operation, MountUnmountFlags flags)
{
  void * slot_copy.147;
  struct BaseObjectType * D.108205;
  struct GFile * D.108206;
  struct SlotAsyncReady * slot_copy;

  slot_copy.147 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.147, slot);
    }
  catch
    {
      operator delete (slot_copy.147);
    }
  slot_copy = slot_copy.147;
  D.108205 = Glib::unwrap<Gio::MountOperation> (start_operation);
  D.108206 = Gio::File::gobj (this);
  g_file_stop_mountable (D.108206, flags, D.108205, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::poll_mountable(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable)
{
  void * slot_copy.148;
  struct BaseObjectType * D.108210;
  struct GFile * D.108211;
  struct SlotAsyncReady * slot_copy;

  slot_copy.148 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.148, slot);
    }
  catch
    {
      operator delete (slot_copy.148);
    }
  slot_copy = slot_copy.148;
  D.108210 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108211 = Gio::File::gobj (this);
  g_file_poll_mountable (D.108211, D.108210, SignalProxy_async_callback, slot_copy);
}


void Gio::File::poll_mountable(const SlotAsyncReady&) (struct File * const this, const struct SlotAsyncReady & slot)
{
  void * slot_copy.149;
  struct GFile * D.108215;
  struct SlotAsyncReady * slot_copy;

  slot_copy.149 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.149, slot);
    }
  catch
    {
      operator delete (slot_copy.149);
    }
  slot_copy = slot_copy.149;
  D.108215 = Gio::File::gobj (this);
  g_file_poll_mountable (D.108215, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::File::find_enclosing_mount_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.150;
  struct BaseObjectType * D.108218;
  struct GFile * D.108219;
  struct SlotAsyncReady * slot_copy;

  slot_copy.150 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.150, slot);
    }
  catch
    {
      operator delete (slot_copy.150);
    }
  slot_copy = slot_copy.150;
  D.108218 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108219 = Gio::File::gobj (this);
  g_file_find_enclosing_mount_async (D.108219, io_priority, D.108218, SignalProxy_async_callback, slot_copy);
}


void Gio::File::find_enclosing_mount_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.151;
  struct GFile * D.108223;
  struct SlotAsyncReady * slot_copy;

  slot_copy.151 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.151, slot);
    }
  catch
    {
      operator delete (slot_copy.151);
    }
  slot_copy = slot_copy.151;
  D.108223 = Gio::File::gobj (this);
  g_file_find_enclosing_mount_async (D.108223, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


bool Gio::File::set_attributes_from_info(const Glib::RefPtr<Gio::FileInfo>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileQueryInfoFlags) (struct File * const this, const struct RefPtr & info, const struct RefPtr & cancellable, FileQueryInfoFlags flags)
{
  struct BaseObjectType * D.108226;
  struct BaseObjectType * D.108227;
  struct GFile * D.108228;
  int D.108229;
  struct GError * gerror.152;
  bool D.108233;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108226 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108227 = Glib::unwrap<Gio::FileInfo> (info);
      D.108228 = Gio::File::gobj (this);
      D.108229 = g_file_set_attributes_from_info (D.108228, D.108227, flags, D.108226, &gerror);
      retvalue = D.108229 != 0;
      gerror.152 = gerror;
      if (gerror.152 != 0B) goto <D.108231>; else goto <D.108232>;
      <D.108231>:
      gerror.152 = gerror;
      Glib::Error::throw_exception (gerror.152);
      <D.108232>:
      D.108233 = retvalue;
      return D.108233;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attributes_from_info(const Glib::RefPtr<Gio::FileInfo>&, Gio::FileQueryInfoFlags) (struct File * const this, const struct RefPtr & info, FileQueryInfoFlags flags)
{
  struct BaseObjectType * D.108240;
  struct GFile * D.108241;
  int D.108242;
  struct GError * gerror.153;
  bool D.108246;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108240 = Glib::unwrap<Gio::FileInfo> (info);
      D.108241 = Gio::File::gobj (this);
      D.108242 = g_file_set_attributes_from_info (D.108241, D.108240, flags, 0B, &gerror);
      retvalue = D.108242 != 0;
      gerror.153 = gerror;
      if (gerror.153 != 0B) goto <D.108244>; else goto <D.108245>;
      <D.108244>:
      gerror.153 = gerror;
      Glib::Error::throw_exception (gerror.153);
      <D.108245>:
      D.108246 = retvalue;
      return D.108246;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::copy_attributes(const Glib::RefPtr<Gio::File>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, const struct RefPtr & cancellable, FileCopyFlags flags)
{
  struct BaseObjectType * D.108252;
  struct BaseObjectType * D.108253;
  struct GFile * D.108254;
  int D.108255;
  struct GError * gerror.154;
  bool D.108259;
  struct GError * gerror;
  bool res;

  try
    {
      gerror = 0B;
      D.108252 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108253 = Glib::unwrap<Gio::File> (destination);
      D.108254 = Gio::File::gobj (this);
      D.108255 = g_file_copy_attributes (D.108254, D.108253, flags, D.108252, &gerror);
      res = D.108255 != 0;
      gerror.154 = gerror;
      if (gerror.154 != 0B) goto <D.108257>; else goto <D.108258>;
      <D.108257>:
      gerror.154 = gerror;
      Glib::Error::throw_exception (gerror.154);
      <D.108258>:
      D.108259 = res;
      return D.108259;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::copy_attributes(const Glib::RefPtr<Gio::File>&, Gio::FileCopyFlags) (struct File * const this, const struct RefPtr & destination, FileCopyFlags flags)
{
  struct BaseObjectType * D.108266;
  struct GFile * D.108267;
  int D.108268;
  struct GError * gerror.155;
  bool D.108272;
  struct GError * gerror;
  bool res;

  try
    {
      gerror = 0B;
      D.108266 = Glib::unwrap<Gio::File> (destination);
      D.108267 = Gio::File::gobj (this);
      D.108268 = g_file_copy_attributes (D.108267, D.108266, flags, 0B, &gerror);
      res = D.108268 != 0;
      gerror.155 = gerror;
      if (gerror.155 != 0B) goto <D.108270>; else goto <D.108271>;
      <D.108270>:
      gerror.155 = gerror;
      Glib::Error::throw_exception (gerror.155);
      <D.108271>:
      D.108272 = res;
      return D.108272;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::create_file(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags) (struct File * const this, const struct RefPtr & cancellable, FileCreateFlags flags)
{
  struct BaseObjectType * D.108279;
  struct GFile * D.108280;
  struct GFileOutputStream * D.108281;
  struct GError * gerror.156;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108279 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108280 = Gio::File::gobj (this);
      D.108281 = g_file_create (D.108280, flags, D.108279, &gerror);
      *<retval> = Glib::wrap (D.108281, 0); [return slot optimization]
      try
        {
          gerror.156 = gerror;
          if (gerror.156 != 0B) goto <D.108283>; else goto <D.108284>;
          <D.108283>:
          gerror.156 = gerror;
          Glib::Error::throw_exception (gerror.156);
          <D.108284>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::create_file(Gio::FileCreateFlags) (struct File * const this, FileCreateFlags flags)
{
  struct GFile * D.108292;
  struct GFileOutputStream * D.108293;
  struct GError * gerror.157;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108292 = Gio::File::gobj (this);
      D.108293 = g_file_create (D.108292, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108293, 0); [return slot optimization]
      try
        {
          gerror.157 = gerror;
          if (gerror.157 != 0B) goto <D.108295>; else goto <D.108296>;
          <D.108295>:
          gerror.157 = gerror;
          Glib::Error::throw_exception (gerror.157);
          <D.108296>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::create_file_readwrite(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags) (struct File * const this, const struct RefPtr & cancellable, FileCreateFlags flags)
{
  struct BaseObjectType * D.108303;
  struct GFile * D.108304;
  struct GFileIOStream * D.108305;
  struct GError * gerror.158;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108303 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108304 = Gio::File::gobj (this);
      D.108305 = g_file_create_readwrite (D.108304, flags, D.108303, &gerror);
      *<retval> = Glib::wrap (D.108305, 0); [return slot optimization]
      try
        {
          gerror.158 = gerror;
          if (gerror.158 != 0B) goto <D.108307>; else goto <D.108308>;
          <D.108307>:
          gerror.158 = gerror;
          Glib::Error::throw_exception (gerror.158);
          <D.108308>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::create_file_readwrite(Gio::FileCreateFlags) (struct File * const this, FileCreateFlags flags)
{
  struct GFile * D.108316;
  struct GFileIOStream * D.108317;
  struct GError * gerror.159;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108316 = Gio::File::gobj (this);
      D.108317 = g_file_create_readwrite (D.108316, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108317, 0); [return slot optimization]
      try
        {
          gerror.159 = gerror;
          if (gerror.159 != 0B) goto <D.108319>; else goto <D.108320>;
          <D.108319>:
          gerror.159 = gerror;
          Glib::Error::throw_exception (gerror.159);
          <D.108320>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::append_to(const Glib::RefPtr<Gio::Cancellable>&, Gio::FileCreateFlags) (struct File * const this, const struct RefPtr & cancellable, FileCreateFlags flags)
{
  struct BaseObjectType * D.108327;
  struct GFile * D.108328;
  struct GFileOutputStream * D.108329;
  struct GError * gerror.160;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108327 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108328 = Gio::File::gobj (this);
      D.108329 = g_file_append_to (D.108328, flags, D.108327, &gerror);
      *<retval> = Glib::wrap (D.108329, 0); [return slot optimization]
      try
        {
          gerror.160 = gerror;
          if (gerror.160 != 0B) goto <D.108331>; else goto <D.108332>;
          <D.108331>:
          gerror.160 = gerror;
          Glib::Error::throw_exception (gerror.160);
          <D.108332>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::append_to(Gio::FileCreateFlags) (struct File * const this, FileCreateFlags flags)
{
  struct GFile * D.108340;
  struct GFileOutputStream * D.108341;
  struct GError * gerror.161;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.108340 = Gio::File::gobj (this);
      D.108341 = g_file_append_to (D.108340, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.108341, 0); [return slot optimization]
      try
        {
          gerror.161 = gerror;
          if (gerror.161 != 0B) goto <D.108343>; else goto <D.108344>;
          <D.108343>:
          gerror.161 = gerror;
          Glib::Error::throw_exception (gerror.161);
          <D.108344>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::load_contents(const Glib::RefPtr<Gio::Cancellable>&, char*&, gsize&, std::string&) (struct File * const this, const struct RefPtr & cancellable, char * & contents, gsize & length, struct string & etag_out)
{
  struct BaseObjectType * D.108350;
  struct GFile * D.108351;
  int D.108352;
  struct GError * gerror.162;
  struct string D.104742;
  gchar * cetag_out.163;
  bool D.108357;
  struct GError * gerror;
  gchar * cetag_out;
  bool retvalue;

  try
    {
      gerror = 0B;
      cetag_out = 0B;
      D.108350 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108351 = Gio::File::gobj (this);
      D.108352 = g_file_load_contents (D.108351, D.108350, contents, length, &cetag_out, &gerror);
      retvalue = D.108352 != 0;
      gerror.162 = gerror;
      if (gerror.162 != 0B) goto <D.108354>; else goto <D.108355>;
      <D.108354>:
      gerror.162 = gerror;
      Glib::Error::throw_exception (gerror.162);
      <D.108355>:
      cetag_out.163 = cetag_out;
      D.104742 = Glib::convert_return_gchar_ptr_to_stdstring (cetag_out.163); [return slot optimization]
      try
        {
          std::basic_string<char>::operator= (etag_out, &D.104742);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.104742);
          D.104742 = {CLOBBER};
        }
      D.108357 = retvalue;
      return D.108357;
    }
  finally
    {
      gerror = {CLOBBER};
      cetag_out = {CLOBBER};
    }
}


std::string Glib::convert_return_gchar_ptr_to_stdstring(char*) (char * str)
{
  struct allocator D.78983;
  bool cleanup.164;
  struct ScopedPtr D.78981;
  bool cleanup.165;
  char * D.108373;
  struct string * D.108374;

  cleanup.164 = 0;
  try
    {
      cleanup.165 = 0;
      try
        {
          if (str != 0B) goto <D.108365>; else goto <D.108366>;
          <D.108365>:
          std::allocator<char>::allocator (&D.78983);
          cleanup.164 = 1;
          Glib::ScopedPtr<char>::ScopedPtr (&D.78981, str);
          cleanup.165 = 1;
          D.108373 = Glib::ScopedPtr<char>::get (&D.78981);
          D.108374 = <retval>;
          std::basic_string<char>::basic_string (D.108374, D.108373, &D.78983);
          goto <D.108375>;
          <D.108366>:
          D.108374 = <retval>;
          std::basic_string<char>::basic_string (D.108374);
          <D.108375>:
          return <retval>;
        }
      finally
        {
          if (cleanup.165 != 0) goto <D.108371>; else goto <D.108372>;
          <D.108371>:
          Glib::ScopedPtr<char>::~ScopedPtr (&D.78981);
          D.78981 = {CLOBBER};
          <D.108372>:
        }
    }
  finally
    {
      if (cleanup.164 != 0) goto <D.108368>; else goto <D.108369>;
      <D.108368>:
      std::allocator<char>::~allocator (&D.78983);
      D.78983 = {CLOBBER};
      <D.108369>:
    }
}


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

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


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

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


bool Gio::File::load_contents(const Glib::RefPtr<Gio::Cancellable>&, char*&, gsize&) (struct File * const this, const struct RefPtr & cancellable, char * & contents, gsize & length)
{
  struct BaseObjectType * D.108389;
  struct GFile * D.108390;
  int D.108391;
  struct GError * gerror.166;
  bool D.108395;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108389 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.108390 = Gio::File::gobj (this);
      D.108391 = g_file_load_contents (D.108390, D.108389, contents, length, 0B, &gerror);
      retvalue = D.108391 != 0;
      gerror.166 = gerror;
      if (gerror.166 != 0B) goto <D.108393>; else goto <D.108394>;
      <D.108393>:
      gerror.166 = gerror;
      Glib::Error::throw_exception (gerror.166);
      <D.108394>:
      D.108395 = retvalue;
      return D.108395;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::load_contents(char*&, gsize&, std::string&) (struct File * const this, char * & contents, gsize & length, struct string & etag_out)
{
  struct GFile * D.108401;
  int D.108402;
  struct GError * gerror.167;
  struct string D.104760;
  gchar * cetag_out.168;
  bool D.108407;
  struct GError * gerror;
  gchar * cetag_out;
  bool retvalue;

  try
    {
      gerror = 0B;
      cetag_out = 0B;
      D.108401 = Gio::File::gobj (this);
      D.108402 = g_file_load_contents (D.108401, 0B, contents, length, &cetag_out, &gerror);
      retvalue = D.108402 != 0;
      gerror.167 = gerror;
      if (gerror.167 != 0B) goto <D.108404>; else goto <D.108405>;
      <D.108404>:
      gerror.167 = gerror;
      Glib::Error::throw_exception (gerror.167);
      <D.108405>:
      cetag_out.168 = cetag_out;
      D.104760 = Glib::convert_return_gchar_ptr_to_stdstring (cetag_out.168); [return slot optimization]
      try
        {
          std::basic_string<char>::operator= (etag_out, &D.104760);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.104760);
          D.104760 = {CLOBBER};
        }
      D.108407 = retvalue;
      return D.108407;
    }
  finally
    {
      gerror = {CLOBBER};
      cetag_out = {CLOBBER};
    }
}


bool Gio::File::load_contents(char*&, gsize&) (struct File * const this, char * & contents, gsize & length)
{
  struct GFile * D.108413;
  int D.108414;
  struct GError * gerror.169;
  bool D.108418;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108413 = Gio::File::gobj (this);
      D.108414 = g_file_load_contents (D.108413, 0B, contents, length, 0B, &gerror);
      retvalue = D.108414 != 0;
      gerror.169 = gerror;
      if (gerror.169 != 0B) goto <D.108416>; else goto <D.108417>;
      <D.108416>:
      gerror.169 = gerror;
      Glib::Error::throw_exception (gerror.169);
      <D.108417>:
      D.108418 = retvalue;
      return D.108418;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::load_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&, char*&, gsize&, std::string&) (struct File * const this, const struct RefPtr & result, char * & contents, gsize & length, struct string & etag_out)
{
  struct BaseObjectType * D.108423;
  struct GFile * D.108424;
  int D.108425;
  struct GError * gerror.170;
  struct string D.104778;
  gchar * cetag_out.171;
  bool D.108430;
  struct GError * gerror;
  gchar * cetag_out;
  bool retvalue;

  try
    {
      gerror = 0B;
      cetag_out = 0B;
      D.108423 = Glib::unwrap<Gio::AsyncResult> (result);
      D.108424 = Gio::File::gobj (this);
      D.108425 = g_file_load_contents_finish (D.108424, D.108423, contents, length, &cetag_out, &gerror);
      retvalue = D.108425 != 0;
      gerror.170 = gerror;
      if (gerror.170 != 0B) goto <D.108427>; else goto <D.108428>;
      <D.108427>:
      gerror.170 = gerror;
      Glib::Error::throw_exception (gerror.170);
      <D.108428>:
      cetag_out.171 = cetag_out;
      D.104778 = Glib::convert_return_gchar_ptr_to_stdstring (cetag_out.171); [return slot optimization]
      try
        {
          std::basic_string<char>::operator= (etag_out, &D.104778);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.104778);
          D.104778 = {CLOBBER};
        }
      D.108430 = retvalue;
      return D.108430;
    }
  finally
    {
      gerror = {CLOBBER};
      cetag_out = {CLOBBER};
    }
}


bool Gio::File::load_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&, char*&, gsize&) (struct File * const this, const struct RefPtr & result, char * & contents, gsize & length)
{
  struct BaseObjectType * D.108437;
  struct GFile * D.108438;
  int D.108439;
  struct GError * gerror.172;
  bool D.108443;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108437 = Glib::unwrap<Gio::AsyncResult> (result);
      D.108438 = Gio::File::gobj (this);
      D.108439 = g_file_load_contents_finish (D.108438, D.108437, contents, length, 0B, &gerror);
      retvalue = D.108439 != 0;
      gerror.172 = gerror;
      if (gerror.172 != 0B) goto <D.108441>; else goto <D.108442>;
      <D.108441>:
      gerror.172 = gerror;
      Glib::Error::throw_exception (gerror.172);
      <D.108442>:
      D.108443 = retvalue;
      return D.108443;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::load_partial_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&, char*&, gsize&, std::string&) (struct File * const this, const struct RefPtr & result, char * & contents, gsize & length, struct string & etag_out)
{
  struct BaseObjectType * D.108449;
  struct GFile * D.108450;
  int D.108451;
  struct GError * gerror.173;
  struct string D.104797;
  gchar * cetag_out.174;
  bool D.108456;
  struct GError * gerror;
  gchar * cetag_out;
  bool retvalue;

  try
    {
      gerror = 0B;
      cetag_out = 0B;
      D.108449 = Glib::unwrap<Gio::AsyncResult> (result);
      D.108450 = Gio::File::gobj (this);
      D.108451 = g_file_load_partial_contents_finish (D.108450, D.108449, contents, length, &cetag_out, &gerror);
      retvalue = D.108451 != 0;
      gerror.173 = gerror;
      if (gerror.173 != 0B) goto <D.108453>; else goto <D.108454>;
      <D.108453>:
      gerror.173 = gerror;
      Glib::Error::throw_exception (gerror.173);
      <D.108454>:
      cetag_out.174 = cetag_out;
      D.104797 = Glib::convert_return_gchar_ptr_to_stdstring (cetag_out.174); [return slot optimization]
      try
        {
          std::basic_string<char>::operator= (etag_out, &D.104797);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.104797);
          D.104797 = {CLOBBER};
        }
      D.108456 = retvalue;
      return D.108456;
    }
  finally
    {
      gerror = {CLOBBER};
      cetag_out = {CLOBBER};
    }
}


bool Gio::File::load_partial_contents_finish(const Glib::RefPtr<Gio::AsyncResult>&, char*&, gsize&) (struct File * const this, const struct RefPtr & result, char * & contents, gsize & length)
{
  struct BaseObjectType * D.108463;
  struct GFile * D.108464;
  int D.108465;
  struct GError * gerror.175;
  bool D.108469;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.108463 = Glib::unwrap<Gio::AsyncResult> (result);
      D.108464 = Gio::File::gobj (this);
      D.108465 = g_file_load_partial_contents_finish (D.108464, D.108463, contents, length, 0B, &gerror);
      retvalue = D.108465 != 0;
      gerror.175 = gerror;
      if (gerror.175 != 0B) goto <D.108467>; else goto <D.108468>;
      <D.108467>:
      gerror.175 = gerror;
      Glib::Error::throw_exception (gerror.175);
      <D.108468>:
      D.108469 = retvalue;
      return D.108469;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::has_parent() const (const struct File * const this)
{
  bool D.108475;
  const struct GFile * D.108476;
  int D.108477;

  D.108476 = Gio::File::gobj (this);
  D.108477 = g_file_has_parent (D.108476, 0B);
  D.108475 = D.108477 != 0;
  return D.108475;
}


void Gio::File::remove_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_ready_copy.176;
  struct BaseObjectType * D.108480;
  struct GFile * D.108481;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.176 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.176, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.176);
    }
  slot_ready_copy = slot_ready_copy.176;
  D.108480 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108481 = Gio::File::gobj (this);
  g_file_delete_async (D.108481, io_priority, D.108480, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::remove_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, int io_priority)
{
  void * slot_ready_copy.177;
  struct GFile * D.108485;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.177 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.177, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.177);
    }
  slot_ready_copy = slot_ready_copy.177;
  D.108485 = Gio::File::gobj (this);
  g_file_delete_async (D.108485, io_priority, 0B, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::trash_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_ready_copy.178;
  struct BaseObjectType * D.108488;
  struct GFile * D.108489;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.178 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.178, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.178);
    }
  slot_ready_copy = slot_ready_copy.178;
  D.108488 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108489 = Gio::File::gobj (this);
  g_file_trash_async (D.108489, io_priority, D.108488, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::trash_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, int io_priority)
{
  void * slot_ready_copy.179;
  struct GFile * D.108493;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.179 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.179, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.179);
    }
  slot_ready_copy = slot_ready_copy.179;
  D.108493 = Gio::File::gobj (this);
  g_file_trash_async (D.108493, io_priority, 0B, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::make_directory_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_ready_copy.180;
  struct BaseObjectType * D.108496;
  struct GFile * D.108497;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.180 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.180, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.180);
    }
  slot_ready_copy = slot_ready_copy.180;
  D.108496 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.108497 = Gio::File::gobj (this);
  g_file_make_directory_async (D.108497, io_priority, D.108496, SignalProxy_async_callback, slot_ready_copy);
}


void Gio::File::make_directory_async(const SlotAsyncReady&, int) (struct File * const this, const struct SlotAsyncReady & slot_ready, int io_priority)
{
  void * slot_ready_copy.181;
  struct GFile * D.108501;
  struct SlotAsyncReady * slot_ready_copy;

  slot_ready_copy.181 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_ready_copy.181, slot_ready);
    }
  catch
    {
      operator delete (slot_ready_copy.181);
    }
  slot_ready_copy = slot_ready_copy.181;
  D.108501 = Gio::File::gobj (this);
  g_file_make_directory_async (D.108501, io_priority, 0B, SignalProxy_async_callback, slot_ready_copy);
}


Glib::RefPtr<Gio::File> Glib::wrap(GFile*, bool) (struct GFile * object, bool take_copy)
{
  int D.108505;
  struct File * D.108506;

  D.108505 = (int) take_copy;
  D.108506 = Glib::wrap_auto_interface<Gio::File> (object, D.108505);
  Glib::RefPtr<Gio::File>::RefPtr (<retval>, D.108506);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::File; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct File * D.108511;
  long unsigned int D.108514;
  struct File * iftmp.182;
  struct ObjectBase * pCppObject.183;
  const struct type_info * iftmp.184;
  int (*__vtbl_ptr_type) () * D.108528;
  const char * D.108530;
  void * result.185;
  bool D.108533;
  bool D.108534;
  int (*__vtbl_ptr_type) () * D.108537;
  int (*__vtbl_ptr_type) () * D.108538;
  long int D.108539;
  sizetype D.108540;
  struct ObjectBase * D.108541;
  int (*__vtbl_ptr_type) () * D.108542;
  int (*__vtbl_ptr_type) () * D.108543;
  int (*__vtbl_ptr_type) () D.108544;
  struct ObjectBase * pCppObject;
  struct File * result;

  if (object == 0B) goto <D.108509>; else goto <D.108510>;
  <D.108509>:
  D.108511 = 0B;
  return D.108511;
  <D.108510>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.108512>; else goto <D.108513>;
  <D.108512>:
  D.108514 = Gio::File::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.108514);
  goto <D.108515>;
  <D.108513>:
  <D.108515>:
  result = 0B;
  if (pCppObject != 0B) goto <D.108516>; else goto <D.108517>;
  <D.108516>:
  pCppObject.183 = pCppObject;
  if (pCppObject.183 == 0B) goto <D.108520>; else goto <D.108521>;
  <D.108520>:
  iftmp.182 = 0B;
  goto <D.108522>;
  <D.108521>:
  iftmp.182 = __dynamic_cast (pCppObject.183, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4FileE, -1);
  <D.108522>:
  result = iftmp.182;
  if (result == 0B) goto <D.108523>; else goto <D.108524>;
  <D.108523>:
  if (pCppObject != 0B) goto <D.108526>; else goto <D.108527>;
  <D.108526>:
  D.108528 = pCppObject->_vptr.ObjectBase;
  iftmp.184 = MEM[(int (*__vtbl_ptr_type) () *)D.108528 + -8B];
  goto <D.108529>;
  <D.108527>:
  __cxa_bad_typeid ();
  <D.108529>:
  D.108530 = std::type_info::name (iftmp.184);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.108530);
  goto <D.108531>;
  <D.108524>:
  <D.108531>:
  goto <D.108532>;
  <D.108517>:
  result.185 = operator new (48);
  try
    {
      Gio::File::File (result.185, object);
    }
  catch
    {
      operator delete (result.185);
    }
  result = result.185;
  <D.108532>:
  D.108533 = result != 0B;
  D.108534 = D.108533 & take_copy;
  if (D.108534 != 0) goto <D.108535>; else goto <D.108536>;
  <D.108535>:
  D.108537 = result->D.101656._vptr.Interface;
  D.108538 = D.108537 + 18446744073709551592;
  D.108539 = MEM[(long int *)D.108538];
  D.108540 = (sizetype) D.108539;
  D.108541 = result + D.108540;
  D.108537 = result->D.101656._vptr.Interface;
  D.108538 = D.108537 + 18446744073709551592;
  D.108539 = MEM[(long int *)D.108538];
  D.108540 = (sizetype) D.108539;
  D.108541 = result + D.108540;
  D.108542 = D.108541->_vptr.ObjectBase;
  D.108543 = D.108542 + 16;
  D.108544 = *D.108543;
  D.108537 = result->D.101656._vptr.Interface;
  D.108538 = D.108537 + 18446744073709551592;
  D.108539 = MEM[(long int *)D.108538];
  D.108540 = (sizetype) D.108539;
  D.108541 = result + D.108540;
  OBJ_TYPE_REF(D.108544;(const struct ObjectBase)D.108541->2) (D.108541);
  goto <D.108545>;
  <D.108536>:
  <D.108545>:
  D.108511 = result;
  return D.108511;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.108552;
  const char * iftmp.186;
  const char * D.108554;
  char D.108555;

  D.108554 = this->__name;
  D.108555 = *D.108554;
  if (D.108555 == 42) goto <D.108556>; else goto <D.108557>;
  <D.108556>:
  D.108554 = this->__name;
  iftmp.186 = D.108554 + 1;
  goto <D.108558>;
  <D.108557>:
  iftmp.186 = this->__name;
  <D.108558>:
  D.108552 = iftmp.186;
  return D.108552;
}


Glib::RefPtr<T_CppObject>::RefPtr(T_CppObject*) [with T_CppObject = Gio::File] (struct RefPtr * const this, struct File * pCppObject)
{
  this->pCppObject_ = pCppObject;
}


const Glib::Interface_Class& Gio::File_Class::init() (struct File_Class * const this)
{
  long unsigned int D.108560;
  long unsigned int D.108563;
  const struct Interface_Class & D.108565;

  D.108560 = this->D.101891.D.101877.gtype_;
  if (D.108560 == 0) goto <D.108561>; else goto <D.108562>;
  <D.108561>:
  this->D.101891.D.101877.class_init_func_ = iface_init_function;
  D.108563 = g_file_get_type ();
  this->D.101891.D.101877.gtype_ = D.108563;
  goto <D.108564>;
  <D.108562>:
  <D.108564>:
  D.108565 = &this->D.101891;
  return D.108565;
}


static void Gio::File_Class::iface_init_function(void*, void*) (void * g_iface, void * D.104866)
{
  bool retval.187;
  int retval.188;
  long int D.108573;
  long int D.108574;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[63] = "static void Gio::File_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.108570>; else goto <D.108571>;
        <D.108570>:
        _g_boolean_var_ = 1;
        goto <D.108572>;
        <D.108571>:
        _g_boolean_var_ = 0;
        <D.108572>:
        retval.188 = _g_boolean_var_;
      }
      D.108573 = (long int) retval.188;
      D.108574 = __builtin_expect (D.108573, 1);
      retval.187 = D.108574 != 0;
      if (retval.187 != 0) goto <D.108575>; else goto <D.108576>;
      <D.108575>:
      goto <D.108577>;
      <D.108576>:
      g_assertion_message_expr ("giomm", "file.cc", 2080, &__PRETTY_FUNCTION__, "klass != 0");
      <D.108577>:
    }
  }
}


static Glib::ObjectBase* Gio::File_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.108578;
  struct ObjectBase * iftmp.189;
  void * D.104879;
  void * D.108580;
  int (*__vtbl_ptr_type) () * D.108583;
  int (*__vtbl_ptr_type) () * D.108584;
  long int D.108585;
  sizetype D.108586;

  D.104879 = operator new (48);
  try
    {
      Gio::File::File (D.104879, object);
    }
  catch
    {
      operator delete (D.104879);
    }
  D.108580 = D.104879;
  if (D.108580 != 0B) goto <D.108581>; else goto <D.108582>;
  <D.108581>:
  D.108583 = MEM[(struct File *)D.108580].D.101656._vptr.Interface;
  D.108584 = D.108583 + 18446744073709551592;
  D.108585 = MEM[(long int *)D.108584];
  D.108586 = (sizetype) D.108585;
  iftmp.189 = D.108580 + D.108586;
  goto <D.108587>;
  <D.108582>:
  iftmp.189 = 0B;
  <D.108587>:
  D.108578 = iftmp.189;
  return D.108578;
}


Gio::File::File() (struct File * const this, const void * * __vtt_parm)
{
  struct trackable * D.108593;
  const void * * iftmp.190;
  struct ObjectBase * D.108601;
  const struct Interface_Class & D.108603;
  const void * * iftmp.191;
  struct Interface * D.108608;
  int (*__vtbl_ptr_type) () * iftmp.192;
  sizetype iftmp.193;
  int (*__vtbl_ptr_type) () * D.108616;
  int (*__vtbl_ptr_type) () * D.108617;
  long int D.108618;
  struct ObjectBase * D.108620;
  int (*__vtbl_ptr_type) () * iftmp.194;
  const void * * iftmp.195;
  const void * * iftmp.196;

  if (0 != 0) goto <D.108591>; else goto <D.108592>;
  <D.108591>:
  D.108593 = &this->D.101659;
  sigc::trackable::trackable (D.108593);
  goto <D.108594>;
  <D.108592>:
  <D.108594>:
  try
    {
      if (0 != 0) goto <D.108595>; else goto <D.108596>;
      <D.108595>:
      if (0 == 0) goto <D.108598>; else goto <D.108599>;
      <D.108598>:
      iftmp.190 = __vtt_parm + 32;
      goto <D.108600>;
      <D.108599>:
      iftmp.190 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108600>:
      D.108601 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108601, iftmp.190);
      goto <D.108602>;
      <D.108596>:
      <D.108602>:
      try
        {
          D.108603 = Gio::File_Class::init (&file_class_);
          if (0 == 0) goto <D.108605>; else goto <D.108606>;
          <D.108605>:
          iftmp.191 = __vtt_parm + 8;
          goto <D.108607>;
          <D.108606>:
          iftmp.191 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108607>:
          D.108608 = &this->D.101656;
          Glib::Interface::Interface (D.108608, iftmp.191, D.108603);
          try
            {
              if (0 == 0) goto <D.108610>; else goto <D.108611>;
              <D.108610>:
              iftmp.192 = *__vtt_parm;
              goto <D.108612>;
              <D.108611>:
              iftmp.192 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108612>:
              this->D.101656._vptr.Interface = iftmp.192;
              if (0 == 0) goto <D.108614>; else goto <D.108615>;
              <D.108614>:
              D.108616 = this->D.101656._vptr.Interface;
              D.108617 = D.108616 + 18446744073709551592;
              D.108618 = MEM[(long int *)D.108617];
              iftmp.193 = (sizetype) D.108618;
              goto <D.108619>;
              <D.108615>:
              iftmp.193 = 8;
              <D.108619>:
              D.108620 = this + iftmp.193;
              if (0 == 0) goto <D.108622>; else goto <D.108623>;
              <D.108622>:
              iftmp.194 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.108624>;
              <D.108623>:
              iftmp.194 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108624>:
              D.108620->_vptr.ObjectBase = iftmp.194;
            }
          catch
            {
              if (0 == 0) goto <D.108626>; else goto <D.108627>;
              <D.108626>:
              iftmp.195 = __vtt_parm + 8;
              goto <D.108628>;
              <D.108627>:
              iftmp.195 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108628>:
              D.108608 = &this->D.101656;
              Glib::Interface::~Interface (D.108608, iftmp.195);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108629>; else goto <D.108630>;
          <D.108629>:
          if (0 == 0) goto <D.108632>; else goto <D.108633>;
          <D.108632>:
          iftmp.196 = __vtt_parm + 32;
          goto <D.108634>;
          <D.108633>:
          iftmp.196 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108634>:
          D.108601 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108601, iftmp.196);
          goto <D.108635>;
          <D.108630>:
          <D.108635>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108636>; else goto <D.108637>;
      <D.108636>:
      D.108593 = &this->D.101659;
      sigc::trackable::~trackable (D.108593);
      goto <D.108638>;
      <D.108637>:
      <D.108638>:
    }
}


Gio::File::File() (struct File * const this)
{
  struct trackable * D.108644;
  const void * * iftmp.197;
  struct ObjectBase * D.108652;
  const struct Interface_Class & D.108654;
  const void * * iftmp.198;
  struct Interface * D.108659;
  int (*__vtbl_ptr_type) () * iftmp.199;
  const void * * D.108663;
  sizetype iftmp.200;
  int (*__vtbl_ptr_type) () * D.108668;
  int (*__vtbl_ptr_type) () * D.108669;
  long int D.108670;
  struct ObjectBase * D.108672;
  int (*__vtbl_ptr_type) () * iftmp.201;
  const void * * iftmp.202;
  const void * * iftmp.203;

  if (1 != 0) goto <D.108642>; else goto <D.108643>;
  <D.108642>:
  D.108644 = &this->D.101659;
  sigc::trackable::trackable (D.108644);
  goto <D.108645>;
  <D.108643>:
  <D.108645>:
  try
    {
      if (1 != 0) goto <D.108646>; else goto <D.108647>;
      <D.108646>:
      if (1 == 0) goto <D.108649>; else goto <D.108650>;
      <D.108649>:
      iftmp.197 = 32B;
      goto <D.108651>;
      <D.108650>:
      iftmp.197 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108651>:
      D.108652 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108652, iftmp.197);
      goto <D.108653>;
      <D.108647>:
      <D.108653>:
      try
        {
          D.108654 = Gio::File_Class::init (&file_class_);
          if (1 == 0) goto <D.108656>; else goto <D.108657>;
          <D.108656>:
          iftmp.198 = 8B;
          goto <D.108658>;
          <D.108657>:
          iftmp.198 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108658>:
          D.108659 = &this->D.101656;
          Glib::Interface::Interface (D.108659, iftmp.198, D.108654);
          try
            {
              if (1 == 0) goto <D.108661>; else goto <D.108662>;
              <D.108661>:
              D.108663 = 0B;
              iftmp.199 = *D.108663;
              goto <D.108664>;
              <D.108662>:
              iftmp.199 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108664>:
              this->D.101656._vptr.Interface = iftmp.199;
              if (1 == 0) goto <D.108666>; else goto <D.108667>;
              <D.108666>:
              D.108668 = this->D.101656._vptr.Interface;
              D.108669 = D.108668 + 18446744073709551592;
              D.108670 = MEM[(long int *)D.108669];
              iftmp.200 = (sizetype) D.108670;
              goto <D.108671>;
              <D.108667>:
              iftmp.200 = 8;
              <D.108671>:
              D.108672 = this + iftmp.200;
              if (1 == 0) goto <D.108674>; else goto <D.108675>;
              <D.108674>:
              iftmp.201 = MEM[(const void * *)0B + 24B];
              goto <D.108676>;
              <D.108675>:
              iftmp.201 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108676>:
              D.108672->_vptr.ObjectBase = iftmp.201;
            }
          catch
            {
              if (1 == 0) goto <D.108678>; else goto <D.108679>;
              <D.108678>:
              iftmp.202 = 8B;
              goto <D.108680>;
              <D.108679>:
              iftmp.202 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108680>:
              D.108659 = &this->D.101656;
              Glib::Interface::~Interface (D.108659, iftmp.202);
            }
        }
      catch
        {
          if (1 != 0) goto <D.108681>; else goto <D.108682>;
          <D.108681>:
          if (1 == 0) goto <D.108684>; else goto <D.108685>;
          <D.108684>:
          iftmp.203 = 32B;
          goto <D.108686>;
          <D.108685>:
          iftmp.203 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108686>:
          D.108652 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108652, iftmp.203);
          goto <D.108687>;
          <D.108682>:
          <D.108687>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.108688>; else goto <D.108689>;
      <D.108688>:
      D.108644 = &this->D.101659;
      sigc::trackable::~trackable (D.108644);
      goto <D.108690>;
      <D.108689>:
      <D.108690>:
    }
}


Gio::File::File(GFile*) (struct File * const this, const void * * __vtt_parm, struct GFile * castitem)
{
  struct trackable * D.108696;
  const void * * iftmp.204;
  struct ObjectBase * D.108704;
  const void * * iftmp.205;
  struct Interface * D.108710;
  int (*__vtbl_ptr_type) () * iftmp.206;
  sizetype iftmp.207;
  int (*__vtbl_ptr_type) () * D.108718;
  int (*__vtbl_ptr_type) () * D.108719;
  long int D.108720;
  struct ObjectBase * D.108722;
  int (*__vtbl_ptr_type) () * iftmp.208;
  const void * * iftmp.209;
  const void * * iftmp.210;

  if (0 != 0) goto <D.108694>; else goto <D.108695>;
  <D.108694>:
  D.108696 = &this->D.101659;
  sigc::trackable::trackable (D.108696);
  goto <D.108697>;
  <D.108695>:
  <D.108697>:
  try
    {
      if (0 != 0) goto <D.108698>; else goto <D.108699>;
      <D.108698>:
      if (0 == 0) goto <D.108701>; else goto <D.108702>;
      <D.108701>:
      iftmp.204 = __vtt_parm + 32;
      goto <D.108703>;
      <D.108702>:
      iftmp.204 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108703>:
      D.108704 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108704, iftmp.204);
      goto <D.108705>;
      <D.108699>:
      <D.108705>:
      try
        {
          if (0 == 0) goto <D.108707>; else goto <D.108708>;
          <D.108707>:
          iftmp.205 = __vtt_parm + 8;
          goto <D.108709>;
          <D.108708>:
          iftmp.205 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108709>:
          D.108710 = &this->D.101656;
          Glib::Interface::Interface (D.108710, iftmp.205, castitem);
          try
            {
              if (0 == 0) goto <D.108712>; else goto <D.108713>;
              <D.108712>:
              iftmp.206 = *__vtt_parm;
              goto <D.108714>;
              <D.108713>:
              iftmp.206 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108714>:
              this->D.101656._vptr.Interface = iftmp.206;
              if (0 == 0) goto <D.108716>; else goto <D.108717>;
              <D.108716>:
              D.108718 = this->D.101656._vptr.Interface;
              D.108719 = D.108718 + 18446744073709551592;
              D.108720 = MEM[(long int *)D.108719];
              iftmp.207 = (sizetype) D.108720;
              goto <D.108721>;
              <D.108717>:
              iftmp.207 = 8;
              <D.108721>:
              D.108722 = this + iftmp.207;
              if (0 == 0) goto <D.108724>; else goto <D.108725>;
              <D.108724>:
              iftmp.208 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.108726>;
              <D.108725>:
              iftmp.208 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108726>:
              D.108722->_vptr.ObjectBase = iftmp.208;
            }
          catch
            {
              if (0 == 0) goto <D.108728>; else goto <D.108729>;
              <D.108728>:
              iftmp.209 = __vtt_parm + 8;
              goto <D.108730>;
              <D.108729>:
              iftmp.209 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108730>:
              D.108710 = &this->D.101656;
              Glib::Interface::~Interface (D.108710, iftmp.209);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108731>; else goto <D.108732>;
          <D.108731>:
          if (0 == 0) goto <D.108734>; else goto <D.108735>;
          <D.108734>:
          iftmp.210 = __vtt_parm + 32;
          goto <D.108736>;
          <D.108735>:
          iftmp.210 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108736>:
          D.108704 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108704, iftmp.210);
          goto <D.108737>;
          <D.108732>:
          <D.108737>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108738>; else goto <D.108739>;
      <D.108738>:
      D.108696 = &this->D.101659;
      sigc::trackable::~trackable (D.108696);
      goto <D.108740>;
      <D.108739>:
      <D.108740>:
    }
}


Gio::File::File(GFile*) (struct File * const this, struct GFile * castitem)
{
  struct trackable * D.108745;
  const void * * iftmp.211;
  struct ObjectBase * D.108753;
  const void * * iftmp.212;
  struct Interface * D.108759;
  int (*__vtbl_ptr_type) () * iftmp.213;
  const void * * D.108763;
  sizetype iftmp.214;
  int (*__vtbl_ptr_type) () * D.108768;
  int (*__vtbl_ptr_type) () * D.108769;
  long int D.108770;
  struct ObjectBase * D.108772;
  int (*__vtbl_ptr_type) () * iftmp.215;
  const void * * iftmp.216;
  const void * * iftmp.217;

  if (1 != 0) goto <D.108743>; else goto <D.108744>;
  <D.108743>:
  D.108745 = &this->D.101659;
  sigc::trackable::trackable (D.108745);
  goto <D.108746>;
  <D.108744>:
  <D.108746>:
  try
    {
      if (1 != 0) goto <D.108747>; else goto <D.108748>;
      <D.108747>:
      if (1 == 0) goto <D.108750>; else goto <D.108751>;
      <D.108750>:
      iftmp.211 = 32B;
      goto <D.108752>;
      <D.108751>:
      iftmp.211 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108752>:
      D.108753 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108753, iftmp.211);
      goto <D.108754>;
      <D.108748>:
      <D.108754>:
      try
        {
          if (1 == 0) goto <D.108756>; else goto <D.108757>;
          <D.108756>:
          iftmp.212 = 8B;
          goto <D.108758>;
          <D.108757>:
          iftmp.212 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108758>:
          D.108759 = &this->D.101656;
          Glib::Interface::Interface (D.108759, iftmp.212, castitem);
          try
            {
              if (1 == 0) goto <D.108761>; else goto <D.108762>;
              <D.108761>:
              D.108763 = 0B;
              iftmp.213 = *D.108763;
              goto <D.108764>;
              <D.108762>:
              iftmp.213 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108764>:
              this->D.101656._vptr.Interface = iftmp.213;
              if (1 == 0) goto <D.108766>; else goto <D.108767>;
              <D.108766>:
              D.108768 = this->D.101656._vptr.Interface;
              D.108769 = D.108768 + 18446744073709551592;
              D.108770 = MEM[(long int *)D.108769];
              iftmp.214 = (sizetype) D.108770;
              goto <D.108771>;
              <D.108767>:
              iftmp.214 = 8;
              <D.108771>:
              D.108772 = this + iftmp.214;
              if (1 == 0) goto <D.108774>; else goto <D.108775>;
              <D.108774>:
              iftmp.215 = MEM[(const void * *)0B + 24B];
              goto <D.108776>;
              <D.108775>:
              iftmp.215 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108776>:
              D.108772->_vptr.ObjectBase = iftmp.215;
            }
          catch
            {
              if (1 == 0) goto <D.108778>; else goto <D.108779>;
              <D.108778>:
              iftmp.216 = 8B;
              goto <D.108780>;
              <D.108779>:
              iftmp.216 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108780>:
              D.108759 = &this->D.101656;
              Glib::Interface::~Interface (D.108759, iftmp.216);
            }
        }
      catch
        {
          if (1 != 0) goto <D.108781>; else goto <D.108782>;
          <D.108781>:
          if (1 == 0) goto <D.108784>; else goto <D.108785>;
          <D.108784>:
          iftmp.217 = 32B;
          goto <D.108786>;
          <D.108785>:
          iftmp.217 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108786>:
          D.108753 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108753, iftmp.217);
          goto <D.108787>;
          <D.108782>:
          <D.108787>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.108788>; else goto <D.108789>;
      <D.108788>:
      D.108745 = &this->D.101659;
      sigc::trackable::~trackable (D.108745);
      goto <D.108790>;
      <D.108789>:
      <D.108790>:
    }
}


Gio::File::File(const Glib::Interface_Class&) (struct File * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.108795;
  const void * * iftmp.218;
  struct ObjectBase * D.108803;
  const void * * iftmp.219;
  struct Interface * D.108809;
  int (*__vtbl_ptr_type) () * iftmp.220;
  sizetype iftmp.221;
  int (*__vtbl_ptr_type) () * D.108817;
  int (*__vtbl_ptr_type) () * D.108818;
  long int D.108819;
  struct ObjectBase * D.108821;
  int (*__vtbl_ptr_type) () * iftmp.222;
  const void * * iftmp.223;
  const void * * iftmp.224;

  if (0 != 0) goto <D.108793>; else goto <D.108794>;
  <D.108793>:
  D.108795 = &this->D.101659;
  sigc::trackable::trackable (D.108795);
  goto <D.108796>;
  <D.108794>:
  <D.108796>:
  try
    {
      if (0 != 0) goto <D.108797>; else goto <D.108798>;
      <D.108797>:
      if (0 == 0) goto <D.108800>; else goto <D.108801>;
      <D.108800>:
      iftmp.218 = __vtt_parm + 32;
      goto <D.108802>;
      <D.108801>:
      iftmp.218 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108802>:
      D.108803 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108803, iftmp.218);
      goto <D.108804>;
      <D.108798>:
      <D.108804>:
      try
        {
          if (0 == 0) goto <D.108806>; else goto <D.108807>;
          <D.108806>:
          iftmp.219 = __vtt_parm + 8;
          goto <D.108808>;
          <D.108807>:
          iftmp.219 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108808>:
          D.108809 = &this->D.101656;
          Glib::Interface::Interface (D.108809, iftmp.219, interface_class);
          try
            {
              if (0 == 0) goto <D.108811>; else goto <D.108812>;
              <D.108811>:
              iftmp.220 = *__vtt_parm;
              goto <D.108813>;
              <D.108812>:
              iftmp.220 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108813>:
              this->D.101656._vptr.Interface = iftmp.220;
              if (0 == 0) goto <D.108815>; else goto <D.108816>;
              <D.108815>:
              D.108817 = this->D.101656._vptr.Interface;
              D.108818 = D.108817 + 18446744073709551592;
              D.108819 = MEM[(long int *)D.108818];
              iftmp.221 = (sizetype) D.108819;
              goto <D.108820>;
              <D.108816>:
              iftmp.221 = 8;
              <D.108820>:
              D.108821 = this + iftmp.221;
              if (0 == 0) goto <D.108823>; else goto <D.108824>;
              <D.108823>:
              iftmp.222 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.108825>;
              <D.108824>:
              iftmp.222 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108825>:
              D.108821->_vptr.ObjectBase = iftmp.222;
            }
          catch
            {
              if (0 == 0) goto <D.108827>; else goto <D.108828>;
              <D.108827>:
              iftmp.223 = __vtt_parm + 8;
              goto <D.108829>;
              <D.108828>:
              iftmp.223 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108829>:
              D.108809 = &this->D.101656;
              Glib::Interface::~Interface (D.108809, iftmp.223);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108830>; else goto <D.108831>;
          <D.108830>:
          if (0 == 0) goto <D.108833>; else goto <D.108834>;
          <D.108833>:
          iftmp.224 = __vtt_parm + 32;
          goto <D.108835>;
          <D.108834>:
          iftmp.224 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108835>:
          D.108803 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108803, iftmp.224);
          goto <D.108836>;
          <D.108831>:
          <D.108836>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108837>; else goto <D.108838>;
      <D.108837>:
      D.108795 = &this->D.101659;
      sigc::trackable::~trackable (D.108795);
      goto <D.108839>;
      <D.108838>:
      <D.108839>:
    }
}


Gio::File::File(const Glib::Interface_Class&) (struct File * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.108844;
  const void * * iftmp.225;
  struct ObjectBase * D.108852;
  const void * * iftmp.226;
  struct Interface * D.108858;
  int (*__vtbl_ptr_type) () * iftmp.227;
  const void * * D.108862;
  sizetype iftmp.228;
  int (*__vtbl_ptr_type) () * D.108867;
  int (*__vtbl_ptr_type) () * D.108868;
  long int D.108869;
  struct ObjectBase * D.108871;
  int (*__vtbl_ptr_type) () * iftmp.229;
  const void * * iftmp.230;
  const void * * iftmp.231;

  if (1 != 0) goto <D.108842>; else goto <D.108843>;
  <D.108842>:
  D.108844 = &this->D.101659;
  sigc::trackable::trackable (D.108844);
  goto <D.108845>;
  <D.108843>:
  <D.108845>:
  try
    {
      if (1 != 0) goto <D.108846>; else goto <D.108847>;
      <D.108846>:
      if (1 == 0) goto <D.108849>; else goto <D.108850>;
      <D.108849>:
      iftmp.225 = 32B;
      goto <D.108851>;
      <D.108850>:
      iftmp.225 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
      <D.108851>:
      D.108852 = &this->D.101658;
      Glib::ObjectBase::ObjectBase (D.108852, iftmp.225);
      goto <D.108853>;
      <D.108847>:
      <D.108853>:
      try
        {
          if (1 == 0) goto <D.108855>; else goto <D.108856>;
          <D.108855>:
          iftmp.226 = 8B;
          goto <D.108857>;
          <D.108856>:
          iftmp.226 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
          <D.108857>:
          D.108858 = &this->D.101656;
          Glib::Interface::Interface (D.108858, iftmp.226, interface_class);
          try
            {
              if (1 == 0) goto <D.108860>; else goto <D.108861>;
              <D.108860>:
              D.108862 = 0B;
              iftmp.227 = *D.108862;
              goto <D.108863>;
              <D.108861>:
              iftmp.227 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
              <D.108863>:
              this->D.101656._vptr.Interface = iftmp.227;
              if (1 == 0) goto <D.108865>; else goto <D.108866>;
              <D.108865>:
              D.108867 = this->D.101656._vptr.Interface;
              D.108868 = D.108867 + 18446744073709551592;
              D.108869 = MEM[(long int *)D.108868];
              iftmp.228 = (sizetype) D.108869;
              goto <D.108870>;
              <D.108866>:
              iftmp.228 = 8;
              <D.108870>:
              D.108871 = this + iftmp.228;
              if (1 == 0) goto <D.108873>; else goto <D.108874>;
              <D.108873>:
              iftmp.229 = MEM[(const void * *)0B + 24B];
              goto <D.108875>;
              <D.108874>:
              iftmp.229 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
              <D.108875>:
              D.108871->_vptr.ObjectBase = iftmp.229;
            }
          catch
            {
              if (1 == 0) goto <D.108877>; else goto <D.108878>;
              <D.108877>:
              iftmp.230 = 8B;
              goto <D.108879>;
              <D.108878>:
              iftmp.230 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
              <D.108879>:
              D.108858 = &this->D.101656;
              Glib::Interface::~Interface (D.108858, iftmp.230);
            }
        }
      catch
        {
          if (1 != 0) goto <D.108880>; else goto <D.108881>;
          <D.108880>:
          if (1 == 0) goto <D.108883>; else goto <D.108884>;
          <D.108883>:
          iftmp.231 = 32B;
          goto <D.108885>;
          <D.108884>:
          iftmp.231 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
          <D.108885>:
          D.108852 = &this->D.101658;
          Glib::ObjectBase::~ObjectBase (D.108852, iftmp.231);
          goto <D.108886>;
          <D.108881>:
          <D.108886>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.108887>; else goto <D.108888>;
      <D.108887>:
      D.108844 = &this->D.101659;
      sigc::trackable::~trackable (D.108844);
      goto <D.108889>;
      <D.108888>:
      <D.108889>:
    }
}


Gio::File::~File() (struct File * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.232;
  sizetype iftmp.233;
  int (*__vtbl_ptr_type) () * D.108899;
  int (*__vtbl_ptr_type) () * D.108900;
  long int D.108901;
  struct ObjectBase * D.108903;
  int (*__vtbl_ptr_type) () * iftmp.234;
  const void * * iftmp.235;
  struct Interface * D.108912;
  int D.108913;
  const void * * iftmp.236;
  struct ObjectBase * D.108920;
  struct trackable * D.108924;
  int D.108926;

  {
    if (0 == 0) goto <D.108893>; else goto <D.108894>;
    <D.108893>:
    iftmp.232 = *__vtt_parm;
    goto <D.108895>;
    <D.108894>:
    iftmp.232 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
    <D.108895>:
    this->D.101656._vptr.Interface = iftmp.232;
    if (0 == 0) goto <D.108897>; else goto <D.108898>;
    <D.108897>:
    D.108899 = this->D.101656._vptr.Interface;
    D.108900 = D.108899 + 18446744073709551592;
    D.108901 = MEM[(long int *)D.108900];
    iftmp.233 = (sizetype) D.108901;
    goto <D.108902>;
    <D.108898>:
    iftmp.233 = 8;
    <D.108902>:
    D.108903 = this + iftmp.233;
    if (0 == 0) goto <D.108905>; else goto <D.108906>;
    <D.108905>:
    iftmp.234 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.108907>;
    <D.108906>:
    iftmp.234 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
    <D.108907>:
    D.108903->_vptr.ObjectBase = iftmp.234;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.108909>; else goto <D.108910>;
                    <D.108909>:
                    iftmp.235 = __vtt_parm + 8;
                    goto <D.108911>;
                    <D.108910>:
                    iftmp.235 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
                    <D.108911>:
                    D.108912 = &this->D.101656;
                    Glib::Interface::~Interface (D.108912, iftmp.235);
                  }
              }
            finally
              {
                D.108913 = 0;
                if (D.108913 != 0) goto <D.108914>; else goto <D.108915>;
                <D.108914>:
                if (0 == 0) goto <D.108917>; else goto <D.108918>;
                <D.108917>:
                iftmp.236 = __vtt_parm + 32;
                goto <D.108919>;
                <D.108918>:
                iftmp.236 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
                <D.108919>:
                D.108920 = &this->D.101658;
                Glib::ObjectBase::~ObjectBase (D.108920, iftmp.236);
                goto <D.108921>;
                <D.108915>:
                <D.108921>:
              }
          }
        finally
          {
            D.108913 = 0;
            if (D.108913 != 0) goto <D.108922>; else goto <D.108923>;
            <D.108922>:
            D.108924 = &this->D.101659;
            sigc::trackable::~trackable (D.108924);
            goto <D.108925>;
            <D.108923>:
            <D.108925>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104926>:
  D.108926 = 0;
  if (D.108926 != 0) goto <D.108927>; else goto <D.108928>;
  <D.108927>:
  operator delete (this);
  goto <D.108929>;
  <D.108928>:
  <D.108929>:
}


virtual Gio::File::~File() (struct File * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.237;
  const void * * D.108945;
  sizetype iftmp.238;
  int (*__vtbl_ptr_type) () * D.108950;
  int (*__vtbl_ptr_type) () * D.108951;
  long int D.108952;
  struct ObjectBase * D.108954;
  int (*__vtbl_ptr_type) () * iftmp.239;
  const void * * iftmp.240;
  struct Interface * D.108963;
  int D.108964;
  const void * * iftmp.241;
  struct ObjectBase * D.108971;
  struct trackable * D.108975;
  int D.108977;

  {
    if (2 == 0) goto <D.108943>; else goto <D.108944>;
    <D.108943>:
    D.108945 = 0B;
    iftmp.237 = *D.108945;
    goto <D.108946>;
    <D.108944>:
    iftmp.237 = &MEM[(void *)&_ZTVN3Gio4FileE + 32B];
    <D.108946>:
    this->D.101656._vptr.Interface = iftmp.237;
    if (2 == 0) goto <D.108948>; else goto <D.108949>;
    <D.108948>:
    D.108950 = this->D.101656._vptr.Interface;
    D.108951 = D.108950 + 18446744073709551592;
    D.108952 = MEM[(long int *)D.108951];
    iftmp.238 = (sizetype) D.108952;
    goto <D.108953>;
    <D.108949>:
    iftmp.238 = 8;
    <D.108953>:
    D.108954 = this + iftmp.238;
    if (2 == 0) goto <D.108956>; else goto <D.108957>;
    <D.108956>:
    iftmp.239 = MEM[(const void * *)0B + 24B];
    goto <D.108958>;
    <D.108957>:
    iftmp.239 = &MEM[(void *)&_ZTVN3Gio4FileE + 112B];
    <D.108958>:
    D.108954->_vptr.ObjectBase = iftmp.239;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.108960>; else goto <D.108961>;
                    <D.108960>:
                    iftmp.240 = 8B;
                    goto <D.108962>;
                    <D.108961>:
                    iftmp.240 = &MEM[(void *)&_ZTTN3Gio4FileE + 8B];
                    <D.108962>:
                    D.108963 = &this->D.101656;
                    Glib::Interface::~Interface (D.108963, iftmp.240);
                  }
              }
            finally
              {
                D.108964 = 2;
                if (D.108964 != 0) goto <D.108965>; else goto <D.108966>;
                <D.108965>:
                if (2 == 0) goto <D.108968>; else goto <D.108969>;
                <D.108968>:
                iftmp.241 = 32B;
                goto <D.108970>;
                <D.108969>:
                iftmp.241 = &MEM[(void *)&_ZTTN3Gio4FileE + 32B];
                <D.108970>:
                D.108971 = &this->D.101658;
                Glib::ObjectBase::~ObjectBase (D.108971, iftmp.241);
                goto <D.108972>;
                <D.108966>:
                <D.108972>:
              }
          }
        finally
          {
            D.108964 = 2;
            if (D.108964 != 0) goto <D.108973>; else goto <D.108974>;
            <D.108973>:
            D.108975 = &this->D.101659;
            sigc::trackable::~trackable (D.108975);
            goto <D.108976>;
            <D.108974>:
            <D.108976>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104929>:
  D.108977 = 0;
  if (D.108977 != 0) goto <D.108978>; else goto <D.108979>;
  <D.108978>:
  operator delete (this);
  goto <D.108980>;
  <D.108979>:
  <D.108980>:
}


virtual Gio::File::~File() (struct File * const this)
{
  Gio::File::~File (this);
  <D.104934>:
  operator delete (this);
}


static void Gio::File::add_interface(GType) (GType gtype_implementer)
{
  const struct Interface_Class & D.108993;

  D.108993 = Gio::File_Class::init (&file_class_);
  Glib::Interface_Class::add_interface (D.108993, gtype_implementer);
}


static GType Gio::File::get_type() ()
{
  GType D.108995;
  const struct Interface_Class & D.108996;
  const struct Class * D.108997;

  D.108996 = Gio::File_Class::init (&file_class_);
  D.108997 = &D.108996->D.101877;
  D.108995 = Glib::Class::get_type (D.108997);
  return D.108995;
}


GType Glib::Class::get_type() const (const struct Class * const this)
{
  GType D.109000;

  D.109000 = this->gtype_;
  return D.109000;
}


static GType Gio::File::get_base_type() ()
{
  GType D.109002;

  D.109002 = g_file_get_type ();
  return D.109002;
}


Glib::RefPtr<Gio::File> Gio::File::dup() const (const struct File * const this)
{
  const struct GFile * D.109006;
  struct GFile * D.109007;

  D.109006 = Gio::File::gobj (this);
  D.109007 = g_file_dup (D.109006);
  *<retval> = Glib::wrap (D.109007, 0); [return slot optimization]
  return <retval>;
}


guint Gio::File::hash() const (const struct File * const this)
{
  guint D.109010;
  const struct GFile * D.109011;

  D.109011 = Gio::File::gobj (this);
  D.109010 = g_file_hash (D.109011);
  return D.109010;
}


bool Gio::File::equal(const Glib::RefPtr<const Gio::File>&) const (const struct File * const this, const struct RefPtr & other)
{
  bool D.109014;
  const struct BaseObjectType * D.109015;
  const struct GFile * D.109016;
  int D.109017;

  D.109015 = Glib::unwrap<Gio::File> (other);
  D.109016 = Gio::File::gobj (this);
  D.109017 = g_file_equal (D.109016, D.109015);
  D.109014 = D.109017 != 0;
  return D.109014;
}


const typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<const T>&) [with T = Gio::File; typename T::BaseObjectType = _GFile] (const struct RefPtr & ptr)
{
  const struct BaseObjectType * D.109021;
  const struct BaseObjectType * iftmp.242;
  bool D.109023;
  const struct File * D.109026;

  D.109023 = Glib::RefPtr<const Gio::File>::operator bool (ptr);
  if (D.109023 != 0) goto <D.109024>; else goto <D.109025>;
  <D.109024>:
  D.109026 = Glib::RefPtr<const Gio::File>::operator-> (ptr);
  iftmp.242 = Gio::File::gobj (D.109026);
  goto <D.109027>;
  <D.109025>:
  iftmp.242 = 0B;
  <D.109027>:
  D.109021 = iftmp.242;
  return D.109021;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = const Gio::File] (const struct RefPtr * const this)
{
  bool D.109029;
  const struct File * D.109030;

  D.109030 = this->pCppObject_;
  D.109029 = D.109030 != 0B;
  return D.109029;
}


T_CppObject* Glib::RefPtr<T_CppObject>::operator->() const [with T_CppObject = const Gio::File] (const struct RefPtr * const this)
{
  const struct File * D.109032;

  D.109032 = this->pCppObject_;
  return D.109032;
}


std::string Gio::File::get_basename() const (const struct File * const this)
{
  const struct GFile * D.109035;
  char * D.109036;

  D.109035 = Gio::File::gobj (this);
  D.109036 = g_file_get_basename (D.109035);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.109036); [return slot optimization]
  return <retval>;
}


std::string Gio::File::get_path() const (const struct File * const this)
{
  const struct GFile * D.109040;
  char * D.109041;

  D.109040 = Gio::File::gobj (this);
  D.109041 = g_file_get_path (D.109040);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.109041); [return slot optimization]
  return <retval>;
}


std::string Gio::File::get_uri() const (const struct File * const this)
{
  const struct GFile * D.109045;
  char * D.109046;

  D.109045 = Gio::File::gobj (this);
  D.109046 = g_file_get_uri (D.109045);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.109046); [return slot optimization]
  return <retval>;
}


Glib::ustring Gio::File::get_parse_name() const (const struct File * const this)
{
  const struct GFile * D.109050;
  char * D.109051;

  D.109050 = Gio::File::gobj (this);
  D.109051 = g_file_get_parse_name (D.109050);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.109051); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.243;
  char * D.109060;
  struct ustring * D.109061;

  cleanup.243 = 0;
  try
    {
      if (str != 0B) goto <D.109055>; else goto <D.109056>;
      <D.109055>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.243 = 1;
      D.109060 = Glib::ScopedPtr<char>::get (&D.78974);
      D.109061 = <retval>;
      Glib::ustring::ustring (D.109061, D.109060);
      goto <D.109062>;
      <D.109056>:
      D.109061 = <retval>;
      Glib::ustring::ustring (D.109061);
      <D.109062>:
      return <retval>;
    }
  finally
    {
      if (cleanup.243 != 0) goto <D.109058>; else goto <D.109059>;
      <D.109058>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.109059>:
    }
}


Glib::RefPtr<Gio::File> Gio::File::get_parent() const (const struct File * const this)
{
  const struct GFile * D.109069;
  struct GFile * D.109070;

  D.109069 = Gio::File::gobj (this);
  D.109070 = g_file_get_parent (D.109069);
  *<retval> = Glib::wrap (D.109070, 0); [return slot optimization]
  return <retval>;
}


bool Gio::File::has_parent(const Glib::RefPtr<Gio::File>&) const (const struct File * const this, const struct RefPtr & parent)
{
  bool D.109073;
  struct BaseObjectType * D.109074;
  const struct GFile * D.109075;
  int D.109076;

  D.109074 = Glib::unwrap<Gio::File> (parent);
  D.109075 = Gio::File::gobj (this);
  D.109076 = g_file_has_parent (D.109075, D.109074);
  D.109073 = D.109076 != 0;
  return D.109073;
}


Glib::RefPtr<Gio::File> Gio::File::get_child(const string&) const (const struct File * const this, const struct string & name)
{
  const char * D.109081;
  const struct GFile * D.109082;
  struct GFile * D.109083;

  D.109081 = std::basic_string<char>::c_str (name);
  D.109082 = Gio::File::gobj (this);
  D.109083 = g_file_get_child (D.109082, D.109081);
  *<retval> = Glib::wrap (D.109083, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Gio::File> Gio::File::get_child_for_display_name(const Glib::ustring&) const (const struct File * const this, const struct ustring & display_name)
{
  const char * D.109088;
  const struct GFile * D.109089;
  struct GFile * D.109090;
  struct GError * gerror.244;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109088 = Glib::ustring::c_str (display_name);
      D.109089 = Gio::File::gobj (this);
      D.109090 = g_file_get_child_for_display_name (D.109089, D.109088, &gerror);
      *<retval> = Glib::wrap (D.109090, 0); [return slot optimization]
      try
        {
          gerror.244 = gerror;
          if (gerror.244 != 0B) goto <D.109092>; else goto <D.109093>;
          <D.109092>:
          gerror.244 = gerror;
          Glib::Error::throw_exception (gerror.244);
          <D.109093>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::File>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::File] (struct RefPtr * const this)
{
  struct File * D.109100;
  int (*__vtbl_ptr_type) () * D.109103;
  int (*__vtbl_ptr_type) () * D.109104;
  long int D.109105;
  sizetype D.109106;
  struct ObjectBase * D.109107;
  int (*__vtbl_ptr_type) () * D.109108;
  int (*__vtbl_ptr_type) () * D.109109;
  int (*__vtbl_ptr_type) () D.109110;

  {
    try
      {
        D.109100 = this->pCppObject_;
        if (D.109100 != 0B) goto <D.109101>; else goto <D.109102>;
        <D.109101>:
        D.109100 = this->pCppObject_;
        D.109100 = this->pCppObject_;
        D.109103 = D.109100->D.101656._vptr.Interface;
        D.109104 = D.109103 + 18446744073709551592;
        D.109105 = MEM[(long int *)D.109104];
        D.109106 = (sizetype) D.109105;
        D.109107 = D.109100 + D.109106;
        D.109100 = this->pCppObject_;
        D.109100 = this->pCppObject_;
        D.109103 = D.109100->D.101656._vptr.Interface;
        D.109104 = D.109103 + 18446744073709551592;
        D.109105 = MEM[(long int *)D.109104];
        D.109106 = (sizetype) D.109105;
        D.109107 = D.109100 + D.109106;
        D.109108 = D.109107->_vptr.ObjectBase;
        D.109109 = D.109108 + 24;
        D.109110 = *D.109109;
        D.109100 = this->pCppObject_;
        D.109100 = this->pCppObject_;
        D.109103 = D.109100->D.101656._vptr.Interface;
        D.109104 = D.109103 + 18446744073709551592;
        D.109105 = MEM[(long int *)D.109104];
        D.109106 = (sizetype) D.109105;
        D.109107 = D.109100 + D.109106;
        OBJ_TYPE_REF(D.109110;(const struct ObjectBase)D.109107->3) (D.109107);
        goto <D.109111>;
        <D.109102>:
        <D.109111>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106372>:
}


bool Gio::File::has_prefix(const Glib::RefPtr<const Gio::File>&) const (const struct File * const this, const struct RefPtr & prefix)
{
  bool D.109113;
  const struct BaseObjectType * D.109114;
  const struct GFile * D.109115;
  int D.109116;

  D.109114 = Glib::unwrap<Gio::File> (prefix);
  D.109115 = Gio::File::gobj (this);
  D.109116 = g_file_has_prefix (D.109115, D.109114);
  D.109113 = D.109116 != 0;
  return D.109113;
}


std::string Gio::File::get_relative_path(const Glib::RefPtr<const Gio::File>&) const (const struct File * const this, const struct RefPtr & descendant)
{
  const struct BaseObjectType * D.109121;
  const struct GFile * D.109122;
  char * D.109123;

  D.109121 = Glib::unwrap<Gio::File> (descendant);
  D.109122 = Gio::File::gobj (this);
  D.109123 = g_file_get_relative_path (D.109122, D.109121);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.109123); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Gio::File> Gio::File::resolve_relative_path(const string&) const (const struct File * const this, const struct string & relative_path)
{
  const char * D.109128;
  const struct GFile * D.109129;
  struct GFile * D.109130;

  D.109128 = std::basic_string<char>::c_str (relative_path);
  D.109129 = Gio::File::gobj (this);
  D.109130 = g_file_resolve_relative_path (D.109129, D.109128);
  *<retval> = Glib::wrap (D.109130, 0); [return slot optimization]
  return <retval>;
}


bool Gio::File::is_native() const (const struct File * const this)
{
  bool D.109134;
  const struct GFile * D.109135;
  int D.109136;

  D.109135 = Gio::File::gobj (this);
  D.109136 = g_file_is_native (D.109135);
  D.109134 = D.109136 != 0;
  return D.109134;
}


bool Gio::File::has_uri_scheme(const string&) const (const struct File * const this, const struct string & uri_scheme)
{
  bool D.109139;
  const char * D.109140;
  const struct GFile * D.109141;
  int D.109142;

  D.109140 = std::basic_string<char>::c_str (uri_scheme);
  D.109141 = Gio::File::gobj (this);
  D.109142 = g_file_has_uri_scheme (D.109141, D.109140);
  D.109139 = D.109142 != 0;
  return D.109139;
}


std::string Gio::File::get_uri_scheme() const (const struct File * const this)
{
  const struct GFile * D.109147;
  char * D.109148;

  D.109147 = Gio::File::gobj (this);
  D.109148 = g_file_get_uri_scheme (D.109147);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.109148); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Gio::FileInputStream> Gio::File::read(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109152;
  struct GFile * D.109153;
  struct GFileInputStream * D.109154;
  struct GError * gerror.245;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109152 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109153 = Gio::File::gobj (this);
      D.109154 = g_file_read (D.109153, D.109152, &gerror);
      *<retval> = Glib::wrap (D.109154, 0); [return slot optimization]
      try
        {
          gerror.245 = gerror;
          if (gerror.245 != 0B) goto <D.109156>; else goto <D.109157>;
          <D.109156>:
          gerror.245 = gerror;
          Glib::Error::throw_exception (gerror.245);
          <D.109157>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileInputStream] (struct RefPtr * const this)
{
  struct FileInputStream * D.109164;
  int (*__vtbl_ptr_type) () * D.109167;
  int (*__vtbl_ptr_type) () * D.109168;
  long int D.109169;
  sizetype D.109170;
  struct ObjectBase * D.109171;
  int (*__vtbl_ptr_type) () * D.109172;
  int (*__vtbl_ptr_type) () * D.109173;
  int (*__vtbl_ptr_type) () D.109174;

  {
    try
      {
        D.109164 = this->pCppObject_;
        if (D.109164 != 0B) goto <D.109165>; else goto <D.109166>;
        <D.109165>:
        D.109164 = this->pCppObject_;
        D.109164 = this->pCppObject_;
        D.109167 = D.109164->D.98257.D.98002._vptr.Object;
        D.109168 = D.109167 + 18446744073709551592;
        D.109169 = MEM[(long int *)D.109168];
        D.109170 = (sizetype) D.109169;
        D.109171 = D.109164 + D.109170;
        D.109164 = this->pCppObject_;
        D.109164 = this->pCppObject_;
        D.109167 = D.109164->D.98257.D.98002._vptr.Object;
        D.109168 = D.109167 + 18446744073709551592;
        D.109169 = MEM[(long int *)D.109168];
        D.109170 = (sizetype) D.109169;
        D.109171 = D.109164 + D.109170;
        D.109172 = D.109171->_vptr.ObjectBase;
        D.109173 = D.109172 + 24;
        D.109174 = *D.109173;
        D.109164 = this->pCppObject_;
        D.109164 = this->pCppObject_;
        D.109167 = D.109164->D.98257.D.98002._vptr.Object;
        D.109168 = D.109167 + 18446744073709551592;
        D.109169 = MEM[(long int *)D.109168];
        D.109170 = (sizetype) D.109169;
        D.109171 = D.109164 + D.109170;
        OBJ_TYPE_REF(D.109174;(const struct ObjectBase)D.109171->3) (D.109171);
        goto <D.109175>;
        <D.109166>:
        <D.109175>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106521>:
}


Glib::RefPtr<Gio::FileInputStream> Gio::File::read() (struct File * const this)
{
  struct GFile * D.109178;
  struct GFileInputStream * D.109179;
  struct GError * gerror.246;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109178 = Gio::File::gobj (this);
      D.109179 = g_file_read (D.109178, 0B, &gerror);
      *<retval> = Glib::wrap (D.109179, 0); [return slot optimization]
      try
        {
          gerror.246 = gerror;
          if (gerror.246 != 0B) goto <D.109181>; else goto <D.109182>;
          <D.109181>:
          gerror.246 = gerror;
          Glib::Error::throw_exception (gerror.246);
          <D.109182>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileInputStream> Gio::File::read_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109189;
  struct GFile * D.109190;
  struct GFileInputStream * D.109191;
  struct GError * gerror.247;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109189 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109190 = Gio::File::gobj (this);
      D.109191 = g_file_read_finish (D.109190, D.109189, &gerror);
      *<retval> = Glib::wrap (D.109191, 0); [return slot optimization]
      try
        {
          gerror.247 = gerror;
          if (gerror.247 != 0B) goto <D.109193>; else goto <D.109194>;
          <D.109193>:
          gerror.247 = gerror;
          Glib::Error::throw_exception (gerror.247);
          <D.109194>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::append_to_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109202;
  struct GFile * D.109203;
  struct GFileOutputStream * D.109204;
  struct GError * gerror.248;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109202 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109203 = Gio::File::gobj (this);
      D.109204 = g_file_append_to_finish (D.109203, D.109202, &gerror);
      *<retval> = Glib::wrap (D.109204, 0); [return slot optimization]
      try
        {
          gerror.248 = gerror;
          if (gerror.248 != 0B) goto <D.109206>; else goto <D.109207>;
          <D.109206>:
          gerror.248 = gerror;
          Glib::Error::throw_exception (gerror.248);
          <D.109207>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::create_file_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109215;
  struct GFile * D.109216;
  struct GFileOutputStream * D.109217;
  struct GError * gerror.249;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109215 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109216 = Gio::File::gobj (this);
      D.109217 = g_file_create_finish (D.109216, D.109215, &gerror);
      *<retval> = Glib::wrap (D.109217, 0); [return slot optimization]
      try
        {
          gerror.249 = gerror;
          if (gerror.249 != 0B) goto <D.109219>; else goto <D.109220>;
          <D.109219>:
          gerror.249 = gerror;
          Glib::Error::throw_exception (gerror.249);
          <D.109220>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::create_file_readwrite_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109228;
  struct GFile * D.109229;
  struct GFileIOStream * D.109230;
  struct GError * gerror.250;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109228 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109229 = Gio::File::gobj (this);
      D.109230 = g_file_create_readwrite_finish (D.109229, D.109228, &gerror);
      *<retval> = Glib::wrap (D.109230, 0); [return slot optimization]
      try
        {
          gerror.250 = gerror;
          if (gerror.250 != 0B) goto <D.109232>; else goto <D.109233>;
          <D.109232>:
          gerror.250 = gerror;
          Glib::Error::throw_exception (gerror.250);
          <D.109233>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileOutputStream> Gio::File::replace_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109241;
  struct GFile * D.109242;
  struct GFileOutputStream * D.109243;
  struct GError * gerror.251;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109241 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109242 = Gio::File::gobj (this);
      D.109243 = g_file_replace_finish (D.109242, D.109241, &gerror);
      *<retval> = Glib::wrap (D.109243, 0); [return slot optimization]
      try
        {
          gerror.251 = gerror;
          if (gerror.251 != 0B) goto <D.109245>; else goto <D.109246>;
          <D.109245>:
          gerror.251 = gerror;
          Glib::Error::throw_exception (gerror.251);
          <D.109246>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileOutputStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::open_readwrite(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109254;
  struct GFile * D.109255;
  struct GFileIOStream * D.109256;
  struct GError * gerror.252;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109254 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109255 = Gio::File::gobj (this);
      D.109256 = g_file_open_readwrite (D.109255, D.109254, &gerror);
      *<retval> = Glib::wrap (D.109256, 0); [return slot optimization]
      try
        {
          gerror.252 = gerror;
          if (gerror.252 != 0B) goto <D.109258>; else goto <D.109259>;
          <D.109258>:
          gerror.252 = gerror;
          Glib::Error::throw_exception (gerror.252);
          <D.109259>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::open_readwrite() (struct File * const this)
{
  struct GFile * D.109267;
  struct GFileIOStream * D.109268;
  struct GError * gerror.253;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109267 = Gio::File::gobj (this);
      D.109268 = g_file_open_readwrite (D.109267, 0B, &gerror);
      *<retval> = Glib::wrap (D.109268, 0); [return slot optimization]
      try
        {
          gerror.253 = gerror;
          if (gerror.253 != 0B) goto <D.109270>; else goto <D.109271>;
          <D.109270>:
          gerror.253 = gerror;
          Glib::Error::throw_exception (gerror.253);
          <D.109271>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::open_readwrite_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109278;
  struct GFile * D.109279;
  struct GFileIOStream * D.109280;
  struct GError * gerror.254;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109278 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109279 = Gio::File::gobj (this);
      D.109280 = g_file_open_readwrite_finish (D.109279, D.109278, &gerror);
      *<retval> = Glib::wrap (D.109280, 0); [return slot optimization]
      try
        {
          gerror.254 = gerror;
          if (gerror.254 != 0B) goto <D.109282>; else goto <D.109283>;
          <D.109282>:
          gerror.254 = gerror;
          Glib::Error::throw_exception (gerror.254);
          <D.109283>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileIOStream> Gio::File::replace_readwrite_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109291;
  struct GFile * D.109292;
  struct GFileIOStream * D.109293;
  struct GError * gerror.255;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109291 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109292 = Gio::File::gobj (this);
      D.109293 = g_file_replace_readwrite_finish (D.109292, D.109291, &gerror);
      *<retval> = Glib::wrap (D.109293, 0); [return slot optimization]
      try
        {
          gerror.255 = gerror;
          if (gerror.255 != 0B) goto <D.109295>; else goto <D.109296>;
          <D.109295>:
          gerror.255 = gerror;
          Glib::Error::throw_exception (gerror.255);
          <D.109296>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileIOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::query_exists(const Glib::RefPtr<Gio::Cancellable>&) const (const struct File * const this, const struct RefPtr & cancellable)
{
  bool D.109303;
  struct BaseObjectType * D.109304;
  const struct GFile * D.109305;
  int D.109306;

  D.109304 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.109305 = Gio::File::gobj (this);
  D.109306 = g_file_query_exists (D.109305, D.109304);
  D.109303 = D.109306 != 0;
  return D.109303;
}


bool Gio::File::query_exists() const (const struct File * const this)
{
  bool D.109310;
  const struct GFile * D.109311;
  int D.109312;

  D.109311 = Gio::File::gobj (this);
  D.109312 = g_file_query_exists (D.109311, 0B);
  D.109310 = D.109312 != 0;
  return D.109310;
}


Gio::FileType Gio::File::query_file_type(Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) const (const struct File * const this, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  FileType D.109315;
  struct BaseObjectType * D.109316;
  const struct GFile * D.109317;

  D.109316 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.109317 = Gio::File::gobj (this);
  D.109315 = g_file_query_file_type (D.109317, flags, D.109316);
  return D.109315;
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_info_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109322;
  struct GFile * D.109323;
  struct GFileInfo * D.109324;
  struct GError * gerror.256;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109322 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109323 = Gio::File::gobj (this);
      D.109324 = g_file_query_info_finish (D.109323, D.109322, &gerror);
      *<retval> = Glib::wrap (D.109324, 0); [return slot optimization]
      try
        {
          gerror.256 = gerror;
          if (gerror.256 != 0B) goto <D.109326>; else goto <D.109327>;
          <D.109326>:
          gerror.256 = gerror;
          Glib::Error::throw_exception (gerror.256);
          <D.109327>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Mount> Gio::File::find_enclosing_mount(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109335;
  struct GFile * D.109336;
  struct GMount * D.109337;
  struct GError * gerror.257;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109335 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109336 = Gio::File::gobj (this);
      D.109337 = g_file_find_enclosing_mount (D.109336, D.109335, &gerror);
      *<retval> = Glib::wrap (D.109337, 0); [return slot optimization]
      try
        {
          gerror.257 = gerror;
          if (gerror.257 != 0B) goto <D.109339>; else goto <D.109340>;
          <D.109339>:
          gerror.257 = gerror;
          Glib::Error::throw_exception (gerror.257);
          <D.109340>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Mount>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Mount] (struct RefPtr * const this)
{
  struct Mount * D.109347;
  int (*__vtbl_ptr_type) () * D.109350;
  int (*__vtbl_ptr_type) () * D.109351;
  long int D.109352;
  sizetype D.109353;
  struct ObjectBase * D.109354;
  int (*__vtbl_ptr_type) () * D.109355;
  int (*__vtbl_ptr_type) () * D.109356;
  int (*__vtbl_ptr_type) () D.109357;

  {
    try
      {
        D.109347 = this->pCppObject_;
        if (D.109347 != 0B) goto <D.109348>; else goto <D.109349>;
        <D.109348>:
        D.109347 = this->pCppObject_;
        D.109347 = this->pCppObject_;
        D.109350 = D.109347->D.99699._vptr.Interface;
        D.109351 = D.109350 + 18446744073709551592;
        D.109352 = MEM[(long int *)D.109351];
        D.109353 = (sizetype) D.109352;
        D.109354 = D.109347 + D.109353;
        D.109347 = this->pCppObject_;
        D.109347 = this->pCppObject_;
        D.109350 = D.109347->D.99699._vptr.Interface;
        D.109351 = D.109350 + 18446744073709551592;
        D.109352 = MEM[(long int *)D.109351];
        D.109353 = (sizetype) D.109352;
        D.109354 = D.109347 + D.109353;
        D.109355 = D.109354->_vptr.ObjectBase;
        D.109356 = D.109355 + 24;
        D.109357 = *D.109356;
        D.109347 = this->pCppObject_;
        D.109347 = this->pCppObject_;
        D.109350 = D.109347->D.99699._vptr.Interface;
        D.109351 = D.109350 + 18446744073709551592;
        D.109352 = MEM[(long int *)D.109351];
        D.109353 = (sizetype) D.109352;
        D.109354 = D.109347 + D.109353;
        OBJ_TYPE_REF(D.109357;(const struct ObjectBase)D.109354->3) (D.109354);
        goto <D.109358>;
        <D.109349>:
        <D.109358>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106350>:
}


Glib::RefPtr<Gio::Mount> Gio::File::find_enclosing_mount() (struct File * const this)
{
  struct GFile * D.109361;
  struct GMount * D.109362;
  struct GError * gerror.258;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109361 = Gio::File::gobj (this);
      D.109362 = g_file_find_enclosing_mount (D.109361, 0B, &gerror);
      *<retval> = Glib::wrap (D.109362, 0); [return slot optimization]
      try
        {
          gerror.258 = gerror;
          if (gerror.258 != 0B) goto <D.109364>; else goto <D.109365>;
          <D.109364>:
          gerror.258 = gerror;
          Glib::Error::throw_exception (gerror.258);
          <D.109365>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Mount>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileInfo> Gio::File::query_filesystem_info_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109372;
  struct GFile * D.109373;
  struct GFileInfo * D.109374;
  struct GError * gerror.259;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109372 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109373 = Gio::File::gobj (this);
      D.109374 = g_file_query_filesystem_info_finish (D.109373, D.109372, &gerror);
      *<retval> = Glib::wrap (D.109374, 0); [return slot optimization]
      try
        {
          gerror.259 = gerror;
          if (gerror.259 != 0B) goto <D.109376>; else goto <D.109377>;
          <D.109376>:
          gerror.259 = gerror;
          Glib::Error::throw_exception (gerror.259);
          <D.109377>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Mount> Gio::File::find_enclosing_mount_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109385;
  struct GFile * D.109386;
  struct GMount * D.109387;
  struct GError * gerror.260;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109385 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109386 = Gio::File::gobj (this);
      D.109387 = g_file_find_enclosing_mount_finish (D.109386, D.109385, &gerror);
      *<retval> = Glib::wrap (D.109387, 0); [return slot optimization]
      try
        {
          gerror.260 = gerror;
          if (gerror.260 != 0B) goto <D.109389>; else goto <D.109390>;
          <D.109389>:
          gerror.260 = gerror;
          Glib::Error::throw_exception (gerror.260);
          <D.109390>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Mount>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileEnumerator> Gio::File::enumerate_children_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109398;
  struct GFile * D.109399;
  struct GFileEnumerator * D.109400;
  struct GError * gerror.261;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109398 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109399 = Gio::File::gobj (this);
      D.109400 = g_file_enumerate_children_finish (D.109399, D.109398, &gerror);
      *<retval> = Glib::wrap (D.109400, 0); [return slot optimization]
      try
        {
          gerror.261 = gerror;
          if (gerror.261 != 0B) goto <D.109402>; else goto <D.109403>;
          <D.109402>:
          gerror.261 = gerror;
          Glib::Error::throw_exception (gerror.261);
          <D.109403>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileEnumerator>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::File> Gio::File::set_display_name(const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct ustring & display_name, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109411;
  const char * D.109412;
  struct GFile * D.109413;
  struct GFile * D.109414;
  struct GError * gerror.262;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109411 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109412 = Glib::ustring::c_str (display_name);
      D.109413 = Gio::File::gobj (this);
      D.109414 = g_file_set_display_name (D.109413, D.109412, D.109411, &gerror);
      *<retval> = Glib::wrap (D.109414, 0); [return slot optimization]
      try
        {
          gerror.262 = gerror;
          if (gerror.262 != 0B) goto <D.109416>; else goto <D.109417>;
          <D.109416>:
          gerror.262 = gerror;
          Glib::Error::throw_exception (gerror.262);
          <D.109417>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::File>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::File> Gio::File::set_display_name(const Glib::ustring&) (struct File * const this, const struct ustring & display_name)
{
  const char * D.109426;
  struct GFile * D.109427;
  struct GFile * D.109428;
  struct GError * gerror.263;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109426 = Glib::ustring::c_str (display_name);
      D.109427 = Gio::File::gobj (this);
      D.109428 = g_file_set_display_name (D.109427, D.109426, 0B, &gerror);
      *<retval> = Glib::wrap (D.109428, 0); [return slot optimization]
      try
        {
          gerror.263 = gerror;
          if (gerror.263 != 0B) goto <D.109430>; else goto <D.109431>;
          <D.109430>:
          gerror.263 = gerror;
          Glib::Error::throw_exception (gerror.263);
          <D.109431>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::File>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::File> Gio::File::set_display_name_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109439;
  struct GFile * D.109440;
  struct GFile * D.109441;
  struct GError * gerror.264;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109439 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109440 = Gio::File::gobj (this);
      D.109441 = g_file_set_display_name_finish (D.109440, D.109439, &gerror);
      *<retval> = Glib::wrap (D.109441, 0); [return slot optimization]
      try
        {
          gerror.264 = gerror;
          if (gerror.264 != 0B) goto <D.109443>; else goto <D.109444>;
          <D.109443>:
          gerror.264 = gerror;
          Glib::Error::throw_exception (gerror.264);
          <D.109444>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::File>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::remove(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109451;
  struct GFile * D.109452;
  int D.109453;
  struct GError * gerror.265;
  bool D.109457;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109451 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109452 = Gio::File::gobj (this);
      D.109453 = g_file_delete (D.109452, D.109451, &gerror);
      retvalue = D.109453 != 0;
      gerror.265 = gerror;
      if (gerror.265 != 0B) goto <D.109455>; else goto <D.109456>;
      <D.109455>:
      gerror.265 = gerror;
      Glib::Error::throw_exception (gerror.265);
      <D.109456>:
      D.109457 = retvalue;
      return D.109457;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::remove() (struct File * const this)
{
  struct GFile * D.109463;
  int D.109464;
  struct GError * gerror.266;
  bool D.109468;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109463 = Gio::File::gobj (this);
      D.109464 = g_file_delete (D.109463, 0B, &gerror);
      retvalue = D.109464 != 0;
      gerror.266 = gerror;
      if (gerror.266 != 0B) goto <D.109466>; else goto <D.109467>;
      <D.109466>:
      gerror.266 = gerror;
      Glib::Error::throw_exception (gerror.266);
      <D.109467>:
      D.109468 = retvalue;
      return D.109468;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::remove_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109473;
  struct GFile * D.109474;
  int D.109475;
  struct GError * gerror.267;
  bool D.109479;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109473 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109474 = Gio::File::gobj (this);
      D.109475 = g_file_delete_finish (D.109474, D.109473, &gerror);
      retvalue = D.109475 != 0;
      gerror.267 = gerror;
      if (gerror.267 != 0B) goto <D.109477>; else goto <D.109478>;
      <D.109477>:
      gerror.267 = gerror;
      Glib::Error::throw_exception (gerror.267);
      <D.109478>:
      D.109479 = retvalue;
      return D.109479;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::trash(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109485;
  struct GFile * D.109486;
  int D.109487;
  struct GError * gerror.268;
  bool D.109491;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109485 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109486 = Gio::File::gobj (this);
      D.109487 = g_file_trash (D.109486, D.109485, &gerror);
      retvalue = D.109487 != 0;
      gerror.268 = gerror;
      if (gerror.268 != 0B) goto <D.109489>; else goto <D.109490>;
      <D.109489>:
      gerror.268 = gerror;
      Glib::Error::throw_exception (gerror.268);
      <D.109490>:
      D.109491 = retvalue;
      return D.109491;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::trash() (struct File * const this)
{
  struct GFile * D.109497;
  int D.109498;
  struct GError * gerror.269;
  bool D.109502;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109497 = Gio::File::gobj (this);
      D.109498 = g_file_trash (D.109497, 0B, &gerror);
      retvalue = D.109498 != 0;
      gerror.269 = gerror;
      if (gerror.269 != 0B) goto <D.109500>; else goto <D.109501>;
      <D.109500>:
      gerror.269 = gerror;
      Glib::Error::throw_exception (gerror.269);
      <D.109501>:
      D.109502 = retvalue;
      return D.109502;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::trash_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109507;
  struct GFile * D.109508;
  int D.109509;
  struct GError * gerror.270;
  bool D.109513;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109507 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109508 = Gio::File::gobj (this);
      D.109509 = g_file_trash_finish (D.109508, D.109507, &gerror);
      retvalue = D.109509 != 0;
      gerror.270 = gerror;
      if (gerror.270 != 0B) goto <D.109511>; else goto <D.109512>;
      <D.109511>:
      gerror.270 = gerror;
      Glib::Error::throw_exception (gerror.270);
      <D.109512>:
      D.109513 = retvalue;
      return D.109513;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::copy_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.109519;
  struct GFile * D.109520;
  int D.109521;
  struct GError * gerror.271;
  bool D.109525;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109519 = Glib::unwrap<Gio::AsyncResult> (res);
      D.109520 = Gio::File::gobj (this);
      D.109521 = g_file_copy_finish (D.109520, D.109519, &gerror);
      retvalue = D.109521 != 0;
      gerror.271 = gerror;
      if (gerror.271 != 0B) goto <D.109523>; else goto <D.109524>;
      <D.109523>:
      gerror.271 = gerror;
      Glib::Error::throw_exception (gerror.271);
      <D.109524>:
      D.109525 = retvalue;
      return D.109525;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_directory(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109531;
  struct GFile * D.109532;
  int D.109533;
  struct GError * gerror.272;
  bool D.109537;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109531 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109532 = Gio::File::gobj (this);
      D.109533 = g_file_make_directory (D.109532, D.109531, &gerror);
      retvalue = D.109533 != 0;
      gerror.272 = gerror;
      if (gerror.272 != 0B) goto <D.109535>; else goto <D.109536>;
      <D.109535>:
      gerror.272 = gerror;
      Glib::Error::throw_exception (gerror.272);
      <D.109536>:
      D.109537 = retvalue;
      return D.109537;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_directory() (struct File * const this)
{
  struct GFile * D.109543;
  int D.109544;
  struct GError * gerror.273;
  bool D.109548;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109543 = Gio::File::gobj (this);
      D.109544 = g_file_make_directory (D.109543, 0B, &gerror);
      retvalue = D.109544 != 0;
      gerror.273 = gerror;
      if (gerror.273 != 0B) goto <D.109546>; else goto <D.109547>;
      <D.109546>:
      gerror.273 = gerror;
      Glib::Error::throw_exception (gerror.273);
      <D.109547>:
      D.109548 = retvalue;
      return D.109548;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_directory_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109553;
  struct GFile * D.109554;
  int D.109555;
  struct GError * gerror.274;
  bool D.109559;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109553 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109554 = Gio::File::gobj (this);
      D.109555 = g_file_make_directory_finish (D.109554, D.109553, &gerror);
      retvalue = D.109555 != 0;
      gerror.274 = gerror;
      if (gerror.274 != 0B) goto <D.109557>; else goto <D.109558>;
      <D.109557>:
      gerror.274 = gerror;
      Glib::Error::throw_exception (gerror.274);
      <D.109558>:
      D.109559 = retvalue;
      return D.109559;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_directory_with_parents(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109565;
  struct GFile * D.109566;
  int D.109567;
  struct GError * gerror.275;
  bool D.109571;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109565 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109566 = Gio::File::gobj (this);
      D.109567 = g_file_make_directory_with_parents (D.109566, D.109565, &gerror);
      retvalue = D.109567 != 0;
      gerror.275 = gerror;
      if (gerror.275 != 0B) goto <D.109569>; else goto <D.109570>;
      <D.109569>:
      gerror.275 = gerror;
      Glib::Error::throw_exception (gerror.275);
      <D.109570>:
      D.109571 = retvalue;
      return D.109571;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_directory_with_parents() (struct File * const this)
{
  struct GFile * D.109577;
  int D.109578;
  struct GError * gerror.276;
  bool D.109582;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109577 = Gio::File::gobj (this);
      D.109578 = g_file_make_directory_with_parents (D.109577, 0B, &gerror);
      retvalue = D.109578 != 0;
      gerror.276 = gerror;
      if (gerror.276 != 0B) goto <D.109580>; else goto <D.109581>;
      <D.109580>:
      gerror.276 = gerror;
      Glib::Error::throw_exception (gerror.276);
      <D.109581>:
      D.109582 = retvalue;
      return D.109582;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_symbolic_link(const string&, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & symlink_value, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109587;
  const char * D.109588;
  struct GFile * D.109589;
  int D.109590;
  struct GError * gerror.277;
  bool D.109594;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109587 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109588 = std::basic_string<char>::c_str (symlink_value);
      D.109589 = Gio::File::gobj (this);
      D.109590 = g_file_make_symbolic_link (D.109589, D.109588, D.109587, &gerror);
      retvalue = D.109590 != 0;
      gerror.277 = gerror;
      if (gerror.277 != 0B) goto <D.109592>; else goto <D.109593>;
      <D.109592>:
      gerror.277 = gerror;
      Glib::Error::throw_exception (gerror.277);
      <D.109593>:
      D.109594 = retvalue;
      return D.109594;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::make_symbolic_link(const string&) (struct File * const this, const struct string & symlink_value)
{
  const char * D.109601;
  struct GFile * D.109602;
  int D.109603;
  struct GError * gerror.278;
  bool D.109607;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109601 = std::basic_string<char>::c_str (symlink_value);
      D.109602 = Gio::File::gobj (this);
      D.109603 = g_file_make_symbolic_link (D.109602, D.109601, 0B, &gerror);
      retvalue = D.109603 != 0;
      gerror.278 = gerror;
      if (gerror.278 != 0B) goto <D.109605>; else goto <D.109606>;
      <D.109605>:
      gerror.278 = gerror;
      Glib::Error::throw_exception (gerror.278);
      <D.109606>:
      D.109607 = retvalue;
      return D.109607;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileAttributeInfoList> Gio::File::query_settable_attributes(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109614;
  struct GFile * D.109615;
  struct GFileAttributeInfoList * D.109616;
  struct GError * gerror.279;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109614 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109615 = Gio::File::gobj (this);
      D.109616 = g_file_query_settable_attributes (D.109615, D.109614, &gerror);
      *<retval> = Glib::wrap (D.109616, 0); [return slot optimization]
      try
        {
          gerror.279 = gerror;
          if (gerror.279 != 0B) goto <D.109618>; else goto <D.109619>;
          <D.109618>:
          gerror.279 = gerror;
          Glib::Error::throw_exception (gerror.279);
          <D.109619>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileAttributeInfoList>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::FileAttributeInfoList] (struct RefPtr * const this)
{
  struct FileAttributeInfoList * D.109626;

  {
    try
      {
        D.109626 = this->pCppObject_;
        if (D.109626 != 0B) goto <D.109627>; else goto <D.109628>;
        <D.109627>:
        D.109626 = this->pCppObject_;
        Gio::FileAttributeInfoList::unreference (D.109626);
        goto <D.109629>;
        <D.109628>:
        <D.109629>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106531>:
}


Glib::RefPtr<Gio::FileAttributeInfoList> Gio::File::query_settable_attributes() (struct File * const this)
{
  struct GFile * D.109632;
  struct GFileAttributeInfoList * D.109633;
  struct GError * gerror.280;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109632 = Gio::File::gobj (this);
      D.109633 = g_file_query_settable_attributes (D.109632, 0B, &gerror);
      *<retval> = Glib::wrap (D.109633, 0); [return slot optimization]
      try
        {
          gerror.280 = gerror;
          if (gerror.280 != 0B) goto <D.109635>; else goto <D.109636>;
          <D.109635>:
          gerror.280 = gerror;
          Glib::Error::throw_exception (gerror.280);
          <D.109636>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileAttributeInfoList>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileAttributeInfoList> Gio::File::query_writable_namespaces(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109643;
  struct GFile * D.109644;
  struct GFileAttributeInfoList * D.109645;
  struct GError * gerror.281;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109643 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109644 = Gio::File::gobj (this);
      D.109645 = g_file_query_writable_namespaces (D.109644, D.109643, &gerror);
      *<retval> = Glib::wrap (D.109645, 0); [return slot optimization]
      try
        {
          gerror.281 = gerror;
          if (gerror.281 != 0B) goto <D.109647>; else goto <D.109648>;
          <D.109647>:
          gerror.281 = gerror;
          Glib::Error::throw_exception (gerror.281);
          <D.109648>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileAttributeInfoList>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::FileAttributeInfoList> Gio::File::query_writable_namespaces() (struct File * const this)
{
  struct GFile * D.109656;
  struct GFileAttributeInfoList * D.109657;
  struct GError * gerror.282;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109656 = Gio::File::gobj (this);
      D.109657 = g_file_query_writable_namespaces (D.109656, 0B, &gerror);
      *<retval> = Glib::wrap (D.109657, 0); [return slot optimization]
      try
        {
          gerror.282 = gerror;
          if (gerror.282 != 0B) goto <D.109659>; else goto <D.109660>;
          <D.109659>:
          gerror.282 = gerror;
          Glib::Error::throw_exception (gerror.282);
          <D.109660>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::FileAttributeInfoList>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_string(const string&, const string&, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, const struct string & value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109666;
  const char * D.109667;
  const char * D.109668;
  struct GFile * D.109669;
  int D.109670;
  struct GError * gerror.283;
  bool D.109674;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109666 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109667 = std::basic_string<char>::c_str (value);
      D.109668 = std::basic_string<char>::c_str (attribute);
      D.109669 = Gio::File::gobj (this);
      D.109670 = g_file_set_attribute_string (D.109669, D.109668, D.109667, flags, D.109666, &gerror);
      retvalue = D.109670 != 0;
      gerror.283 = gerror;
      if (gerror.283 != 0B) goto <D.109672>; else goto <D.109673>;
      <D.109672>:
      gerror.283 = gerror;
      Glib::Error::throw_exception (gerror.283);
      <D.109673>:
      D.109674 = retvalue;
      return D.109674;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_string(const string&, const string&, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, const struct string & value, FileQueryInfoFlags flags)
{
  const char * D.109682;
  const char * D.109683;
  struct GFile * D.109684;
  int D.109685;
  struct GError * gerror.284;
  bool D.109689;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109682 = std::basic_string<char>::c_str (value);
      D.109683 = std::basic_string<char>::c_str (attribute);
      D.109684 = Gio::File::gobj (this);
      D.109685 = g_file_set_attribute_string (D.109684, D.109683, D.109682, flags, 0B, &gerror);
      retvalue = D.109685 != 0;
      gerror.284 = gerror;
      if (gerror.284 != 0B) goto <D.109687>; else goto <D.109688>;
      <D.109687>:
      gerror.284 = gerror;
      Glib::Error::throw_exception (gerror.284);
      <D.109688>:
      D.109689 = retvalue;
      return D.109689;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_byte_string(const string&, const string&, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, const struct string & value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109696;
  const char * D.109697;
  const char * D.109698;
  struct GFile * D.109699;
  int D.109700;
  struct GError * gerror.285;
  bool D.109704;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109696 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109697 = std::basic_string<char>::c_str (value);
      D.109698 = std::basic_string<char>::c_str (attribute);
      D.109699 = Gio::File::gobj (this);
      D.109700 = g_file_set_attribute_byte_string (D.109699, D.109698, D.109697, flags, D.109696, &gerror);
      retvalue = D.109700 != 0;
      gerror.285 = gerror;
      if (gerror.285 != 0B) goto <D.109702>; else goto <D.109703>;
      <D.109702>:
      gerror.285 = gerror;
      Glib::Error::throw_exception (gerror.285);
      <D.109703>:
      D.109704 = retvalue;
      return D.109704;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_byte_string(const string&, const string&, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, const struct string & value, FileQueryInfoFlags flags)
{
  const char * D.109712;
  const char * D.109713;
  struct GFile * D.109714;
  int D.109715;
  struct GError * gerror.286;
  bool D.109719;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109712 = std::basic_string<char>::c_str (value);
      D.109713 = std::basic_string<char>::c_str (attribute);
      D.109714 = Gio::File::gobj (this);
      D.109715 = g_file_set_attribute_byte_string (D.109714, D.109713, D.109712, flags, 0B, &gerror);
      retvalue = D.109715 != 0;
      gerror.286 = gerror;
      if (gerror.286 != 0B) goto <D.109717>; else goto <D.109718>;
      <D.109717>:
      gerror.286 = gerror;
      Glib::Error::throw_exception (gerror.286);
      <D.109718>:
      D.109719 = retvalue;
      return D.109719;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_uint32(const string&, guint32, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, guint32 value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109726;
  const char * D.109727;
  struct GFile * D.109728;
  int D.109729;
  struct GError * gerror.287;
  bool D.109733;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109726 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109727 = std::basic_string<char>::c_str (attribute);
      D.109728 = Gio::File::gobj (this);
      D.109729 = g_file_set_attribute_uint32 (D.109728, D.109727, value, flags, D.109726, &gerror);
      retvalue = D.109729 != 0;
      gerror.287 = gerror;
      if (gerror.287 != 0B) goto <D.109731>; else goto <D.109732>;
      <D.109731>:
      gerror.287 = gerror;
      Glib::Error::throw_exception (gerror.287);
      <D.109732>:
      D.109733 = retvalue;
      return D.109733;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_uint32(const string&, guint32, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, guint32 value, FileQueryInfoFlags flags)
{
  const char * D.109740;
  struct GFile * D.109741;
  int D.109742;
  struct GError * gerror.288;
  bool D.109746;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109740 = std::basic_string<char>::c_str (attribute);
      D.109741 = Gio::File::gobj (this);
      D.109742 = g_file_set_attribute_uint32 (D.109741, D.109740, value, flags, 0B, &gerror);
      retvalue = D.109742 != 0;
      gerror.288 = gerror;
      if (gerror.288 != 0B) goto <D.109744>; else goto <D.109745>;
      <D.109744>:
      gerror.288 = gerror;
      Glib::Error::throw_exception (gerror.288);
      <D.109745>:
      D.109746 = retvalue;
      return D.109746;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_int32(const string&, gint32, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, gint32 value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109752;
  const char * D.109753;
  struct GFile * D.109754;
  int D.109755;
  struct GError * gerror.289;
  bool D.109759;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109752 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109753 = std::basic_string<char>::c_str (attribute);
      D.109754 = Gio::File::gobj (this);
      D.109755 = g_file_set_attribute_int32 (D.109754, D.109753, value, flags, D.109752, &gerror);
      retvalue = D.109755 != 0;
      gerror.289 = gerror;
      if (gerror.289 != 0B) goto <D.109757>; else goto <D.109758>;
      <D.109757>:
      gerror.289 = gerror;
      Glib::Error::throw_exception (gerror.289);
      <D.109758>:
      D.109759 = retvalue;
      return D.109759;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_int32(const string&, gint32, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, gint32 value, FileQueryInfoFlags flags)
{
  const char * D.109766;
  struct GFile * D.109767;
  int D.109768;
  struct GError * gerror.290;
  bool D.109772;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109766 = std::basic_string<char>::c_str (attribute);
      D.109767 = Gio::File::gobj (this);
      D.109768 = g_file_set_attribute_int32 (D.109767, D.109766, value, flags, 0B, &gerror);
      retvalue = D.109768 != 0;
      gerror.290 = gerror;
      if (gerror.290 != 0B) goto <D.109770>; else goto <D.109771>;
      <D.109770>:
      gerror.290 = gerror;
      Glib::Error::throw_exception (gerror.290);
      <D.109771>:
      D.109772 = retvalue;
      return D.109772;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_uint64(const string&, guint64, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, guint64 value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109778;
  const char * D.109779;
  struct GFile * D.109780;
  int D.109781;
  struct GError * gerror.291;
  bool D.109785;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109778 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109779 = std::basic_string<char>::c_str (attribute);
      D.109780 = Gio::File::gobj (this);
      D.109781 = g_file_set_attribute_uint64 (D.109780, D.109779, value, flags, D.109778, &gerror);
      retvalue = D.109781 != 0;
      gerror.291 = gerror;
      if (gerror.291 != 0B) goto <D.109783>; else goto <D.109784>;
      <D.109783>:
      gerror.291 = gerror;
      Glib::Error::throw_exception (gerror.291);
      <D.109784>:
      D.109785 = retvalue;
      return D.109785;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_uint64(const string&, guint64, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, guint64 value, FileQueryInfoFlags flags)
{
  const char * D.109792;
  struct GFile * D.109793;
  int D.109794;
  struct GError * gerror.292;
  bool D.109798;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109792 = std::basic_string<char>::c_str (attribute);
      D.109793 = Gio::File::gobj (this);
      D.109794 = g_file_set_attribute_uint64 (D.109793, D.109792, value, flags, 0B, &gerror);
      retvalue = D.109794 != 0;
      gerror.292 = gerror;
      if (gerror.292 != 0B) goto <D.109796>; else goto <D.109797>;
      <D.109796>:
      gerror.292 = gerror;
      Glib::Error::throw_exception (gerror.292);
      <D.109797>:
      D.109798 = retvalue;
      return D.109798;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_int64(const string&, gint64, Gio::FileQueryInfoFlags, const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct string & attribute, gint64 value, FileQueryInfoFlags flags, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109804;
  const char * D.109805;
  struct GFile * D.109806;
  int D.109807;
  struct GError * gerror.293;
  bool D.109811;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109804 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109805 = std::basic_string<char>::c_str (attribute);
      D.109806 = Gio::File::gobj (this);
      D.109807 = g_file_set_attribute_int64 (D.109806, D.109805, value, flags, D.109804, &gerror);
      retvalue = D.109807 != 0;
      gerror.293 = gerror;
      if (gerror.293 != 0B) goto <D.109809>; else goto <D.109810>;
      <D.109809>:
      gerror.293 = gerror;
      Glib::Error::throw_exception (gerror.293);
      <D.109810>:
      D.109811 = retvalue;
      return D.109811;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::set_attribute_int64(const string&, gint64, Gio::FileQueryInfoFlags) (struct File * const this, const struct string & attribute, gint64 value, FileQueryInfoFlags flags)
{
  const char * D.109818;
  struct GFile * D.109819;
  int D.109820;
  struct GError * gerror.294;
  bool D.109824;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109818 = std::basic_string<char>::c_str (attribute);
      D.109819 = Gio::File::gobj (this);
      D.109820 = g_file_set_attribute_int64 (D.109819, D.109818, value, flags, 0B, &gerror);
      retvalue = D.109820 != 0;
      gerror.294 = gerror;
      if (gerror.294 != 0B) goto <D.109822>; else goto <D.109823>;
      <D.109822>:
      gerror.294 = gerror;
      Glib::Error::throw_exception (gerror.294);
      <D.109823>:
      D.109824 = retvalue;
      return D.109824;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::mount_enclosing_volume_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109830;
  struct GFile * D.109831;
  int D.109832;
  struct GError * gerror.295;
  bool D.109836;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109830 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109831 = Gio::File::gobj (this);
      D.109832 = g_file_mount_enclosing_volume_finish (D.109831, D.109830, &gerror);
      retvalue = D.109832 != 0;
      gerror.295 = gerror;
      if (gerror.295 != 0B) goto <D.109834>; else goto <D.109835>;
      <D.109834>:
      gerror.295 = gerror;
      Glib::Error::throw_exception (gerror.295);
      <D.109835>:
      D.109836 = retvalue;
      return D.109836;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::File> Gio::File::mount_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109843;
  struct GFile * D.109844;
  struct GFile * D.109845;
  struct GError * gerror.296;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109843 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109844 = Gio::File::gobj (this);
      D.109845 = g_file_mount_mountable_finish (D.109844, D.109843, &gerror);
      *<retval> = Glib::wrap (D.109845, 0); [return slot optimization]
      try
        {
          gerror.296 = gerror;
          if (gerror.296 != 0B) goto <D.109847>; else goto <D.109848>;
          <D.109847>:
          gerror.296 = gerror;
          Glib::Error::throw_exception (gerror.296);
          <D.109848>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::File>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::unmount_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109855;
  struct GFile * D.109856;
  int D.109857;
  struct GError * gerror.297;
  bool D.109861;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109855 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109856 = Gio::File::gobj (this);
      D.109857 = g_file_unmount_mountable_with_operation_finish (D.109856, D.109855, &gerror);
      retvalue = D.109857 != 0;
      gerror.297 = gerror;
      if (gerror.297 != 0B) goto <D.109859>; else goto <D.109860>;
      <D.109859>:
      gerror.297 = gerror;
      Glib::Error::throw_exception (gerror.297);
      <D.109860>:
      D.109861 = retvalue;
      return D.109861;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::eject_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109867;
  struct GFile * D.109868;
  int D.109869;
  struct GError * gerror.298;
  bool D.109873;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109867 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109868 = Gio::File::gobj (this);
      D.109869 = g_file_eject_mountable_with_operation_finish (D.109868, D.109867, &gerror);
      retvalue = D.109869 != 0;
      gerror.298 = gerror;
      if (gerror.298 != 0B) goto <D.109871>; else goto <D.109872>;
      <D.109871>:
      gerror.298 = gerror;
      Glib::Error::throw_exception (gerror.298);
      <D.109872>:
      D.109873 = retvalue;
      return D.109873;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::measure_disk_usage_finish(const Glib::RefPtr<Gio::AsyncResult>&, guint64&, guint64&, guint64&) (struct File * const this, const struct RefPtr & result, guint64 & disk_usage, guint64 & num_dirs, guint64 & num_files)
{
  struct BaseObjectType * D.109879;
  struct GFile * D.109880;
  int D.109881;
  struct GError * gerror.299;
  bool D.109885;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109879 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109880 = Gio::File::gobj (this);
      D.109881 = g_file_measure_disk_usage_finish (D.109880, D.109879, disk_usage, num_dirs, num_files, &gerror);
      retvalue = D.109881 != 0;
      gerror.299 = gerror;
      if (gerror.299 != 0B) goto <D.109883>; else goto <D.109884>;
      <D.109883>:
      gerror.299 = gerror;
      Glib::Error::throw_exception (gerror.299);
      <D.109884>:
      D.109885 = retvalue;
      return D.109885;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::start_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109891;
  struct GFile * D.109892;
  int D.109893;
  struct GError * gerror.300;
  bool D.109897;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109891 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109892 = Gio::File::gobj (this);
      D.109893 = g_file_start_mountable_finish (D.109892, D.109891, &gerror);
      retvalue = D.109893 != 0;
      gerror.300 = gerror;
      if (gerror.300 != 0B) goto <D.109895>; else goto <D.109896>;
      <D.109895>:
      gerror.300 = gerror;
      Glib::Error::throw_exception (gerror.300);
      <D.109896>:
      D.109897 = retvalue;
      return D.109897;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::stop_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109903;
  struct GFile * D.109904;
  int D.109905;
  struct GError * gerror.301;
  bool D.109909;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109903 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109904 = Gio::File::gobj (this);
      D.109905 = g_file_stop_mountable_finish (D.109904, D.109903, &gerror);
      retvalue = D.109905 != 0;
      gerror.301 = gerror;
      if (gerror.301 != 0B) goto <D.109907>; else goto <D.109908>;
      <D.109907>:
      gerror.301 = gerror;
      Glib::Error::throw_exception (gerror.301);
      <D.109908>:
      D.109909 = retvalue;
      return D.109909;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::poll_mountable_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct File * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.109915;
  struct GFile * D.109916;
  int D.109917;
  struct GError * gerror.302;
  bool D.109921;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.109915 = Glib::unwrap<Gio::AsyncResult> (result);
      D.109916 = Gio::File::gobj (this);
      D.109917 = g_file_poll_mountable_finish (D.109916, D.109915, &gerror);
      retvalue = D.109917 != 0;
      gerror.302 = gerror;
      if (gerror.302 != 0B) goto <D.109919>; else goto <D.109920>;
      <D.109919>:
      gerror.302 = gerror;
      Glib::Error::throw_exception (gerror.302);
      <D.109920>:
      D.109921 = retvalue;
      return D.109921;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::AppInfo> Gio::File::query_default_handler(const Glib::RefPtr<Gio::Cancellable>&) (struct File * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.109928;
  struct GFile * D.109929;
  struct GAppInfo * D.109930;
  struct GError * gerror.303;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109928 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.109929 = Gio::File::gobj (this);
      D.109930 = g_file_query_default_handler (D.109929, D.109928, &gerror);
      *<retval> = Glib::wrap (D.109930, 0); [return slot optimization]
      try
        {
          gerror.303 = gerror;
          if (gerror.303 != 0B) goto <D.109932>; else goto <D.109933>;
          <D.109932>:
          gerror.303 = gerror;
          Glib::Error::throw_exception (gerror.303);
          <D.109933>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::AppInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::AppInfo] (struct RefPtr * const this)
{
  struct AppInfo * D.109940;
  int (*__vtbl_ptr_type) () * D.109943;
  int (*__vtbl_ptr_type) () * D.109944;
  long int D.109945;
  sizetype D.109946;
  struct ObjectBase * D.109947;
  int (*__vtbl_ptr_type) () * D.109948;
  int (*__vtbl_ptr_type) () * D.109949;
  int (*__vtbl_ptr_type) () D.109950;

  {
    try
      {
        D.109940 = this->pCppObject_;
        if (D.109940 != 0B) goto <D.109941>; else goto <D.109942>;
        <D.109941>:
        D.109940 = this->pCppObject_;
        D.109940 = this->pCppObject_;
        D.109943 = D.109940->D.86414._vptr.Interface;
        D.109944 = D.109943 + 18446744073709551592;
        D.109945 = MEM[(long int *)D.109944];
        D.109946 = (sizetype) D.109945;
        D.109947 = D.109940 + D.109946;
        D.109940 = this->pCppObject_;
        D.109940 = this->pCppObject_;
        D.109943 = D.109940->D.86414._vptr.Interface;
        D.109944 = D.109943 + 18446744073709551592;
        D.109945 = MEM[(long int *)D.109944];
        D.109946 = (sizetype) D.109945;
        D.109947 = D.109940 + D.109946;
        D.109948 = D.109947->_vptr.ObjectBase;
        D.109949 = D.109948 + 24;
        D.109950 = *D.109949;
        D.109940 = this->pCppObject_;
        D.109940 = this->pCppObject_;
        D.109943 = D.109940->D.86414._vptr.Interface;
        D.109944 = D.109943 + 18446744073709551592;
        D.109945 = MEM[(long int *)D.109944];
        D.109946 = (sizetype) D.109945;
        D.109947 = D.109940 + D.109946;
        OBJ_TYPE_REF(D.109950;(const struct ObjectBase)D.109947->3) (D.109947);
        goto <D.109951>;
        <D.109942>:
        <D.109951>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106541>:
}


Glib::RefPtr<Gio::AppInfo> Gio::File::query_default_handler() (struct File * const this)
{
  struct GFile * D.109954;
  struct GAppInfo * D.109955;
  struct GError * gerror.304;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.109954 = Gio::File::gobj (this);
      D.109955 = g_file_query_default_handler (D.109954, 0B, &gerror);
      *<retval> = Glib::wrap (D.109955, 0); [return slot optimization]
      try
        {
          gerror.304 = gerror;
          if (gerror.304 != 0B) goto <D.109957>; else goto <D.109958>;
          <D.109957>:
          gerror.304 = gerror;
          Glib::Error::throw_exception (gerror.304);
          <D.109958>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::AppInfo>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::File::supports_thread_contexts() const (const struct File * const this)
{
  bool D.109964;
  const struct GFile * D.109965;
  int D.109966;

  D.109965 = Gio::File::gobj (this);
  D.109966 = g_file_supports_thread_contexts (D.109965);
  D.109964 = D.109966 != 0;
  return D.109964;
}