void Gio::Volume::mount(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountMountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountMountFlags flags)
{
  void * slot_copy.0;
  struct BaseObjectType * D.104817;
  struct BaseObjectType * D.104818;
  struct GVolume * D.104819;
  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.104817 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.104818 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104819 = Gio::Volume::gobj (this);
  g_volume_mount (D.104819, flags, D.104818, D.104817, 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.104825;

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

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


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.104826;
  struct slot_base * D.104827;

  D.104826 = &src->D.102329;
  D.104827 = &this->D.102329;
  sigc::slot_base::slot_base (D.104827, D.104826);
  try
    {

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


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.104828;
  struct BaseObjectType * iftmp.1;
  bool D.104830;
  struct Cancellable * D.104833;

  D.104830 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.104830 != 0) goto <D.104831>; else goto <D.104832>;
  <D.104831>:
  D.104833 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.104833);
  goto <D.104834>;
  <D.104832>:
  iftmp.1 = 0B;
  <D.104834>:
  D.104828 = iftmp.1;
  return D.104828;
}


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

  D.104837 = this->pCppObject_;
  D.104836 = D.104837 != 0B;
  return D.104836;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.104841;
  int (*__vtbl_ptr_type) () * D.104842;
  int (*__vtbl_ptr_type) () * D.104843;
  long int D.104844;
  sizetype D.104845;
  struct ObjectBase * D.104846;

  D.104842 = this->D.97300._vptr.Object;
  D.104843 = D.104842 + 18446744073709551592;
  D.104844 = MEM[(long int *)D.104843];
  D.104845 = (sizetype) D.104844;
  D.104846 = this + D.104845;
  D.104841 = D.104846->gobject_;
  return D.104841;
}


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.104848;
  struct BaseObjectType * iftmp.2;
  bool D.104850;
  struct MountOperation * D.104853;

  D.104850 = Glib::RefPtr<Gio::MountOperation>::operator bool (ptr);
  if (D.104850 != 0) goto <D.104851>; else goto <D.104852>;
  <D.104851>:
  D.104853 = Glib::RefPtr<Gio::MountOperation>::operator-> (ptr);
  iftmp.2 = Gio::MountOperation::gobj (D.104853);
  goto <D.104854>;
  <D.104852>:
  iftmp.2 = 0B;
  <D.104854>:
  D.104848 = iftmp.2;
  return D.104848;
}


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

  D.104857 = this->pCppObject_;
  D.104856 = D.104857 != 0B;
  return D.104856;
}


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

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


GMountOperation* Gio::MountOperation::gobj() (struct MountOperation * const this)
{
  struct GMountOperation * D.104861;
  int (*__vtbl_ptr_type) () * D.104862;
  int (*__vtbl_ptr_type) () * D.104863;
  long int D.104864;
  sizetype D.104865;
  struct ObjectBase * D.104866;

  D.104862 = this->D.99371._vptr.Object;
  D.104863 = D.104862 + 18446744073709551592;
  D.104864 = MEM[(long int *)D.104863];
  D.104865 = (sizetype) D.104864;
  D.104866 = this + D.104865;
  D.104861 = D.104866->gobject_;
  return D.104861;
}


GVolume* Gio::Volume::gobj() (struct Volume * const this)
{
  struct GVolume * D.104868;
  int (*__vtbl_ptr_type) () * D.104869;
  int (*__vtbl_ptr_type) () * D.104870;
  long int D.104871;
  sizetype D.104872;
  struct ObjectBase * D.104873;

  D.104869 = this->D.102063._vptr.Interface;
  D.104870 = D.104869 + 18446744073709551592;
  D.104871 = MEM[(long int *)D.104870];
  D.104872 = (sizetype) D.104871;
  D.104873 = this + D.104872;
  D.104868 = D.104873->gobject_;
  return D.104868;
}


void Gio::Volume::mount(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, Gio::MountMountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, MountMountFlags flags)
{
  void * slot_copy.3;
  struct BaseObjectType * D.104875;
  struct GVolume * D.104876;
  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.104875 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104876 = Gio::Volume::gobj (this);
  g_volume_mount (D.104876, flags, D.104875, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::Volume::mount(const Glib::RefPtr<Gio::MountOperation>&, Gio::MountMountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, MountMountFlags flags)
{
  struct BaseObjectType * D.104880;
  struct GVolume * D.104881;

  D.104880 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104881 = Gio::Volume::gobj (this);
  g_volume_mount (D.104881, flags, D.104880, 0B, 0B, 0B);
}


void Gio::Volume::mount(Gio::MountMountFlags) (struct Volume * const this, MountMountFlags flags)
{
  struct GVolume * D.104883;

  D.104883 = Gio::Volume::gobj (this);
  g_volume_mount (D.104883, flags, 0B, 0B, 0B, 0B);
}


void Gio::Volume::eject(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountUnmountFlags) (struct Volume * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountUnmountFlags flags)
{
  void * slot_copy.4;
  struct BaseObjectType * D.104884;
  struct GVolume * D.104885;
  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.104884 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.104885 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104885, flags, 0B, D.104884, SignalProxy_async_callback, slot_copy);
}


void Gio::Volume::eject(const SlotAsyncReady&, Gio::MountUnmountFlags) (struct Volume * const this, const struct SlotAsyncReady & slot, MountUnmountFlags flags)
{
  void * slot_copy.5;
  struct GVolume * D.104889;
  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.104889 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104889, flags, 0B, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::Volume::eject(Gio::MountUnmountFlags) (struct Volume * const this, MountUnmountFlags flags)
{
  struct GVolume * D.104892;

  D.104892 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104892, flags, 0B, 0B, 0B, 0B);
}


void Gio::Volume::eject(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::MountUnmountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, MountUnmountFlags flags)
{
  void * slot_copy.6;
  struct BaseObjectType * D.104893;
  struct BaseObjectType * D.104894;
  struct GVolume * D.104895;
  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.104893 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.104894 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104895 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104895, flags, D.104894, D.104893, SignalProxy_async_callback, slot_copy);
}


void Gio::Volume::eject(const Glib::RefPtr<Gio::MountOperation>&, const SlotAsyncReady&, Gio::MountUnmountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, const struct SlotAsyncReady & slot, MountUnmountFlags flags)
{
  void * slot_copy.7;
  struct BaseObjectType * D.104900;
  struct GVolume * D.104901;
  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.104900 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104901 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104901, flags, D.104900, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::Volume::eject(const Glib::RefPtr<Gio::MountOperation>&, Gio::MountUnmountFlags) (struct Volume * const this, const struct RefPtr & mount_operation, MountUnmountFlags flags)
{
  struct BaseObjectType * D.104905;
  struct GVolume * D.104906;

  D.104905 = Glib::unwrap<Gio::MountOperation> (mount_operation);
  D.104906 = Gio::Volume::gobj (this);
  g_volume_eject_with_operation (D.104906, flags, D.104905, 0B, 0B, 0B);
}


Glib::RefPtr<Gio::Volume> Glib::wrap(GVolume*, bool) (struct GVolume * object, bool take_copy)
{
  int D.104909;
  struct Volume * D.104910;

  D.104909 = (int) take_copy;
  D.104910 = Glib::wrap_auto_interface<Gio::Volume> (object, D.104909);
  Glib::RefPtr<Gio::Volume>::RefPtr (<retval>, D.104910);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::Volume; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct Volume * D.104915;
  long unsigned int D.104918;
  struct Volume * iftmp.8;
  struct ObjectBase * pCppObject.9;
  const struct type_info * iftmp.10;
  int (*__vtbl_ptr_type) () * D.104932;
  const char * D.104934;
  void * result.11;
  bool D.104937;
  bool D.104938;
  int (*__vtbl_ptr_type) () * D.104941;
  int (*__vtbl_ptr_type) () * D.104942;
  long int D.104943;
  sizetype D.104944;
  struct ObjectBase * D.104945;
  int (*__vtbl_ptr_type) () * D.104946;
  int (*__vtbl_ptr_type) () * D.104947;
  int (*__vtbl_ptr_type) () D.104948;
  struct ObjectBase * pCppObject;
  struct Volume * result;

  if (object == 0B) goto <D.104913>; else goto <D.104914>;
  <D.104913>:
  D.104915 = 0B;
  return D.104915;
  <D.104914>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.104916>; else goto <D.104917>;
  <D.104916>:
  D.104918 = Gio::Volume::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.104918);
  goto <D.104919>;
  <D.104917>:
  <D.104919>:
  result = 0B;
  if (pCppObject != 0B) goto <D.104920>; else goto <D.104921>;
  <D.104920>:
  pCppObject.9 = pCppObject;
  if (pCppObject.9 == 0B) goto <D.104924>; else goto <D.104925>;
  <D.104924>:
  iftmp.8 = 0B;
  goto <D.104926>;
  <D.104925>:
  iftmp.8 = __dynamic_cast (pCppObject.9, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6VolumeE, -1);
  <D.104926>:
  result = iftmp.8;
  if (result == 0B) goto <D.104927>; else goto <D.104928>;
  <D.104927>:
  if (pCppObject != 0B) goto <D.104930>; else goto <D.104931>;
  <D.104930>:
  D.104932 = pCppObject->_vptr.ObjectBase;
  iftmp.10 = MEM[(int (*__vtbl_ptr_type) () *)D.104932 + -8B];
  goto <D.104933>;
  <D.104931>:
  __cxa_bad_typeid ();
  <D.104933>:
  D.104934 = std::type_info::name (iftmp.10);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.104934);
  goto <D.104935>;
  <D.104928>:
  <D.104935>:
  goto <D.104936>;
  <D.104921>:
  result.11 = operator new (48);
  try
    {
      Gio::Volume::Volume (result.11, object);
    }
  catch
    {
      operator delete (result.11);
    }
  result = result.11;
  <D.104936>:
  D.104937 = result != 0B;
  D.104938 = D.104937 & take_copy;
  if (D.104938 != 0) goto <D.104939>; else goto <D.104940>;
  <D.104939>:
  D.104941 = result->D.102063._vptr.Interface;
  D.104942 = D.104941 + 18446744073709551592;
  D.104943 = MEM[(long int *)D.104942];
  D.104944 = (sizetype) D.104943;
  D.104945 = result + D.104944;
  D.104941 = result->D.102063._vptr.Interface;
  D.104942 = D.104941 + 18446744073709551592;
  D.104943 = MEM[(long int *)D.104942];
  D.104944 = (sizetype) D.104943;
  D.104945 = result + D.104944;
  D.104946 = D.104945->_vptr.ObjectBase;
  D.104947 = D.104946 + 16;
  D.104948 = *D.104947;
  D.104941 = result->D.102063._vptr.Interface;
  D.104942 = D.104941 + 18446744073709551592;
  D.104943 = MEM[(long int *)D.104942];
  D.104944 = (sizetype) D.104943;
  D.104945 = result + D.104944;
  OBJ_TYPE_REF(D.104948;(const struct ObjectBase)D.104945->2) (D.104945);
  goto <D.104949>;
  <D.104940>:
  <D.104949>:
  D.104915 = result;
  return D.104915;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.104956;
  const char * iftmp.12;
  const char * D.104958;
  char D.104959;

  D.104958 = this->__name;
  D.104959 = *D.104958;
  if (D.104959 == 42) goto <D.104960>; else goto <D.104961>;
  <D.104960>:
  D.104958 = this->__name;
  iftmp.12 = D.104958 + 1;
  goto <D.104962>;
  <D.104961>:
  iftmp.12 = this->__name;
  <D.104962>:
  D.104956 = iftmp.12;
  return D.104956;
}


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


const Glib::Interface_Class& Gio::Volume_Class::init() (struct Volume_Class * const this)
{
  long unsigned int D.104964;
  long unsigned int D.104967;
  const struct Interface_Class & D.104969;

  D.104964 = this->D.102258.D.102240.gtype_;
  if (D.104964 == 0) goto <D.104965>; else goto <D.104966>;
  <D.104965>:
  this->D.102258.D.102240.class_init_func_ = iface_init_function;
  D.104967 = g_drive_get_type ();
  this->D.102258.D.102240.gtype_ = D.104967;
  goto <D.104968>;
  <D.104966>:
  <D.104968>:
  D.104969 = &this->D.102258;
  return D.104969;
}


static void Gio::Volume_Class::iface_init_function(void*, void*) (void * g_iface, void * D.102832)
{
  bool retval.13;
  int retval.14;
  long int D.104977;
  long int D.104978;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[65] = "static void Gio::Volume_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.104974>; else goto <D.104975>;
        <D.104974>:
        _g_boolean_var_ = 1;
        goto <D.104976>;
        <D.104975>:
        _g_boolean_var_ = 0;
        <D.104976>:
        retval.14 = _g_boolean_var_;
      }
      D.104977 = (long int) retval.14;
      D.104978 = __builtin_expect (D.104977, 1);
      retval.13 = D.104978 != 0;
      if (retval.13 != 0) goto <D.104979>; else goto <D.104980>;
      <D.104979>:
      goto <D.104981>;
      <D.104980>:
      g_assertion_message_expr ("giomm", "volume.cc", 240, &__PRETTY_FUNCTION__, "klass != 0");
      <D.104981>:
    }
  }
  klass->changed = changed_callback;
  klass->removed = removed_callback;
}


static void Gio::Volume_Class::changed_callback(GVolume*) (struct GVolume * self)
{
  bool retval.15;
  bool iftmp.16;
  bool D.104987;
  struct CppObjectType * const iftmp.17;
  int (*__vtbl_ptr_type) () * D.104997;
  int (*__vtbl_ptr_type) () * D.104998;
  int (*__vtbl_ptr_type) () D.104999;
  void * D.105000;
  long unsigned int D.105003;
  struct GTypeClass * D.105004;
  void * D.105005;
  void (*<T11509>) (struct GVolume *) D.105008;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.104986>; else goto <D.104984>;
    <D.104986>:
    D.104987 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.104987 != 0) goto <D.104988>; else goto <D.104984>;
    <D.104988>:
    iftmp.16 = 1;
    goto <D.104985>;
    <D.104984>:
    iftmp.16 = 0;
    <D.104985>:
    retval.15 = iftmp.16;
    if (retval.15 != 0) goto <D.104989>; else goto <D.104990>;
    <D.104989>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.104992>; else goto <D.104993>;
      <D.104992>:
      iftmp.17 = 0B;
      goto <D.104994>;
      <D.104993>:
      iftmp.17 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6VolumeE, -1);
      <D.104994>:
      obj = iftmp.17;
      if (obj != 0B) goto <D.104995>; else goto <D.104996>;
      <D.104995>:
      try
        {
          D.104997 = obj->D.102063._vptr.Interface;
          D.104998 = D.104997 + 16;
          D.104999 = *D.104998;
          OBJ_TYPE_REF(D.104999;(struct Volume)obj->2) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105000 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105000);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105001>;
      <D.104996>:
      <D.105001>:
    }
    goto <D.105002>;
    <D.104990>:
    <D.105002>:
  }
  D.105003 = Gio::Volume::get_type ();
  D.105004 = MEM[(struct GTypeInstance *)self].g_class;
  D.105005 = g_type_interface_peek (D.105004, D.105003);
  base = g_type_interface_peek_parent (D.105005);
  if (base != 0B) goto <D.105006>; else goto <D.105007>;
  <D.105006>:
  D.105008 = base->changed;
  if (D.105008 != 0B) goto <D.105009>; else goto <D.105010>;
  <D.105009>:
  D.105008 = base->changed;
  D.105008 (self);
  goto <D.105011>;
  <D.105010>:
  <D.105011>:
  <D.105007>:
}


static void Gio::Volume_Class::removed_callback(GVolume*) (struct GVolume * self)
{
  bool retval.18;
  bool iftmp.19;
  bool D.105026;
  struct CppObjectType * const iftmp.20;
  int (*__vtbl_ptr_type) () * D.105036;
  int (*__vtbl_ptr_type) () * D.105037;
  int (*__vtbl_ptr_type) () D.105038;
  void * D.105039;
  long unsigned int D.105042;
  struct GTypeClass * D.105043;
  void * D.105044;
  void (*<T11509>) (struct GVolume *) D.105047;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105025>; else goto <D.105023>;
    <D.105025>:
    D.105026 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105026 != 0) goto <D.105027>; else goto <D.105023>;
    <D.105027>:
    iftmp.19 = 1;
    goto <D.105024>;
    <D.105023>:
    iftmp.19 = 0;
    <D.105024>:
    retval.18 = iftmp.19;
    if (retval.18 != 0) goto <D.105028>; else goto <D.105029>;
    <D.105028>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105031>; else goto <D.105032>;
      <D.105031>:
      iftmp.20 = 0B;
      goto <D.105033>;
      <D.105032>:
      iftmp.20 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6VolumeE, -1);
      <D.105033>:
      obj = iftmp.20;
      if (obj != 0B) goto <D.105034>; else goto <D.105035>;
      <D.105034>:
      try
        {
          D.105036 = obj->D.102063._vptr.Interface;
          D.105037 = D.105036 + 24;
          D.105038 = *D.105037;
          OBJ_TYPE_REF(D.105038;(struct Volume)obj->3) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105039 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105039);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105040>;
      <D.105035>:
      <D.105040>:
    }
    goto <D.105041>;
    <D.105029>:
    <D.105041>:
  }
  D.105042 = Gio::Volume::get_type ();
  D.105043 = MEM[(struct GTypeInstance *)self].g_class;
  D.105044 = g_type_interface_peek (D.105043, D.105042);
  base = g_type_interface_peek_parent (D.105044);
  if (base != 0B) goto <D.105045>; else goto <D.105046>;
  <D.105045>:
  D.105047 = base->removed;
  if (D.105047 != 0B) goto <D.105048>; else goto <D.105049>;
  <D.105048>:
  D.105047 = base->removed;
  D.105047 (self);
  goto <D.105050>;
  <D.105049>:
  <D.105050>:
  <D.105046>:
}


static Glib::ObjectBase* Gio::Volume_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.105060;
  struct ObjectBase * iftmp.21;
  void * D.102860;
  void * D.105062;
  int (*__vtbl_ptr_type) () * D.105065;
  int (*__vtbl_ptr_type) () * D.105066;
  long int D.105067;
  sizetype D.105068;

  D.102860 = operator new (48);
  try
    {
      Gio::Volume::Volume (D.102860, object);
    }
  catch
    {
      operator delete (D.102860);
    }
  D.105062 = D.102860;
  if (D.105062 != 0B) goto <D.105063>; else goto <D.105064>;
  <D.105063>:
  D.105065 = MEM[(struct Volume *)D.105062].D.102063._vptr.Interface;
  D.105066 = D.105065 + 18446744073709551592;
  D.105067 = MEM[(long int *)D.105066];
  D.105068 = (sizetype) D.105067;
  iftmp.21 = D.105062 + D.105068;
  goto <D.105069>;
  <D.105064>:
  iftmp.21 = 0B;
  <D.105069>:
  D.105060 = iftmp.21;
  return D.105060;
}


Gio::Volume::Volume() (struct Volume * const this, const void * * __vtt_parm)
{
  struct trackable * D.105075;
  const void * * iftmp.22;
  struct ObjectBase * D.105083;
  const struct Interface_Class & D.105085;
  const void * * iftmp.23;
  struct Interface * D.105090;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.105098;
  int (*__vtbl_ptr_type) () * D.105099;
  long int D.105100;
  struct ObjectBase * D.105102;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * iftmp.27;
  const void * * iftmp.28;

  if (0 != 0) goto <D.105073>; else goto <D.105074>;
  <D.105073>:
  D.105075 = &this->D.102066;
  sigc::trackable::trackable (D.105075);
  goto <D.105076>;
  <D.105074>:
  <D.105076>:
  try
    {
      if (0 != 0) goto <D.105077>; else goto <D.105078>;
      <D.105077>:
      if (0 == 0) goto <D.105080>; else goto <D.105081>;
      <D.105080>:
      iftmp.22 = __vtt_parm + 32;
      goto <D.105082>;
      <D.105081>:
      iftmp.22 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105082>:
      D.105083 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105083, iftmp.22);
      goto <D.105084>;
      <D.105078>:
      <D.105084>:
      try
        {
          D.105085 = Gio::Volume_Class::init (&volume_class_);
          if (0 == 0) goto <D.105087>; else goto <D.105088>;
          <D.105087>:
          iftmp.23 = __vtt_parm + 8;
          goto <D.105089>;
          <D.105088>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105089>:
          D.105090 = &this->D.102063;
          Glib::Interface::Interface (D.105090, iftmp.23, D.105085);
          try
            {
              if (0 == 0) goto <D.105092>; else goto <D.105093>;
              <D.105092>:
              iftmp.24 = *__vtt_parm;
              goto <D.105094>;
              <D.105093>:
              iftmp.24 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105094>:
              this->D.102063._vptr.Interface = iftmp.24;
              if (0 == 0) goto <D.105096>; else goto <D.105097>;
              <D.105096>:
              D.105098 = this->D.102063._vptr.Interface;
              D.105099 = D.105098 + 18446744073709551592;
              D.105100 = MEM[(long int *)D.105099];
              iftmp.25 = (sizetype) D.105100;
              goto <D.105101>;
              <D.105097>:
              iftmp.25 = 8;
              <D.105101>:
              D.105102 = this + iftmp.25;
              if (0 == 0) goto <D.105104>; else goto <D.105105>;
              <D.105104>:
              iftmp.26 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105106>;
              <D.105105>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105106>:
              D.105102->_vptr.ObjectBase = iftmp.26;
            }
          catch
            {
              if (0 == 0) goto <D.105108>; else goto <D.105109>;
              <D.105108>:
              iftmp.27 = __vtt_parm + 8;
              goto <D.105110>;
              <D.105109>:
              iftmp.27 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105110>:
              D.105090 = &this->D.102063;
              Glib::Interface::~Interface (D.105090, iftmp.27);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105111>; else goto <D.105112>;
          <D.105111>:
          if (0 == 0) goto <D.105114>; else goto <D.105115>;
          <D.105114>:
          iftmp.28 = __vtt_parm + 32;
          goto <D.105116>;
          <D.105115>:
          iftmp.28 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105116>:
          D.105083 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105083, iftmp.28);
          goto <D.105117>;
          <D.105112>:
          <D.105117>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105118>; else goto <D.105119>;
      <D.105118>:
      D.105075 = &this->D.102066;
      sigc::trackable::~trackable (D.105075);
      goto <D.105120>;
      <D.105119>:
      <D.105120>:
    }
}


Gio::Volume::Volume() (struct Volume * const this)
{
  struct trackable * D.105126;
  const void * * iftmp.29;
  struct ObjectBase * D.105134;
  const struct Interface_Class & D.105136;
  const void * * iftmp.30;
  struct Interface * D.105141;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * D.105145;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.105150;
  int (*__vtbl_ptr_type) () * D.105151;
  long int D.105152;
  struct ObjectBase * D.105154;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * iftmp.34;
  const void * * iftmp.35;

  if (1 != 0) goto <D.105124>; else goto <D.105125>;
  <D.105124>:
  D.105126 = &this->D.102066;
  sigc::trackable::trackable (D.105126);
  goto <D.105127>;
  <D.105125>:
  <D.105127>:
  try
    {
      if (1 != 0) goto <D.105128>; else goto <D.105129>;
      <D.105128>:
      if (1 == 0) goto <D.105131>; else goto <D.105132>;
      <D.105131>:
      iftmp.29 = 32B;
      goto <D.105133>;
      <D.105132>:
      iftmp.29 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105133>:
      D.105134 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105134, iftmp.29);
      goto <D.105135>;
      <D.105129>:
      <D.105135>:
      try
        {
          D.105136 = Gio::Volume_Class::init (&volume_class_);
          if (1 == 0) goto <D.105138>; else goto <D.105139>;
          <D.105138>:
          iftmp.30 = 8B;
          goto <D.105140>;
          <D.105139>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105140>:
          D.105141 = &this->D.102063;
          Glib::Interface::Interface (D.105141, iftmp.30, D.105136);
          try
            {
              if (1 == 0) goto <D.105143>; else goto <D.105144>;
              <D.105143>:
              D.105145 = 0B;
              iftmp.31 = *D.105145;
              goto <D.105146>;
              <D.105144>:
              iftmp.31 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105146>:
              this->D.102063._vptr.Interface = iftmp.31;
              if (1 == 0) goto <D.105148>; else goto <D.105149>;
              <D.105148>:
              D.105150 = this->D.102063._vptr.Interface;
              D.105151 = D.105150 + 18446744073709551592;
              D.105152 = MEM[(long int *)D.105151];
              iftmp.32 = (sizetype) D.105152;
              goto <D.105153>;
              <D.105149>:
              iftmp.32 = 8;
              <D.105153>:
              D.105154 = this + iftmp.32;
              if (1 == 0) goto <D.105156>; else goto <D.105157>;
              <D.105156>:
              iftmp.33 = MEM[(const void * *)0B + 24B];
              goto <D.105158>;
              <D.105157>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105158>:
              D.105154->_vptr.ObjectBase = iftmp.33;
            }
          catch
            {
              if (1 == 0) goto <D.105160>; else goto <D.105161>;
              <D.105160>:
              iftmp.34 = 8B;
              goto <D.105162>;
              <D.105161>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105162>:
              D.105141 = &this->D.102063;
              Glib::Interface::~Interface (D.105141, iftmp.34);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105163>; else goto <D.105164>;
          <D.105163>:
          if (1 == 0) goto <D.105166>; else goto <D.105167>;
          <D.105166>:
          iftmp.35 = 32B;
          goto <D.105168>;
          <D.105167>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105168>:
          D.105134 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105134, iftmp.35);
          goto <D.105169>;
          <D.105164>:
          <D.105169>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105170>; else goto <D.105171>;
      <D.105170>:
      D.105126 = &this->D.102066;
      sigc::trackable::~trackable (D.105126);
      goto <D.105172>;
      <D.105171>:
      <D.105172>:
    }
}


Gio::Volume::Volume(GVolume*) (struct Volume * const this, const void * * __vtt_parm, struct GVolume * castitem)
{
  struct trackable * D.105178;
  const void * * iftmp.36;
  struct ObjectBase * D.105186;
  const void * * iftmp.37;
  struct Interface * D.105192;
  int (*__vtbl_ptr_type) () * iftmp.38;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.105200;
  int (*__vtbl_ptr_type) () * D.105201;
  long int D.105202;
  struct ObjectBase * D.105204;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  const void * * iftmp.42;

  if (0 != 0) goto <D.105176>; else goto <D.105177>;
  <D.105176>:
  D.105178 = &this->D.102066;
  sigc::trackable::trackable (D.105178);
  goto <D.105179>;
  <D.105177>:
  <D.105179>:
  try
    {
      if (0 != 0) goto <D.105180>; else goto <D.105181>;
      <D.105180>:
      if (0 == 0) goto <D.105183>; else goto <D.105184>;
      <D.105183>:
      iftmp.36 = __vtt_parm + 32;
      goto <D.105185>;
      <D.105184>:
      iftmp.36 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105185>:
      D.105186 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105186, iftmp.36);
      goto <D.105187>;
      <D.105181>:
      <D.105187>:
      try
        {
          if (0 == 0) goto <D.105189>; else goto <D.105190>;
          <D.105189>:
          iftmp.37 = __vtt_parm + 8;
          goto <D.105191>;
          <D.105190>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105191>:
          D.105192 = &this->D.102063;
          Glib::Interface::Interface (D.105192, iftmp.37, castitem);
          try
            {
              if (0 == 0) goto <D.105194>; else goto <D.105195>;
              <D.105194>:
              iftmp.38 = *__vtt_parm;
              goto <D.105196>;
              <D.105195>:
              iftmp.38 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105196>:
              this->D.102063._vptr.Interface = iftmp.38;
              if (0 == 0) goto <D.105198>; else goto <D.105199>;
              <D.105198>:
              D.105200 = this->D.102063._vptr.Interface;
              D.105201 = D.105200 + 18446744073709551592;
              D.105202 = MEM[(long int *)D.105201];
              iftmp.39 = (sizetype) D.105202;
              goto <D.105203>;
              <D.105199>:
              iftmp.39 = 8;
              <D.105203>:
              D.105204 = this + iftmp.39;
              if (0 == 0) goto <D.105206>; else goto <D.105207>;
              <D.105206>:
              iftmp.40 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105208>;
              <D.105207>:
              iftmp.40 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105208>:
              D.105204->_vptr.ObjectBase = iftmp.40;
            }
          catch
            {
              if (0 == 0) goto <D.105210>; else goto <D.105211>;
              <D.105210>:
              iftmp.41 = __vtt_parm + 8;
              goto <D.105212>;
              <D.105211>:
              iftmp.41 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105212>:
              D.105192 = &this->D.102063;
              Glib::Interface::~Interface (D.105192, iftmp.41);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105213>; else goto <D.105214>;
          <D.105213>:
          if (0 == 0) goto <D.105216>; else goto <D.105217>;
          <D.105216>:
          iftmp.42 = __vtt_parm + 32;
          goto <D.105218>;
          <D.105217>:
          iftmp.42 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105218>:
          D.105186 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105186, iftmp.42);
          goto <D.105219>;
          <D.105214>:
          <D.105219>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105220>; else goto <D.105221>;
      <D.105220>:
      D.105178 = &this->D.102066;
      sigc::trackable::~trackable (D.105178);
      goto <D.105222>;
      <D.105221>:
      <D.105222>:
    }
}


Gio::Volume::Volume(GVolume*) (struct Volume * const this, struct GVolume * castitem)
{
  struct trackable * D.105227;
  const void * * iftmp.43;
  struct ObjectBase * D.105235;
  const void * * iftmp.44;
  struct Interface * D.105241;
  int (*__vtbl_ptr_type) () * iftmp.45;
  const void * * D.105245;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.105250;
  int (*__vtbl_ptr_type) () * D.105251;
  long int D.105252;
  struct ObjectBase * D.105254;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  const void * * iftmp.49;

  if (1 != 0) goto <D.105225>; else goto <D.105226>;
  <D.105225>:
  D.105227 = &this->D.102066;
  sigc::trackable::trackable (D.105227);
  goto <D.105228>;
  <D.105226>:
  <D.105228>:
  try
    {
      if (1 != 0) goto <D.105229>; else goto <D.105230>;
      <D.105229>:
      if (1 == 0) goto <D.105232>; else goto <D.105233>;
      <D.105232>:
      iftmp.43 = 32B;
      goto <D.105234>;
      <D.105233>:
      iftmp.43 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105234>:
      D.105235 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105235, iftmp.43);
      goto <D.105236>;
      <D.105230>:
      <D.105236>:
      try
        {
          if (1 == 0) goto <D.105238>; else goto <D.105239>;
          <D.105238>:
          iftmp.44 = 8B;
          goto <D.105240>;
          <D.105239>:
          iftmp.44 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105240>:
          D.105241 = &this->D.102063;
          Glib::Interface::Interface (D.105241, iftmp.44, castitem);
          try
            {
              if (1 == 0) goto <D.105243>; else goto <D.105244>;
              <D.105243>:
              D.105245 = 0B;
              iftmp.45 = *D.105245;
              goto <D.105246>;
              <D.105244>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105246>:
              this->D.102063._vptr.Interface = iftmp.45;
              if (1 == 0) goto <D.105248>; else goto <D.105249>;
              <D.105248>:
              D.105250 = this->D.102063._vptr.Interface;
              D.105251 = D.105250 + 18446744073709551592;
              D.105252 = MEM[(long int *)D.105251];
              iftmp.46 = (sizetype) D.105252;
              goto <D.105253>;
              <D.105249>:
              iftmp.46 = 8;
              <D.105253>:
              D.105254 = this + iftmp.46;
              if (1 == 0) goto <D.105256>; else goto <D.105257>;
              <D.105256>:
              iftmp.47 = MEM[(const void * *)0B + 24B];
              goto <D.105258>;
              <D.105257>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105258>:
              D.105254->_vptr.ObjectBase = iftmp.47;
            }
          catch
            {
              if (1 == 0) goto <D.105260>; else goto <D.105261>;
              <D.105260>:
              iftmp.48 = 8B;
              goto <D.105262>;
              <D.105261>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105262>:
              D.105241 = &this->D.102063;
              Glib::Interface::~Interface (D.105241, iftmp.48);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105263>; else goto <D.105264>;
          <D.105263>:
          if (1 == 0) goto <D.105266>; else goto <D.105267>;
          <D.105266>:
          iftmp.49 = 32B;
          goto <D.105268>;
          <D.105267>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105268>:
          D.105235 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105235, iftmp.49);
          goto <D.105269>;
          <D.105264>:
          <D.105269>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105270>; else goto <D.105271>;
      <D.105270>:
      D.105227 = &this->D.102066;
      sigc::trackable::~trackable (D.105227);
      goto <D.105272>;
      <D.105271>:
      <D.105272>:
    }
}


Gio::Volume::Volume(const Glib::Interface_Class&) (struct Volume * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.105277;
  const void * * iftmp.50;
  struct ObjectBase * D.105285;
  const void * * iftmp.51;
  struct Interface * D.105291;
  int (*__vtbl_ptr_type) () * iftmp.52;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.105299;
  int (*__vtbl_ptr_type) () * D.105300;
  long int D.105301;
  struct ObjectBase * D.105303;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;

  if (0 != 0) goto <D.105275>; else goto <D.105276>;
  <D.105275>:
  D.105277 = &this->D.102066;
  sigc::trackable::trackable (D.105277);
  goto <D.105278>;
  <D.105276>:
  <D.105278>:
  try
    {
      if (0 != 0) goto <D.105279>; else goto <D.105280>;
      <D.105279>:
      if (0 == 0) goto <D.105282>; else goto <D.105283>;
      <D.105282>:
      iftmp.50 = __vtt_parm + 32;
      goto <D.105284>;
      <D.105283>:
      iftmp.50 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105284>:
      D.105285 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105285, iftmp.50);
      goto <D.105286>;
      <D.105280>:
      <D.105286>:
      try
        {
          if (0 == 0) goto <D.105288>; else goto <D.105289>;
          <D.105288>:
          iftmp.51 = __vtt_parm + 8;
          goto <D.105290>;
          <D.105289>:
          iftmp.51 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105290>:
          D.105291 = &this->D.102063;
          Glib::Interface::Interface (D.105291, iftmp.51, interface_class);
          try
            {
              if (0 == 0) goto <D.105293>; else goto <D.105294>;
              <D.105293>:
              iftmp.52 = *__vtt_parm;
              goto <D.105295>;
              <D.105294>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105295>:
              this->D.102063._vptr.Interface = iftmp.52;
              if (0 == 0) goto <D.105297>; else goto <D.105298>;
              <D.105297>:
              D.105299 = this->D.102063._vptr.Interface;
              D.105300 = D.105299 + 18446744073709551592;
              D.105301 = MEM[(long int *)D.105300];
              iftmp.53 = (sizetype) D.105301;
              goto <D.105302>;
              <D.105298>:
              iftmp.53 = 8;
              <D.105302>:
              D.105303 = this + iftmp.53;
              if (0 == 0) goto <D.105305>; else goto <D.105306>;
              <D.105305>:
              iftmp.54 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105307>;
              <D.105306>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105307>:
              D.105303->_vptr.ObjectBase = iftmp.54;
            }
          catch
            {
              if (0 == 0) goto <D.105309>; else goto <D.105310>;
              <D.105309>:
              iftmp.55 = __vtt_parm + 8;
              goto <D.105311>;
              <D.105310>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105311>:
              D.105291 = &this->D.102063;
              Glib::Interface::~Interface (D.105291, iftmp.55);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105312>; else goto <D.105313>;
          <D.105312>:
          if (0 == 0) goto <D.105315>; else goto <D.105316>;
          <D.105315>:
          iftmp.56 = __vtt_parm + 32;
          goto <D.105317>;
          <D.105316>:
          iftmp.56 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105317>:
          D.105285 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105285, iftmp.56);
          goto <D.105318>;
          <D.105313>:
          <D.105318>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105319>; else goto <D.105320>;
      <D.105319>:
      D.105277 = &this->D.102066;
      sigc::trackable::~trackable (D.105277);
      goto <D.105321>;
      <D.105320>:
      <D.105321>:
    }
}


Gio::Volume::Volume(const Glib::Interface_Class&) (struct Volume * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.105326;
  const void * * iftmp.57;
  struct ObjectBase * D.105334;
  const void * * iftmp.58;
  struct Interface * D.105340;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * D.105344;
  sizetype iftmp.60;
  int (*__vtbl_ptr_type) () * D.105349;
  int (*__vtbl_ptr_type) () * D.105350;
  long int D.105351;
  struct ObjectBase * D.105353;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * iftmp.62;
  const void * * iftmp.63;

  if (1 != 0) goto <D.105324>; else goto <D.105325>;
  <D.105324>:
  D.105326 = &this->D.102066;
  sigc::trackable::trackable (D.105326);
  goto <D.105327>;
  <D.105325>:
  <D.105327>:
  try
    {
      if (1 != 0) goto <D.105328>; else goto <D.105329>;
      <D.105328>:
      if (1 == 0) goto <D.105331>; else goto <D.105332>;
      <D.105331>:
      iftmp.57 = 32B;
      goto <D.105333>;
      <D.105332>:
      iftmp.57 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
      <D.105333>:
      D.105334 = &this->D.102065;
      Glib::ObjectBase::ObjectBase (D.105334, iftmp.57);
      goto <D.105335>;
      <D.105329>:
      <D.105335>:
      try
        {
          if (1 == 0) goto <D.105337>; else goto <D.105338>;
          <D.105337>:
          iftmp.58 = 8B;
          goto <D.105339>;
          <D.105338>:
          iftmp.58 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
          <D.105339>:
          D.105340 = &this->D.102063;
          Glib::Interface::Interface (D.105340, iftmp.58, interface_class);
          try
            {
              if (1 == 0) goto <D.105342>; else goto <D.105343>;
              <D.105342>:
              D.105344 = 0B;
              iftmp.59 = *D.105344;
              goto <D.105345>;
              <D.105343>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
              <D.105345>:
              this->D.102063._vptr.Interface = iftmp.59;
              if (1 == 0) goto <D.105347>; else goto <D.105348>;
              <D.105347>:
              D.105349 = this->D.102063._vptr.Interface;
              D.105350 = D.105349 + 18446744073709551592;
              D.105351 = MEM[(long int *)D.105350];
              iftmp.60 = (sizetype) D.105351;
              goto <D.105352>;
              <D.105348>:
              iftmp.60 = 8;
              <D.105352>:
              D.105353 = this + iftmp.60;
              if (1 == 0) goto <D.105355>; else goto <D.105356>;
              <D.105355>:
              iftmp.61 = MEM[(const void * *)0B + 24B];
              goto <D.105357>;
              <D.105356>:
              iftmp.61 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
              <D.105357>:
              D.105353->_vptr.ObjectBase = iftmp.61;
            }
          catch
            {
              if (1 == 0) goto <D.105359>; else goto <D.105360>;
              <D.105359>:
              iftmp.62 = 8B;
              goto <D.105361>;
              <D.105360>:
              iftmp.62 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
              <D.105361>:
              D.105340 = &this->D.102063;
              Glib::Interface::~Interface (D.105340, iftmp.62);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105362>; else goto <D.105363>;
          <D.105362>:
          if (1 == 0) goto <D.105365>; else goto <D.105366>;
          <D.105365>:
          iftmp.63 = 32B;
          goto <D.105367>;
          <D.105366>:
          iftmp.63 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
          <D.105367>:
          D.105334 = &this->D.102065;
          Glib::ObjectBase::~ObjectBase (D.105334, iftmp.63);
          goto <D.105368>;
          <D.105363>:
          <D.105368>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105369>; else goto <D.105370>;
      <D.105369>:
      D.105326 = &this->D.102066;
      sigc::trackable::~trackable (D.105326);
      goto <D.105371>;
      <D.105370>:
      <D.105371>:
    }
}


Gio::Volume::~Volume() (struct Volume * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.64;
  sizetype iftmp.65;
  int (*__vtbl_ptr_type) () * D.105381;
  int (*__vtbl_ptr_type) () * D.105382;
  long int D.105383;
  struct ObjectBase * D.105385;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * iftmp.67;
  struct Interface * D.105394;
  int D.105395;
  const void * * iftmp.68;
  struct ObjectBase * D.105402;
  struct trackable * D.105406;
  int D.105408;

  {
    if (0 == 0) goto <D.105375>; else goto <D.105376>;
    <D.105375>:
    iftmp.64 = *__vtt_parm;
    goto <D.105377>;
    <D.105376>:
    iftmp.64 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
    <D.105377>:
    this->D.102063._vptr.Interface = iftmp.64;
    if (0 == 0) goto <D.105379>; else goto <D.105380>;
    <D.105379>:
    D.105381 = this->D.102063._vptr.Interface;
    D.105382 = D.105381 + 18446744073709551592;
    D.105383 = MEM[(long int *)D.105382];
    iftmp.65 = (sizetype) D.105383;
    goto <D.105384>;
    <D.105380>:
    iftmp.65 = 8;
    <D.105384>:
    D.105385 = this + iftmp.65;
    if (0 == 0) goto <D.105387>; else goto <D.105388>;
    <D.105387>:
    iftmp.66 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.105389>;
    <D.105388>:
    iftmp.66 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
    <D.105389>:
    D.105385->_vptr.ObjectBase = iftmp.66;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.105391>; else goto <D.105392>;
                    <D.105391>:
                    iftmp.67 = __vtt_parm + 8;
                    goto <D.105393>;
                    <D.105392>:
                    iftmp.67 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
                    <D.105393>:
                    D.105394 = &this->D.102063;
                    Glib::Interface::~Interface (D.105394, iftmp.67);
                  }
              }
            finally
              {
                D.105395 = 0;
                if (D.105395 != 0) goto <D.105396>; else goto <D.105397>;
                <D.105396>:
                if (0 == 0) goto <D.105399>; else goto <D.105400>;
                <D.105399>:
                iftmp.68 = __vtt_parm + 32;
                goto <D.105401>;
                <D.105400>:
                iftmp.68 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
                <D.105401>:
                D.105402 = &this->D.102065;
                Glib::ObjectBase::~ObjectBase (D.105402, iftmp.68);
                goto <D.105403>;
                <D.105397>:
                <D.105403>:
              }
          }
        finally
          {
            D.105395 = 0;
            if (D.105395 != 0) goto <D.105404>; else goto <D.105405>;
            <D.105404>:
            D.105406 = &this->D.102066;
            sigc::trackable::~trackable (D.105406);
            goto <D.105407>;
            <D.105405>:
            <D.105407>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102907>:
  D.105408 = 0;
  if (D.105408 != 0) goto <D.105409>; else goto <D.105410>;
  <D.105409>:
  operator delete (this);
  goto <D.105411>;
  <D.105410>:
  <D.105411>:
}


virtual Gio::Volume::~Volume() (struct Volume * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.69;
  const void * * D.105427;
  sizetype iftmp.70;
  int (*__vtbl_ptr_type) () * D.105432;
  int (*__vtbl_ptr_type) () * D.105433;
  long int D.105434;
  struct ObjectBase * D.105436;
  int (*__vtbl_ptr_type) () * iftmp.71;
  const void * * iftmp.72;
  struct Interface * D.105445;
  int D.105446;
  const void * * iftmp.73;
  struct ObjectBase * D.105453;
  struct trackable * D.105457;
  int D.105459;

  {
    if (2 == 0) goto <D.105425>; else goto <D.105426>;
    <D.105425>:
    D.105427 = 0B;
    iftmp.69 = *D.105427;
    goto <D.105428>;
    <D.105426>:
    iftmp.69 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 32B];
    <D.105428>:
    this->D.102063._vptr.Interface = iftmp.69;
    if (2 == 0) goto <D.105430>; else goto <D.105431>;
    <D.105430>:
    D.105432 = this->D.102063._vptr.Interface;
    D.105433 = D.105432 + 18446744073709551592;
    D.105434 = MEM[(long int *)D.105433];
    iftmp.70 = (sizetype) D.105434;
    goto <D.105435>;
    <D.105431>:
    iftmp.70 = 8;
    <D.105435>:
    D.105436 = this + iftmp.70;
    if (2 == 0) goto <D.105438>; else goto <D.105439>;
    <D.105438>:
    iftmp.71 = MEM[(const void * *)0B + 24B];
    goto <D.105440>;
    <D.105439>:
    iftmp.71 = &MEM[(void *)&_ZTVN3Gio6VolumeE + 128B];
    <D.105440>:
    D.105436->_vptr.ObjectBase = iftmp.71;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.105442>; else goto <D.105443>;
                    <D.105442>:
                    iftmp.72 = 8B;
                    goto <D.105444>;
                    <D.105443>:
                    iftmp.72 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 8B];
                    <D.105444>:
                    D.105445 = &this->D.102063;
                    Glib::Interface::~Interface (D.105445, iftmp.72);
                  }
              }
            finally
              {
                D.105446 = 2;
                if (D.105446 != 0) goto <D.105447>; else goto <D.105448>;
                <D.105447>:
                if (2 == 0) goto <D.105450>; else goto <D.105451>;
                <D.105450>:
                iftmp.73 = 32B;
                goto <D.105452>;
                <D.105451>:
                iftmp.73 = &MEM[(void *)&_ZTTN3Gio6VolumeE + 32B];
                <D.105452>:
                D.105453 = &this->D.102065;
                Glib::ObjectBase::~ObjectBase (D.105453, iftmp.73);
                goto <D.105454>;
                <D.105448>:
                <D.105454>:
              }
          }
        finally
          {
            D.105446 = 2;
            if (D.105446 != 0) goto <D.105455>; else goto <D.105456>;
            <D.105455>:
            D.105457 = &this->D.102066;
            sigc::trackable::~trackable (D.105457);
            goto <D.105458>;
            <D.105456>:
            <D.105458>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102910>:
  D.105459 = 0;
  if (D.105459 != 0) goto <D.105460>; else goto <D.105461>;
  <D.105460>:
  operator delete (this);
  goto <D.105462>;
  <D.105461>:
  <D.105462>:
}


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


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

  D.105475 = Gio::Volume_Class::init (&volume_class_);
  Glib::Interface_Class::add_interface (D.105475, gtype_implementer);
}


static GType Gio::Volume::get_type() ()
{
  GType D.105477;
  const struct Interface_Class & D.105478;
  const struct Class * D.105479;

  D.105478 = Gio::Volume_Class::init (&volume_class_);
  D.105479 = &D.105478->D.102240;
  D.105477 = Glib::Class::get_type (D.105479);
  return D.105477;
}


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

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


static GType Gio::Volume::get_base_type() ()
{
  GType D.105484;

  D.105484 = g_drive_get_type ();
  return D.105484;
}


std::string Gio::Volume::get_name() const (const struct Volume * const this)
{
  const struct GVolume * D.105488;
  char * D.105489;

  D.105488 = Gio::Volume::gobj (this);
  D.105489 = g_volume_get_name (D.105488);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.105489); [return slot optimization]
  return <retval>;
}


const GVolume* Gio::Volume::gobj() const (const struct Volume * const this)
{
  const struct GVolume * D.105492;
  int (*__vtbl_ptr_type) () * D.105493;
  int (*__vtbl_ptr_type) () * D.105494;
  long int D.105495;
  sizetype D.105496;
  const struct ObjectBase * D.105497;

  D.105493 = this->D.102063._vptr.Interface;
  D.105494 = D.105493 + 18446744073709551592;
  D.105495 = MEM[(long int *)D.105494];
  D.105496 = (sizetype) D.105495;
  D.105497 = this + D.105496;
  D.105492 = D.105497->gobject_;
  return D.105492;
}


std::string Glib::convert_return_gchar_ptr_to_stdstring(char*) (char * str)
{
  struct allocator D.78983;
  bool cleanup.74;
  struct ScopedPtr D.78981;
  bool cleanup.75;
  char * D.105508;
  struct string * D.105509;

  cleanup.74 = 0;
  try
    {
      cleanup.75 = 0;
      try
        {
          if (str != 0B) goto <D.105500>; else goto <D.105501>;
          <D.105500>:
          std::allocator<char>::allocator (&D.78983);
          cleanup.74 = 1;
          Glib::ScopedPtr<char>::ScopedPtr (&D.78981, str);
          cleanup.75 = 1;
          D.105508 = Glib::ScopedPtr<char>::get (&D.78981);
          D.105509 = <retval>;
          std::basic_string<char>::basic_string (D.105509, D.105508, &D.78983);
          goto <D.105510>;
          <D.105501>:
          D.105509 = <retval>;
          std::basic_string<char>::basic_string (D.105509);
          <D.105510>:
          return <retval>;
        }
      finally
        {
          if (cleanup.75 != 0) goto <D.105506>; else goto <D.105507>;
          <D.105506>:
          Glib::ScopedPtr<char>::~ScopedPtr (&D.78981);
          D.78981 = {CLOBBER};
          <D.105507>:
        }
    }
  finally
    {
      if (cleanup.74 != 0) goto <D.105503>; else goto <D.105504>;
      <D.105503>:
      std::allocator<char>::~allocator (&D.78983);
      D.78983 = {CLOBBER};
      <D.105504>:
    }
}


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

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

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


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

  try
    {
      {

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


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

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


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.104238;
  struct _Rep & D.105524;
  char * D.105525;
  struct _Alloc_hider * D.105526;

  std::allocator<char>::allocator (&D.104238);
  try
    {
      D.105524 = std::basic_string<char>::_S_empty_rep ();
      D.105525 = std::basic_string<char>::_Rep::_M_refdata (D.105524);
      D.105526 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.105526, D.105525, &D.104238);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.104238);
      D.104238 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


_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.105534;
  void * D.105535;

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


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

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


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

  try
    {
      {

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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::string Gio::Volume::get_uuid() const (const struct Volume * const this)
{
  const struct GVolume * D.105544;
  char * D.105545;

  D.105544 = Gio::Volume::gobj (this);
  D.105545 = g_volume_get_uuid (D.105544);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.105545); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Gio::Icon> Gio::Volume::get_icon() (struct Volume * const this)
{
  struct GVolume * D.105549;
  struct GIcon * D.105550;
  bool retval.76;
  struct Icon * D.105554;
  int (*__vtbl_ptr_type) () * D.105555;
  int (*__vtbl_ptr_type) () * D.105556;
  long int D.105557;
  sizetype D.105558;
  struct ObjectBase * D.105559;
  int (*__vtbl_ptr_type) () * D.105560;
  int (*__vtbl_ptr_type) () * D.105561;
  int (*__vtbl_ptr_type) () D.105562;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105549 = Gio::Volume::gobj (this);
  D.105550 = g_volume_get_icon (D.105549);
  *<retval> = Glib::wrap (D.105550, 0); [return slot optimization]
  try
    {
      retval.76 = Glib::RefPtr<Gio::Icon>::operator bool (<retval>);
      if (retval.76 != 0) goto <D.105552>; else goto <D.105553>;
      <D.105552>:
      D.105554 = Glib::RefPtr<Gio::Icon>::operator-> (<retval>);
      D.105555 = D.105554->D.86022._vptr.Interface;
      D.105556 = D.105555 + 18446744073709551592;
      D.105557 = MEM[(long int *)D.105556];
      D.105558 = (sizetype) D.105557;
      D.105559 = D.105554 + D.105558;
      D.105555 = D.105554->D.86022._vptr.Interface;
      D.105556 = D.105555 + 18446744073709551592;
      D.105557 = MEM[(long int *)D.105556];
      D.105558 = (sizetype) D.105557;
      D.105559 = D.105554 + D.105558;
      D.105560 = D.105559->_vptr.ObjectBase;
      D.105561 = D.105560 + 16;
      D.105562 = *D.105561;
      D.105555 = D.105554->D.86022._vptr.Interface;
      D.105556 = D.105555 + 18446744073709551592;
      D.105557 = MEM[(long int *)D.105556];
      D.105558 = (sizetype) D.105557;
      D.105559 = D.105554 + D.105558;
      OBJ_TYPE_REF(D.105562;(const struct ObjectBase)D.105559->2) (D.105559);
      goto <D.105563>;
      <D.105553>:
      <D.105563>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::Icon>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Icon] (const struct RefPtr * const this)
{
  bool D.105567;
  struct Icon * D.105568;

  D.105568 = this->pCppObject_;
  D.105567 = D.105568 != 0B;
  return D.105567;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Icon] (struct RefPtr * const this)
{
  struct Icon * D.105572;
  int (*__vtbl_ptr_type) () * D.105575;
  int (*__vtbl_ptr_type) () * D.105576;
  long int D.105577;
  sizetype D.105578;
  struct ObjectBase * D.105579;
  int (*__vtbl_ptr_type) () * D.105580;
  int (*__vtbl_ptr_type) () * D.105581;
  int (*__vtbl_ptr_type) () D.105582;

  {
    try
      {
        D.105572 = this->pCppObject_;
        if (D.105572 != 0B) goto <D.105573>; else goto <D.105574>;
        <D.105573>:
        D.105572 = this->pCppObject_;
        D.105572 = this->pCppObject_;
        D.105575 = D.105572->D.86022._vptr.Interface;
        D.105576 = D.105575 + 18446744073709551592;
        D.105577 = MEM[(long int *)D.105576];
        D.105578 = (sizetype) D.105577;
        D.105579 = D.105572 + D.105578;
        D.105572 = this->pCppObject_;
        D.105572 = this->pCppObject_;
        D.105575 = D.105572->D.86022._vptr.Interface;
        D.105576 = D.105575 + 18446744073709551592;
        D.105577 = MEM[(long int *)D.105576];
        D.105578 = (sizetype) D.105577;
        D.105579 = D.105572 + D.105578;
        D.105580 = D.105579->_vptr.ObjectBase;
        D.105581 = D.105580 + 24;
        D.105582 = *D.105581;
        D.105572 = this->pCppObject_;
        D.105572 = this->pCppObject_;
        D.105575 = D.105572->D.86022._vptr.Interface;
        D.105576 = D.105575 + 18446744073709551592;
        D.105577 = MEM[(long int *)D.105576];
        D.105578 = (sizetype) D.105577;
        D.105579 = D.105572 + D.105578;
        OBJ_TYPE_REF(D.105582;(const struct ObjectBase)D.105579->3) (D.105579);
        goto <D.105583>;
        <D.105574>:
        <D.105583>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104362>:
}


Glib::RefPtr<const Gio::Icon> Gio::Volume::get_icon() const (const struct Volume * const this)
{
  struct RefPtr D.103204;

  D.103204 = Gio::Volume::get_icon (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Icon>::RefPtr<Gio::Icon> (<retval>, &D.103204);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Icon>::~RefPtr (&D.103204);
      D.103204 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Icon; T_CppObject = const Gio::Icon] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Icon * D.105589;
  const struct Icon * D.105590;
  int (*__vtbl_ptr_type) () * D.105593;
  int (*__vtbl_ptr_type) () * D.105594;
  long int D.105595;
  sizetype D.105596;
  const struct ObjectBase * D.105597;
  int (*__vtbl_ptr_type) () * D.105598;
  int (*__vtbl_ptr_type) () * D.105599;
  int (*__vtbl_ptr_type) () D.105600;

  D.105589 = Glib::RefPtr<Gio::Icon>::operator-> (src);
  this->pCppObject_ = D.105589;
  D.105590 = this->pCppObject_;
  if (D.105590 != 0B) goto <D.105591>; else goto <D.105592>;
  <D.105591>:
  D.105590 = this->pCppObject_;
  D.105590 = this->pCppObject_;
  D.105593 = D.105590->D.86022._vptr.Interface;
  D.105594 = D.105593 + 18446744073709551592;
  D.105595 = MEM[(long int *)D.105594];
  D.105596 = (sizetype) D.105595;
  D.105597 = D.105590 + D.105596;
  D.105590 = this->pCppObject_;
  D.105590 = this->pCppObject_;
  D.105593 = D.105590->D.86022._vptr.Interface;
  D.105594 = D.105593 + 18446744073709551592;
  D.105595 = MEM[(long int *)D.105594];
  D.105596 = (sizetype) D.105595;
  D.105597 = D.105590 + D.105596;
  D.105598 = D.105597->_vptr.ObjectBase;
  D.105599 = D.105598 + 16;
  D.105600 = *D.105599;
  D.105590 = this->pCppObject_;
  D.105590 = this->pCppObject_;
  D.105593 = D.105590->D.86022._vptr.Interface;
  D.105594 = D.105593 + 18446744073709551592;
  D.105595 = MEM[(long int *)D.105594];
  D.105596 = (sizetype) D.105595;
  D.105597 = D.105590 + D.105596;
  OBJ_TYPE_REF(D.105600;(const struct ObjectBase)D.105597->2) (D.105597);
  goto <D.105601>;
  <D.105592>:
  <D.105601>:
}


Glib::RefPtr<Gio::Icon> Gio::Volume::get_symbolic_icon() (struct Volume * const this)
{
  struct GVolume * D.105603;
  struct GIcon * D.105604;
  bool retval.77;
  struct Icon * D.105608;
  int (*__vtbl_ptr_type) () * D.105609;
  int (*__vtbl_ptr_type) () * D.105610;
  long int D.105611;
  sizetype D.105612;
  struct ObjectBase * D.105613;
  int (*__vtbl_ptr_type) () * D.105614;
  int (*__vtbl_ptr_type) () * D.105615;
  int (*__vtbl_ptr_type) () D.105616;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105603 = Gio::Volume::gobj (this);
  D.105604 = g_volume_get_symbolic_icon (D.105603);
  *<retval> = Glib::wrap (D.105604, 0); [return slot optimization]
  try
    {
      retval.77 = Glib::RefPtr<Gio::Icon>::operator bool (<retval>);
      if (retval.77 != 0) goto <D.105606>; else goto <D.105607>;
      <D.105606>:
      D.105608 = Glib::RefPtr<Gio::Icon>::operator-> (<retval>);
      D.105609 = D.105608->D.86022._vptr.Interface;
      D.105610 = D.105609 + 18446744073709551592;
      D.105611 = MEM[(long int *)D.105610];
      D.105612 = (sizetype) D.105611;
      D.105613 = D.105608 + D.105612;
      D.105609 = D.105608->D.86022._vptr.Interface;
      D.105610 = D.105609 + 18446744073709551592;
      D.105611 = MEM[(long int *)D.105610];
      D.105612 = (sizetype) D.105611;
      D.105613 = D.105608 + D.105612;
      D.105614 = D.105613->_vptr.ObjectBase;
      D.105615 = D.105614 + 16;
      D.105616 = *D.105615;
      D.105609 = D.105608->D.86022._vptr.Interface;
      D.105610 = D.105609 + 18446744073709551592;
      D.105611 = MEM[(long int *)D.105610];
      D.105612 = (sizetype) D.105611;
      D.105613 = D.105608 + D.105612;
      OBJ_TYPE_REF(D.105616;(const struct ObjectBase)D.105613->2) (D.105613);
      goto <D.105617>;
      <D.105607>:
      <D.105617>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::Icon>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<const Gio::Icon> Gio::Volume::get_symbolic_icon() const (const struct Volume * const this)
{
  struct RefPtr D.103233;

  D.103233 = Gio::Volume::get_symbolic_icon (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Icon>::RefPtr<Gio::Icon> (<retval>, &D.103233);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Icon>::~RefPtr (&D.103233);
      D.103233 = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Drive> Gio::Volume::get_drive() (struct Volume * const this)
{
  struct GVolume * D.105626;
  struct GDrive * D.105627;
  bool retval.78;
  struct Drive * D.105631;
  int (*__vtbl_ptr_type) () * D.105632;
  int (*__vtbl_ptr_type) () * D.105633;
  long int D.105634;
  sizetype D.105635;
  struct ObjectBase * D.105636;
  int (*__vtbl_ptr_type) () * D.105637;
  int (*__vtbl_ptr_type) () * D.105638;
  int (*__vtbl_ptr_type) () D.105639;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105626 = Gio::Volume::gobj (this);
  D.105627 = g_volume_get_drive (D.105626);
  *<retval> = Glib::wrap (D.105627, 0); [return slot optimization]
  try
    {
      retval.78 = Glib::RefPtr<Gio::Drive>::operator bool (<retval>);
      if (retval.78 != 0) goto <D.105629>; else goto <D.105630>;
      <D.105629>:
      D.105631 = Glib::RefPtr<Gio::Drive>::operator-> (<retval>);
      D.105632 = D.105631->D.100151._vptr.Interface;
      D.105633 = D.105632 + 18446744073709551592;
      D.105634 = MEM[(long int *)D.105633];
      D.105635 = (sizetype) D.105634;
      D.105636 = D.105631 + D.105635;
      D.105632 = D.105631->D.100151._vptr.Interface;
      D.105633 = D.105632 + 18446744073709551592;
      D.105634 = MEM[(long int *)D.105633];
      D.105635 = (sizetype) D.105634;
      D.105636 = D.105631 + D.105635;
      D.105637 = D.105636->_vptr.ObjectBase;
      D.105638 = D.105637 + 16;
      D.105639 = *D.105638;
      D.105632 = D.105631->D.100151._vptr.Interface;
      D.105633 = D.105632 + 18446744073709551592;
      D.105634 = MEM[(long int *)D.105633];
      D.105635 = (sizetype) D.105634;
      D.105636 = D.105631 + D.105635;
      OBJ_TYPE_REF(D.105639;(const struct ObjectBase)D.105636->2) (D.105636);
      goto <D.105640>;
      <D.105630>:
      <D.105640>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::Drive>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Drive] (const struct RefPtr * const this)
{
  bool D.105644;
  struct Drive * D.105645;

  D.105645 = this->pCppObject_;
  D.105644 = D.105645 != 0B;
  return D.105644;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Drive] (struct RefPtr * const this)
{
  struct Drive * D.105649;
  int (*__vtbl_ptr_type) () * D.105652;
  int (*__vtbl_ptr_type) () * D.105653;
  long int D.105654;
  sizetype D.105655;
  struct ObjectBase * D.105656;
  int (*__vtbl_ptr_type) () * D.105657;
  int (*__vtbl_ptr_type) () * D.105658;
  int (*__vtbl_ptr_type) () D.105659;

  {
    try
      {
        D.105649 = this->pCppObject_;
        if (D.105649 != 0B) goto <D.105650>; else goto <D.105651>;
        <D.105650>:
        D.105649 = this->pCppObject_;
        D.105649 = this->pCppObject_;
        D.105652 = D.105649->D.100151._vptr.Interface;
        D.105653 = D.105652 + 18446744073709551592;
        D.105654 = MEM[(long int *)D.105653];
        D.105655 = (sizetype) D.105654;
        D.105656 = D.105649 + D.105655;
        D.105649 = this->pCppObject_;
        D.105649 = this->pCppObject_;
        D.105652 = D.105649->D.100151._vptr.Interface;
        D.105653 = D.105652 + 18446744073709551592;
        D.105654 = MEM[(long int *)D.105653];
        D.105655 = (sizetype) D.105654;
        D.105656 = D.105649 + D.105655;
        D.105657 = D.105656->_vptr.ObjectBase;
        D.105658 = D.105657 + 24;
        D.105659 = *D.105658;
        D.105649 = this->pCppObject_;
        D.105649 = this->pCppObject_;
        D.105652 = D.105649->D.100151._vptr.Interface;
        D.105653 = D.105652 + 18446744073709551592;
        D.105654 = MEM[(long int *)D.105653];
        D.105655 = (sizetype) D.105654;
        D.105656 = D.105649 + D.105655;
        OBJ_TYPE_REF(D.105659;(const struct ObjectBase)D.105656->3) (D.105656);
        goto <D.105660>;
        <D.105651>:
        <D.105660>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104292>:
}


Glib::RefPtr<const Gio::Drive> Gio::Volume::get_drive() const (const struct Volume * const this)
{
  struct RefPtr D.103368;

  D.103368 = Gio::Volume::get_drive (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Drive>::RefPtr<Gio::Drive> (<retval>, &D.103368);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Drive>::~RefPtr (&D.103368);
      D.103368 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Drive; T_CppObject = const Gio::Drive] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Drive * D.105666;
  const struct Drive * D.105667;
  int (*__vtbl_ptr_type) () * D.105670;
  int (*__vtbl_ptr_type) () * D.105671;
  long int D.105672;
  sizetype D.105673;
  const struct ObjectBase * D.105674;
  int (*__vtbl_ptr_type) () * D.105675;
  int (*__vtbl_ptr_type) () * D.105676;
  int (*__vtbl_ptr_type) () D.105677;

  D.105666 = Glib::RefPtr<Gio::Drive>::operator-> (src);
  this->pCppObject_ = D.105666;
  D.105667 = this->pCppObject_;
  if (D.105667 != 0B) goto <D.105668>; else goto <D.105669>;
  <D.105668>:
  D.105667 = this->pCppObject_;
  D.105667 = this->pCppObject_;
  D.105670 = D.105667->D.100151._vptr.Interface;
  D.105671 = D.105670 + 18446744073709551592;
  D.105672 = MEM[(long int *)D.105671];
  D.105673 = (sizetype) D.105672;
  D.105674 = D.105667 + D.105673;
  D.105667 = this->pCppObject_;
  D.105667 = this->pCppObject_;
  D.105670 = D.105667->D.100151._vptr.Interface;
  D.105671 = D.105670 + 18446744073709551592;
  D.105672 = MEM[(long int *)D.105671];
  D.105673 = (sizetype) D.105672;
  D.105674 = D.105667 + D.105673;
  D.105675 = D.105674->_vptr.ObjectBase;
  D.105676 = D.105675 + 16;
  D.105677 = *D.105676;
  D.105667 = this->pCppObject_;
  D.105667 = this->pCppObject_;
  D.105670 = D.105667->D.100151._vptr.Interface;
  D.105671 = D.105670 + 18446744073709551592;
  D.105672 = MEM[(long int *)D.105671];
  D.105673 = (sizetype) D.105672;
  D.105674 = D.105667 + D.105673;
  OBJ_TYPE_REF(D.105677;(const struct ObjectBase)D.105674->2) (D.105674);
  goto <D.105678>;
  <D.105669>:
  <D.105678>:
}


Glib::RefPtr<Gio::Mount> Gio::Volume::get_mount() (struct Volume * const this)
{
  struct GVolume * D.105680;
  struct GMount * D.105681;
  bool retval.79;
  struct Mount * D.105685;
  int (*__vtbl_ptr_type) () * D.105686;
  int (*__vtbl_ptr_type) () * D.105687;
  long int D.105688;
  sizetype D.105689;
  struct ObjectBase * D.105690;
  int (*__vtbl_ptr_type) () * D.105691;
  int (*__vtbl_ptr_type) () * D.105692;
  int (*__vtbl_ptr_type) () D.105693;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105680 = Gio::Volume::gobj (this);
  D.105681 = g_volume_get_mount (D.105680);
  *<retval> = Glib::wrap (D.105681, 0); [return slot optimization]
  try
    {
      retval.79 = Glib::RefPtr<Gio::Mount>::operator bool (<retval>);
      if (retval.79 != 0) goto <D.105683>; else goto <D.105684>;
      <D.105683>:
      D.105685 = Glib::RefPtr<Gio::Mount>::operator-> (<retval>);
      D.105686 = D.105685->D.99699._vptr.Interface;
      D.105687 = D.105686 + 18446744073709551592;
      D.105688 = MEM[(long int *)D.105687];
      D.105689 = (sizetype) D.105688;
      D.105690 = D.105685 + D.105689;
      D.105686 = D.105685->D.99699._vptr.Interface;
      D.105687 = D.105686 + 18446744073709551592;
      D.105688 = MEM[(long int *)D.105687];
      D.105689 = (sizetype) D.105688;
      D.105690 = D.105685 + D.105689;
      D.105691 = D.105690->_vptr.ObjectBase;
      D.105692 = D.105691 + 16;
      D.105693 = *D.105692;
      D.105686 = D.105685->D.99699._vptr.Interface;
      D.105687 = D.105686 + 18446744073709551592;
      D.105688 = MEM[(long int *)D.105687];
      D.105689 = (sizetype) D.105688;
      D.105690 = D.105685 + D.105689;
      OBJ_TYPE_REF(D.105693;(const struct ObjectBase)D.105690->2) (D.105690);
      goto <D.105694>;
      <D.105684>:
      <D.105694>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::Mount>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Mount] (const struct RefPtr * const this)
{
  bool D.105698;
  struct Mount * D.105699;

  D.105699 = this->pCppObject_;
  D.105698 = D.105699 != 0B;
  return D.105698;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Mount] (struct RefPtr * const this)
{
  struct Mount * D.105703;
  int (*__vtbl_ptr_type) () * D.105706;
  int (*__vtbl_ptr_type) () * D.105707;
  long int D.105708;
  sizetype D.105709;
  struct ObjectBase * D.105710;
  int (*__vtbl_ptr_type) () * D.105711;
  int (*__vtbl_ptr_type) () * D.105712;
  int (*__vtbl_ptr_type) () D.105713;

  {
    try
      {
        D.105703 = this->pCppObject_;
        if (D.105703 != 0B) goto <D.105704>; else goto <D.105705>;
        <D.105704>:
        D.105703 = this->pCppObject_;
        D.105703 = this->pCppObject_;
        D.105706 = D.105703->D.99699._vptr.Interface;
        D.105707 = D.105706 + 18446744073709551592;
        D.105708 = MEM[(long int *)D.105707];
        D.105709 = (sizetype) D.105708;
        D.105710 = D.105703 + D.105709;
        D.105703 = this->pCppObject_;
        D.105703 = this->pCppObject_;
        D.105706 = D.105703->D.99699._vptr.Interface;
        D.105707 = D.105706 + 18446744073709551592;
        D.105708 = MEM[(long int *)D.105707];
        D.105709 = (sizetype) D.105708;
        D.105710 = D.105703 + D.105709;
        D.105711 = D.105710->_vptr.ObjectBase;
        D.105712 = D.105711 + 24;
        D.105713 = *D.105712;
        D.105703 = this->pCppObject_;
        D.105703 = this->pCppObject_;
        D.105706 = D.105703->D.99699._vptr.Interface;
        D.105707 = D.105706 + 18446744073709551592;
        D.105708 = MEM[(long int *)D.105707];
        D.105709 = (sizetype) D.105708;
        D.105710 = D.105703 + D.105709;
        OBJ_TYPE_REF(D.105713;(const struct ObjectBase)D.105710->3) (D.105710);
        goto <D.105714>;
        <D.105705>:
        <D.105714>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104281>:
}


Glib::RefPtr<const Gio::Mount> Gio::Volume::get_mount() const (const struct Volume * const this)
{
  struct RefPtr D.103521;

  D.103521 = Gio::Volume::get_mount (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Mount>::RefPtr<Gio::Mount> (<retval>, &D.103521);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Mount>::~RefPtr (&D.103521);
      D.103521 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Mount; T_CppObject = const Gio::Mount] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Mount * D.105720;
  const struct Mount * D.105721;
  int (*__vtbl_ptr_type) () * D.105724;
  int (*__vtbl_ptr_type) () * D.105725;
  long int D.105726;
  sizetype D.105727;
  const struct ObjectBase * D.105728;
  int (*__vtbl_ptr_type) () * D.105729;
  int (*__vtbl_ptr_type) () * D.105730;
  int (*__vtbl_ptr_type) () D.105731;

  D.105720 = Glib::RefPtr<Gio::Mount>::operator-> (src);
  this->pCppObject_ = D.105720;
  D.105721 = this->pCppObject_;
  if (D.105721 != 0B) goto <D.105722>; else goto <D.105723>;
  <D.105722>:
  D.105721 = this->pCppObject_;
  D.105721 = this->pCppObject_;
  D.105724 = D.105721->D.99699._vptr.Interface;
  D.105725 = D.105724 + 18446744073709551592;
  D.105726 = MEM[(long int *)D.105725];
  D.105727 = (sizetype) D.105726;
  D.105728 = D.105721 + D.105727;
  D.105721 = this->pCppObject_;
  D.105721 = this->pCppObject_;
  D.105724 = D.105721->D.99699._vptr.Interface;
  D.105725 = D.105724 + 18446744073709551592;
  D.105726 = MEM[(long int *)D.105725];
  D.105727 = (sizetype) D.105726;
  D.105728 = D.105721 + D.105727;
  D.105729 = D.105728->_vptr.ObjectBase;
  D.105730 = D.105729 + 16;
  D.105731 = *D.105730;
  D.105721 = this->pCppObject_;
  D.105721 = this->pCppObject_;
  D.105724 = D.105721->D.99699._vptr.Interface;
  D.105725 = D.105724 + 18446744073709551592;
  D.105726 = MEM[(long int *)D.105725];
  D.105727 = (sizetype) D.105726;
  D.105728 = D.105721 + D.105727;
  OBJ_TYPE_REF(D.105731;(const struct ObjectBase)D.105728->2) (D.105728);
  goto <D.105732>;
  <D.105723>:
  <D.105732>:
}


bool Gio::Volume::can_mount() const (const struct Volume * const this)
{
  bool D.105733;
  const struct GVolume * D.105734;
  int D.105735;

  D.105734 = Gio::Volume::gobj (this);
  D.105735 = g_volume_can_mount (D.105734);
  D.105733 = D.105735 != 0;
  return D.105733;
}


bool Gio::Volume::can_eject() const (const struct Volume * const this)
{
  bool D.105738;
  const struct GVolume * D.105739;
  int D.105740;

  D.105739 = Gio::Volume::gobj (this);
  D.105740 = g_volume_can_eject (D.105739);
  D.105738 = D.105740 != 0;
  return D.105738;
}


bool Gio::Volume::should_automount() const (const struct Volume * const this)
{
  bool D.105743;
  const struct GVolume * D.105744;
  int D.105745;

  D.105744 = Gio::Volume::gobj (this);
  D.105745 = g_volume_should_automount (D.105744);
  D.105743 = D.105745 != 0;
  return D.105743;
}


bool Gio::Volume::mount_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct Volume * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.105748;
  struct GVolume * D.105749;
  int D.105750;
  struct GError * gerror.80;
  bool D.105754;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.105748 = Glib::unwrap<Gio::AsyncResult> (result);
      D.105749 = Gio::Volume::gobj (this);
      D.105750 = g_volume_mount_finish (D.105749, D.105748, &gerror);
      retvalue = D.105750 != 0;
      gerror.80 = gerror;
      if (gerror.80 != 0B) goto <D.105752>; else goto <D.105753>;
      <D.105752>:
      gerror.80 = gerror;
      Glib::Error::throw_exception (gerror.80);
      <D.105753>:
      D.105754 = retvalue;
      return D.105754;
    }
  finally
    {
      gerror = {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.105760;
  struct BaseObjectType * iftmp.81;
  bool D.105762;
  struct AsyncResult * D.105765;

  D.105762 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.105762 != 0) goto <D.105763>; else goto <D.105764>;
  <D.105763>:
  D.105765 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.81 = Gio::AsyncResult::gobj (D.105765);
  goto <D.105766>;
  <D.105764>:
  iftmp.81 = 0B;
  <D.105766>:
  D.105760 = iftmp.81;
  return D.105760;
}


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

  D.105769 = this->pCppObject_;
  D.105768 = D.105769 != 0B;
  return D.105768;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.105773;
  int (*__vtbl_ptr_type) () * D.105774;
  int (*__vtbl_ptr_type) () * D.105775;
  long int D.105776;
  sizetype D.105777;
  struct ObjectBase * D.105778;

  D.105774 = this->D.86546._vptr.Interface;
  D.105775 = D.105774 + 18446744073709551592;
  D.105776 = MEM[(long int *)D.105775];
  D.105777 = (sizetype) D.105776;
  D.105778 = this + D.105777;
  D.105773 = D.105778->gobject_;
  return D.105773;
}


bool Gio::Volume::eject_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct Volume * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.105780;
  struct GVolume * D.105781;
  int D.105782;
  struct GError * gerror.82;
  bool D.105786;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.105780 = Glib::unwrap<Gio::AsyncResult> (result);
      D.105781 = Gio::Volume::gobj (this);
      D.105782 = g_volume_eject_with_operation_finish (D.105781, D.105780, &gerror);
      retvalue = D.105782 != 0;
      gerror.82 = gerror;
      if (gerror.82 != 0B) goto <D.105784>; else goto <D.105785>;
      <D.105784>:
      gerror.82 = gerror;
      Glib::Error::throw_exception (gerror.82);
      <D.105785>:
      D.105786 = retvalue;
      return D.105786;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::string Gio::Volume::get_identifier(const string&) const (const struct Volume * const this, const struct string & kind)
{
  const char * D.105793;
  const struct GVolume * D.105794;
  char * D.105795;

  D.105793 = std::basic_string<char>::c_str (kind);
  D.105794 = Gio::Volume::gobj (this);
  D.105795 = g_volume_get_identifier (D.105794, D.105793);
  *<retval> = Glib::convert_return_gchar_ptr_to_stdstring (D.105795); [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.105799;

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


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

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


Glib::StringArrayHandle Gio::Volume::enumerate_identifiers() const (const struct Volume * const this)
{
  const struct GVolume * D.105805;
  char * * D.105806;

  D.105805 = Gio::Volume::gobj (this);
  D.105806 = g_volume_enumerate_identifiers (D.105805);
  Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.105806, 2);
  return <retval>;
}


Glib::ArrayHandle<T, Tr>::ArrayHandle(const CType*, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandle<T, Tr>::CType = const char*] (struct ArrayHandle * const this, const char * const * array, OwnershipType ownership)
{
  long unsigned int iftmp.83;

  if (array != 0B) goto <D.105810>; else goto <D.105811>;
  <D.105810>:
  iftmp.83 = Glib::Container_Helpers::compute_array_size<const char*> (array);
  goto <D.105812>;
  <D.105811>:
  iftmp.83 = 0;
  <D.105812>:
  this->size_ = iftmp.83;
  this->parray_ = array;
  this->ownership_ = ownership;
}


std::size_t Glib::Container_Helpers::compute_array_size(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.105813;
  size_t D.105814;
  long int pend.84;
  long int array.85;
  long int D.105817;
  long int D.105818;
  const char * const * pend;

  pend = array;
  goto <D.104603>;
  <D.104604>:
  pend = pend + 8;
  <D.104603>:
  D.105813 = *pend;
  if (D.105813 != 0B) goto <D.104604>; else goto <D.104602>;
  <D.104602>:
  pend.84 = (long int) pend;
  array.85 = (long int) array;
  D.105817 = pend.84 - array.85;
  D.105818 = D.105817 /[ex] 8;
  D.105814 = (size_t) D.105818;
  return D.105814;
}


Glib::RefPtr<Gio::File> Gio::Volume::get_activation_root() (struct Volume * const this)
{
  struct GVolume * D.105821;
  struct GFile * D.105822;

  D.105821 = Gio::Volume::gobj (this);
  D.105822 = g_volume_get_activation_root (D.105821);
  *<retval> = Glib::wrap (D.105822, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::File> Gio::Volume::get_activation_root() const (const struct Volume * const this)
{
  struct RefPtr D.103851;
  const struct GVolume * D.105826;
  struct GFile * D.105827;

  D.105826 = Gio::Volume::gobj (this);
  D.105827 = g_volume_get_activation_root (D.105826);
  D.103851 = Glib::wrap (D.105827, 0); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::File>::RefPtr<Gio::File> (<retval>, &D.103851);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::File>::~RefPtr (&D.103851);
      D.103851 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::File; T_CppObject = const Gio::File] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct File * D.105832;
  const struct File * D.105833;
  int (*__vtbl_ptr_type) () * D.105836;
  int (*__vtbl_ptr_type) () * D.105837;
  long int D.105838;
  sizetype D.105839;
  const struct ObjectBase * D.105840;
  int (*__vtbl_ptr_type) () * D.105841;
  int (*__vtbl_ptr_type) () * D.105842;
  int (*__vtbl_ptr_type) () D.105843;

  D.105832 = Glib::RefPtr<Gio::File>::operator-> (src);
  this->pCppObject_ = D.105832;
  D.105833 = this->pCppObject_;
  if (D.105833 != 0B) goto <D.105834>; else goto <D.105835>;
  <D.105834>:
  D.105833 = this->pCppObject_;
  D.105833 = this->pCppObject_;
  D.105836 = D.105833->D.101656._vptr.Interface;
  D.105837 = D.105836 + 18446744073709551592;
  D.105838 = MEM[(long int *)D.105837];
  D.105839 = (sizetype) D.105838;
  D.105840 = D.105833 + D.105839;
  D.105833 = this->pCppObject_;
  D.105833 = this->pCppObject_;
  D.105836 = D.105833->D.101656._vptr.Interface;
  D.105837 = D.105836 + 18446744073709551592;
  D.105838 = MEM[(long int *)D.105837];
  D.105839 = (sizetype) D.105838;
  D.105840 = D.105833 + D.105839;
  D.105841 = D.105840->_vptr.ObjectBase;
  D.105842 = D.105841 + 16;
  D.105843 = *D.105842;
  D.105833 = this->pCppObject_;
  D.105833 = this->pCppObject_;
  D.105836 = D.105833->D.101656._vptr.Interface;
  D.105837 = D.105836 + 18446744073709551592;
  D.105838 = MEM[(long int *)D.105837];
  D.105839 = (sizetype) D.105838;
  D.105840 = D.105833 + D.105839;
  OBJ_TYPE_REF(D.105843;(const struct ObjectBase)D.105840->2) (D.105840);
  goto <D.105844>;
  <D.105835>:
  <D.105844>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::File] (struct RefPtr * const this)
{
  struct File * D.105847;
  int (*__vtbl_ptr_type) () * D.105850;
  int (*__vtbl_ptr_type) () * D.105851;
  long int D.105852;
  sizetype D.105853;
  struct ObjectBase * D.105854;
  int (*__vtbl_ptr_type) () * D.105855;
  int (*__vtbl_ptr_type) () * D.105856;
  int (*__vtbl_ptr_type) () D.105857;

  {
    try
      {
        D.105847 = this->pCppObject_;
        if (D.105847 != 0B) goto <D.105848>; else goto <D.105849>;
        <D.105848>:
        D.105847 = this->pCppObject_;
        D.105847 = this->pCppObject_;
        D.105850 = D.105847->D.101656._vptr.Interface;
        D.105851 = D.105850 + 18446744073709551592;
        D.105852 = MEM[(long int *)D.105851];
        D.105853 = (sizetype) D.105852;
        D.105854 = D.105847 + D.105853;
        D.105847 = this->pCppObject_;
        D.105847 = this->pCppObject_;
        D.105850 = D.105847->D.101656._vptr.Interface;
        D.105851 = D.105850 + 18446744073709551592;
        D.105852 = MEM[(long int *)D.105851];
        D.105853 = (sizetype) D.105852;
        D.105854 = D.105847 + D.105853;
        D.105855 = D.105854->_vptr.ObjectBase;
        D.105856 = D.105855 + 24;
        D.105857 = *D.105856;
        D.105847 = this->pCppObject_;
        D.105847 = this->pCppObject_;
        D.105850 = D.105847->D.101656._vptr.Interface;
        D.105851 = D.105850 + 18446744073709551592;
        D.105852 = MEM[(long int *)D.105851];
        D.105853 = (sizetype) D.105852;
        D.105854 = D.105847 + D.105853;
        OBJ_TYPE_REF(D.105857;(const struct ObjectBase)D.105854->3) (D.105854);
        goto <D.105858>;
        <D.105849>:
        <D.105858>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104303>:
}


Glib::ustring Gio::Volume::sort_key() (struct Volume * const this)
{
  struct GVolume * D.105861;
  const gchar * D.105862;

  D.105861 = Gio::Volume::gobj (this);
  D.105862 = g_volume_get_sort_key (D.105861);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.105862); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_const_gchar_ptr_to_ustring(const char*) (const char * str)
{
  struct ustring * D.105868;

  if (str != 0B) goto <D.105866>; else goto <D.105867>;
  <D.105866>:
  D.105868 = <retval>;
  Glib::ustring::ustring (D.105868, str);
  goto <D.105869>;
  <D.105867>:
  D.105868 = <retval>;
  Glib::ustring::ustring (D.105868);
  <D.105869>:
  return <retval>;
}


Glib::SignalProxy0<void> Gio::Volume::signal_changed() (struct Volume * const this)
{
  int (*__vtbl_ptr_type) () * D.105872;
  int (*__vtbl_ptr_type) () * D.105873;
  long int D.105874;
  sizetype D.105875;
  struct ObjectBase * D.105876;

  D.105872 = this->D.102063._vptr.Interface;
  D.105873 = D.105872 + 18446744073709551592;
  D.105874 = MEM[(long int *)D.105873];
  D.105875 = (sizetype) D.105874;
  D.105876 = this + D.105875;
  Glib::SignalProxy0<void>::SignalProxy0 (<retval>, D.105876, &Volume_signal_changed_info);
  return <retval>;
}


Glib::SignalProxy0<R>::SignalProxy0(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void] (struct SignalProxy0 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.105878;

  D.105878 = &this->D.103900;
  Glib::SignalProxyNormal::SignalProxyNormal (D.105878, obj, info);
  try
    {

    }
  catch
    {
      D.105878 = &this->D.103900;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.105878);
    }
}


Glib::SignalProxy0<void> Gio::Volume::signal_removed() (struct Volume * const this)
{
  int (*__vtbl_ptr_type) () * D.105880;
  int (*__vtbl_ptr_type) () * D.105881;
  long int D.105882;
  sizetype D.105883;
  struct ObjectBase * D.105884;

  D.105880 = this->D.102063._vptr.Interface;
  D.105881 = D.105880 + 18446744073709551592;
  D.105882 = MEM[(long int *)D.105881];
  D.105883 = (sizetype) D.105882;
  D.105884 = this + D.105883;
  Glib::SignalProxy0<void>::SignalProxy0 (<retval>, D.105884, &Volume_signal_removed_info);
  return <retval>;
}


virtual void Gio::Volume::on_changed() (struct Volume * const this)
{
  long unsigned int D.105886;
  int (*__vtbl_ptr_type) () * D.105887;
  int (*__vtbl_ptr_type) () * D.105888;
  long int D.105889;
  sizetype D.105890;
  struct ObjectBase * D.105891;
  struct GObject * D.105892;
  struct GTypeClass * D.105893;
  void * D.105894;
  void (*<T11509>) (struct GVolume *) D.105897;
  struct GVolume * D.105900;
  struct BaseClassType * const base;

  D.105886 = Gio::Volume::get_type ();
  D.105887 = this->D.102063._vptr.Interface;
  D.105888 = D.105887 + 18446744073709551592;
  D.105889 = MEM[(long int *)D.105888];
  D.105890 = (sizetype) D.105889;
  D.105891 = this + D.105890;
  D.105892 = D.105891->gobject_;
  D.105893 = MEM[(struct GTypeInstance *)D.105892].g_class;
  D.105894 = g_type_interface_peek (D.105893, D.105886);
  base = g_type_interface_peek_parent (D.105894);
  if (base != 0B) goto <D.105895>; else goto <D.105896>;
  <D.105895>:
  D.105897 = base->changed;
  if (D.105897 != 0B) goto <D.105898>; else goto <D.105899>;
  <D.105898>:
  D.105897 = base->changed;
  D.105900 = Gio::Volume::gobj (this);
  D.105897 (D.105900);
  goto <D.105901>;
  <D.105899>:
  <D.105901>:
  <D.105896>:
}


virtual void Gio::Volume::on_removed() (struct Volume * const this)
{
  long unsigned int D.105905;
  int (*__vtbl_ptr_type) () * D.105906;
  int (*__vtbl_ptr_type) () * D.105907;
  long int D.105908;
  sizetype D.105909;
  struct ObjectBase * D.105910;
  struct GObject * D.105911;
  struct GTypeClass * D.105912;
  void * D.105913;
  void (*<T11509>) (struct GVolume *) D.105916;
  struct GVolume * D.105919;
  struct BaseClassType * const base;

  D.105905 = Gio::Volume::get_type ();
  D.105906 = this->D.102063._vptr.Interface;
  D.105907 = D.105906 + 18446744073709551592;
  D.105908 = MEM[(long int *)D.105907];
  D.105909 = (sizetype) D.105908;
  D.105910 = this + D.105909;
  D.105911 = D.105910->gobject_;
  D.105912 = MEM[(struct GTypeInstance *)D.105911].g_class;
  D.105913 = g_type_interface_peek (D.105912, D.105905);
  base = g_type_interface_peek_parent (D.105913);
  if (base != 0B) goto <D.105914>; else goto <D.105915>;
  <D.105914>:
  D.105916 = base->removed;
  if (D.105916 != 0B) goto <D.105917>; else goto <D.105918>;
  <D.105917>:
  D.105916 = base->removed;
  D.105919 = Gio::Volume::gobj (this);
  D.105916 (D.105919);
  goto <D.105920>;
  <D.105918>:
  <D.105920>:
  <D.105915>:
}