Glib::RefPtr<Gio::DBus::Interface> Glib::wrap(GDBusInterface*, bool) (struct GDBusInterface * object, bool take_copy)
{
  int D.98630;
  struct Interface * D.98631;

  D.98630 = (int) take_copy;
  D.98631 = Glib::wrap_auto_interface<Gio::DBus::Interface> (object, D.98630);
  Glib::RefPtr<Gio::DBus::Interface>::RefPtr (<retval>, D.98631);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::DBus::Interface; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct Interface * D.98636;
  long unsigned int D.98639;
  struct Interface * iftmp.0;
  struct ObjectBase * pCppObject.1;
  const struct type_info * iftmp.2;
  int (*__vtbl_ptr_type) () * D.98653;
  const char * D.98655;
  void * result.3;
  bool D.98658;
  bool D.98659;
  int (*__vtbl_ptr_type) () * D.98662;
  int (*__vtbl_ptr_type) () * D.98663;
  long int D.98664;
  sizetype D.98665;
  struct ObjectBase * D.98666;
  int (*__vtbl_ptr_type) () * D.98667;
  int (*__vtbl_ptr_type) () * D.98668;
  int (*__vtbl_ptr_type) () D.98669;
  struct ObjectBase * pCppObject;
  struct Interface * result;

  if (object == 0B) goto <D.98634>; else goto <D.98635>;
  <D.98634>:
  D.98636 = 0B;
  return D.98636;
  <D.98635>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.98637>; else goto <D.98638>;
  <D.98637>:
  D.98639 = Gio::DBus::Interface::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.98639);
  goto <D.98640>;
  <D.98638>:
  <D.98640>:
  result = 0B;
  if (pCppObject != 0B) goto <D.98641>; else goto <D.98642>;
  <D.98641>:
  pCppObject.1 = pCppObject;
  if (pCppObject.1 == 0B) goto <D.98645>; else goto <D.98646>;
  <D.98645>:
  iftmp.0 = 0B;
  goto <D.98647>;
  <D.98646>:
  iftmp.0 = __dynamic_cast (pCppObject.1, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus9InterfaceE, -1);
  <D.98647>:
  result = iftmp.0;
  if (result == 0B) goto <D.98648>; else goto <D.98649>;
  <D.98648>:
  if (pCppObject != 0B) goto <D.98651>; else goto <D.98652>;
  <D.98651>:
  D.98653 = pCppObject->_vptr.ObjectBase;
  iftmp.2 = MEM[(int (*__vtbl_ptr_type) () *)D.98653 + -8B];
  goto <D.98654>;
  <D.98652>:
  __cxa_bad_typeid ();
  <D.98654>:
  D.98655 = std::type_info::name (iftmp.2);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.98655);
  goto <D.98656>;
  <D.98649>:
  <D.98656>:
  goto <D.98657>;
  <D.98642>:
  result.3 = operator new (48);
  try
    {
      Gio::DBus::Interface::Interface (result.3, object);
    }
  catch
    {
      operator delete (result.3);
    }
  result = result.3;
  <D.98657>:
  D.98658 = result != 0B;
  D.98659 = D.98658 & take_copy;
  if (D.98659 != 0) goto <D.98660>; else goto <D.98661>;
  <D.98660>:
  D.98662 = result->D.86043._vptr.Interface;
  D.98663 = D.98662 + 18446744073709551592;
  D.98664 = MEM[(long int *)D.98663];
  D.98665 = (sizetype) D.98664;
  D.98666 = result + D.98665;
  D.98662 = result->D.86043._vptr.Interface;
  D.98663 = D.98662 + 18446744073709551592;
  D.98664 = MEM[(long int *)D.98663];
  D.98665 = (sizetype) D.98664;
  D.98666 = result + D.98665;
  D.98667 = D.98666->_vptr.ObjectBase;
  D.98668 = D.98667 + 16;
  D.98669 = *D.98668;
  D.98662 = result->D.86043._vptr.Interface;
  D.98663 = D.98662 + 18446744073709551592;
  D.98664 = MEM[(long int *)D.98663];
  D.98665 = (sizetype) D.98664;
  D.98666 = result + D.98665;
  OBJ_TYPE_REF(D.98669;(const struct ObjectBase)D.98666->2) (D.98666);
  goto <D.98670>;
  <D.98661>:
  <D.98670>:
  D.98636 = result;
  return D.98636;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.98678;
  const char * iftmp.4;
  const char * D.98680;
  char D.98681;

  D.98680 = this->__name;
  D.98681 = *D.98680;
  if (D.98681 == 42) goto <D.98682>; else goto <D.98683>;
  <D.98682>:
  D.98680 = this->__name;
  iftmp.4 = D.98680 + 1;
  goto <D.98684>;
  <D.98683>:
  iftmp.4 = this->__name;
  <D.98684>:
  D.98678 = iftmp.4;
  return D.98678;
}


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


const Glib::Interface_Class& Gio::DBus::Interface_Class::init() (struct Interface_Class * const this)
{
  long unsigned int D.98686;
  long unsigned int D.98689;
  const struct Interface_Class & D.98691;

  D.98686 = this->D.96515.D.86066.gtype_;
  if (D.98686 == 0) goto <D.98687>; else goto <D.98688>;
  <D.98687>:
  this->D.96515.D.86066.class_init_func_ = iface_init_function;
  D.98689 = g_dbus_interface_get_type ();
  this->D.96515.D.86066.gtype_ = D.98689;
  goto <D.98690>;
  <D.98688>:
  <D.98690>:
  D.98691 = &this->D.96515;
  return D.98691;
}


static void Gio::DBus::Interface_Class::iface_init_function(void*, void*) (void * g_iface, void * D.97156)
{
  bool retval.5;
  int retval.6;
  long int D.98699;
  long int D.98700;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[74] = "static void Gio::DBus::Interface_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.98696>; else goto <D.98697>;
        <D.98696>:
        _g_boolean_var_ = 1;
        goto <D.98698>;
        <D.98697>:
        _g_boolean_var_ = 0;
        <D.98698>:
        retval.6 = _g_boolean_var_;
      }
      D.98699 = (long int) retval.6;
      D.98700 = __builtin_expect (D.98699, 1);
      retval.5 = D.98700 != 0;
      if (retval.5 != 0) goto <D.98701>; else goto <D.98702>;
      <D.98701>:
      goto <D.98703>;
      <D.98702>:
      g_assertion_message_expr ("giomm", "dbusinterface.cc", 85, &__PRETTY_FUNCTION__, "klass != 0");
      <D.98703>:
    }
  }
  klass->get_info = get_info_vfunc_callback;
  klass->get_object = get_object_vfunc_callback;
  klass->set_object = set_object_vfunc_callback;
  klass->dup_object = dup_object_vfunc_callback;
}


static GDBusInterfaceInfo* Gio::DBus::Interface_Class::get_info_vfunc_callback(GDBusInterface*) (struct GDBusInterface * self)
{
  bool retval.7;
  bool iftmp.8;
  bool D.98709;
  struct CppObjectType * const iftmp.9;
  struct GDBusInterfaceInfo * D.98719;
  struct RefPtr D.97296;
  int (*__vtbl_ptr_type) () * D.98720;
  int (*__vtbl_ptr_type) () * D.98721;
  int (*__vtbl_ptr_type) () D.98722;
  void * D.98723;
  long unsigned int D.98726;
  struct GTypeClass * D.98727;
  void * D.98728;
  struct GDBusInterfaceInfo * (*<T11419>) (struct GDBusInterface *) D.98731;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GDBusInterfaceInfo * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98708>; else goto <D.98706>;
    <D.98708>:
    D.98709 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98709 != 0) goto <D.98710>; else goto <D.98706>;
    <D.98710>:
    iftmp.8 = 1;
    goto <D.98707>;
    <D.98706>:
    iftmp.8 = 0;
    <D.98707>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.98711>; else goto <D.98712>;
    <D.98711>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98714>; else goto <D.98715>;
      <D.98714>:
      iftmp.9 = 0B;
      goto <D.98716>;
      <D.98715>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus9InterfaceE, -1);
      <D.98716>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.98717>; else goto <D.98718>;
      <D.98717>:
      try
        {
          D.98720 = obj->D.86043._vptr.Interface;
          D.98721 = D.98720 + 16;
          D.98722 = *D.98721;
          D.97296 = OBJ_TYPE_REF(D.98722;(const struct Interface)obj->2) (obj); [return slot optimization]
          try
            {
              D.98719 = Glib::unwrap<Gio::DBus::InterfaceInfo> (&D.97296);
              return D.98719;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::InterfaceInfo>::~RefPtr (&D.97296);
              D.97296 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98723 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98723);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98724>;
      <D.98718>:
      <D.98724>:
    }
    goto <D.98725>;
    <D.98712>:
    <D.98725>:
  }
  D.98726 = Gio::DBus::Interface::get_type ();
  D.98727 = MEM[(struct GTypeInstance *)self].g_class;
  D.98728 = g_type_interface_peek (D.98727, D.98726);
  base = g_type_interface_peek_parent (D.98728);
  {
    if (base != 0B) goto <D.98729>; else goto <D.98730>;
    <D.98729>:
    D.98731 = base->get_info;
    if (D.98731 != 0B) goto <D.98732>; else goto <D.98733>;
    <D.98732>:
    {
      struct GDBusInterfaceInfo * retval;

      D.98731 = base->get_info;
      retval = D.98731 (self);
      D.98719 = retval;
      return D.98719;
    }
    <D.98733>:
    <D.98730>:
  }
  D.98719 = 0B;
  return D.98719;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::DBus::InterfaceInfo; typename T::BaseObjectType = _GDBusInterfaceInfo] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.98747;
  struct BaseObjectType * iftmp.10;
  bool D.98749;
  struct InterfaceInfo * D.98752;

  D.98749 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator bool (ptr);
  if (D.98749 != 0) goto <D.98750>; else goto <D.98751>;
  <D.98750>:
  D.98752 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator-> (ptr);
  iftmp.10 = Gio::DBus::InterfaceInfo::gobj (D.98752);
  goto <D.98753>;
  <D.98751>:
  iftmp.10 = 0B;
  <D.98753>:
  D.98747 = iftmp.10;
  return D.98747;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::DBus::InterfaceInfo] (const struct RefPtr * const this)
{
  bool D.98756;
  struct InterfaceInfo * D.98757;

  D.98757 = this->pCppObject_;
  D.98756 = D.98757 != 0B;
  return D.98756;
}


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

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


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

  {
    try
      {
        D.98761 = this->pCppObject_;
        if (D.98761 != 0B) goto <D.98762>; else goto <D.98763>;
        <D.98762>:
        D.98761 = this->pCppObject_;
        Gio::DBus::InterfaceInfo::unreference (D.98761);
        goto <D.98764>;
        <D.98763>:
        <D.98764>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98253>:
}


static GDBusObject* Gio::DBus::Interface_Class::get_object_vfunc_callback(GDBusInterface*) (struct GDBusInterface * self)
{
  bool retval.11;
  bool iftmp.12;
  bool D.98771;
  struct CppObjectType * const iftmp.13;
  struct GDBusObject * D.98781;
  struct RefPtr D.97432;
  int (*__vtbl_ptr_type) () * D.98782;
  int (*__vtbl_ptr_type) () * D.98783;
  int (*__vtbl_ptr_type) () D.98784;
  void * D.98785;
  long unsigned int D.98788;
  struct GTypeClass * D.98789;
  void * D.98790;
  struct GDBusObject * (*<T1141f>) (struct GDBusInterface *) D.98793;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GDBusObject * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98770>; else goto <D.98768>;
    <D.98770>:
    D.98771 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98771 != 0) goto <D.98772>; else goto <D.98768>;
    <D.98772>:
    iftmp.12 = 1;
    goto <D.98769>;
    <D.98768>:
    iftmp.12 = 0;
    <D.98769>:
    retval.11 = iftmp.12;
    if (retval.11 != 0) goto <D.98773>; else goto <D.98774>;
    <D.98773>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98776>; else goto <D.98777>;
      <D.98776>:
      iftmp.13 = 0B;
      goto <D.98778>;
      <D.98777>:
      iftmp.13 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus9InterfaceE, -1);
      <D.98778>:
      obj = iftmp.13;
      if (obj != 0B) goto <D.98779>; else goto <D.98780>;
      <D.98779>:
      try
        {
          D.98782 = obj->D.86043._vptr.Interface;
          D.98783 = D.98782 + 24;
          D.98784 = *D.98783;
          D.97432 = OBJ_TYPE_REF(D.98784;(const struct Interface)obj->3) (obj); [return slot optimization]
          try
            {
              D.98781 = Glib::unwrap<Gio::DBus::Object> (&D.97432);
              return D.98781;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&D.97432);
              D.97432 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98785 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98785);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98786>;
      <D.98780>:
      <D.98786>:
    }
    goto <D.98787>;
    <D.98774>:
    <D.98787>:
  }
  D.98788 = Gio::DBus::Interface::get_type ();
  D.98789 = MEM[(struct GTypeInstance *)self].g_class;
  D.98790 = g_type_interface_peek (D.98789, D.98788);
  base = g_type_interface_peek_parent (D.98790);
  {
    if (base != 0B) goto <D.98791>; else goto <D.98792>;
    <D.98791>:
    D.98793 = base->get_object;
    if (D.98793 != 0B) goto <D.98794>; else goto <D.98795>;
    <D.98794>:
    {
      struct GDBusObject * retval;

      D.98793 = base->get_object;
      retval = D.98793 (self);
      D.98781 = retval;
      return D.98781;
    }
    <D.98795>:
    <D.98792>:
  }
  D.98781 = 0B;
  return D.98781;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::DBus::Object; typename T::BaseObjectType = _GDBusObject] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.98809;
  struct BaseObjectType * iftmp.14;
  bool D.98811;
  struct Object * D.98814;

  D.98811 = Glib::RefPtr<Gio::DBus::Object>::operator bool (ptr);
  if (D.98811 != 0) goto <D.98812>; else goto <D.98813>;
  <D.98812>:
  D.98814 = Glib::RefPtr<Gio::DBus::Object>::operator-> (ptr);
  iftmp.14 = Gio::DBus::Object::gobj (D.98814);
  goto <D.98815>;
  <D.98813>:
  iftmp.14 = 0B;
  <D.98815>:
  D.98809 = iftmp.14;
  return D.98809;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::DBus::Object] (const struct RefPtr * const this)
{
  bool D.98817;
  struct Object * D.98818;

  D.98818 = this->pCppObject_;
  D.98817 = D.98818 != 0B;
  return D.98817;
}


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

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


GDBusObject* Gio::DBus::Object::gobj() (struct Object * const this)
{
  struct GDBusObject * D.98822;
  int (*__vtbl_ptr_type) () * D.98823;
  int (*__vtbl_ptr_type) () * D.98824;
  long int D.98825;
  sizetype D.98826;
  struct ObjectBase * D.98827;

  D.98823 = this->D.96994._vptr.Interface;
  D.98824 = D.98823 + 18446744073709551592;
  D.98825 = MEM[(long int *)D.98824];
  D.98826 = (sizetype) D.98825;
  D.98827 = this + D.98826;
  D.98822 = D.98827->gobject_;
  return D.98822;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::DBus::Object] (struct RefPtr * const this)
{
  struct Object * D.98829;
  int (*__vtbl_ptr_type) () * D.98832;
  int (*__vtbl_ptr_type) () * D.98833;
  long int D.98834;
  sizetype D.98835;
  struct ObjectBase * D.98836;
  int (*__vtbl_ptr_type) () * D.98837;
  int (*__vtbl_ptr_type) () * D.98838;
  int (*__vtbl_ptr_type) () D.98839;

  {
    try
      {
        D.98829 = this->pCppObject_;
        if (D.98829 != 0B) goto <D.98830>; else goto <D.98831>;
        <D.98830>:
        D.98829 = this->pCppObject_;
        D.98829 = this->pCppObject_;
        D.98832 = D.98829->D.96994._vptr.Interface;
        D.98833 = D.98832 + 18446744073709551592;
        D.98834 = MEM[(long int *)D.98833];
        D.98835 = (sizetype) D.98834;
        D.98836 = D.98829 + D.98835;
        D.98829 = this->pCppObject_;
        D.98829 = this->pCppObject_;
        D.98832 = D.98829->D.96994._vptr.Interface;
        D.98833 = D.98832 + 18446744073709551592;
        D.98834 = MEM[(long int *)D.98833];
        D.98835 = (sizetype) D.98834;
        D.98836 = D.98829 + D.98835;
        D.98837 = D.98836->_vptr.ObjectBase;
        D.98838 = D.98837 + 24;
        D.98839 = *D.98838;
        D.98829 = this->pCppObject_;
        D.98829 = this->pCppObject_;
        D.98832 = D.98829->D.96994._vptr.Interface;
        D.98833 = D.98832 + 18446744073709551592;
        D.98834 = MEM[(long int *)D.98833];
        D.98835 = (sizetype) D.98834;
        D.98836 = D.98829 + D.98835;
        OBJ_TYPE_REF(D.98839;(const struct ObjectBase)D.98836->3) (D.98836);
        goto <D.98840>;
        <D.98831>:
        <D.98840>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98261>:
}


static void Gio::DBus::Interface_Class::set_object_vfunc_callback(GDBusInterface*, GDBusObject*) (struct GDBusInterface * self, struct GDBusObject * object)
{
  bool retval.15;
  bool iftmp.16;
  bool D.98847;
  struct CppObjectType * const iftmp.17;
  int (*__vtbl_ptr_type) () * D.98857;
  int (*__vtbl_ptr_type) () * D.98858;
  int (*__vtbl_ptr_type) () D.98859;
  struct RefPtr D.97445;
  void * D.98860;
  long unsigned int D.98863;
  struct GTypeClass * D.98864;
  void * D.98865;
  void (*<T11423>) (struct GDBusInterface *, struct GDBusObject *) D.98868;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98846>; else goto <D.98844>;
    <D.98846>:
    D.98847 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98847 != 0) goto <D.98848>; else goto <D.98844>;
    <D.98848>:
    iftmp.16 = 1;
    goto <D.98845>;
    <D.98844>:
    iftmp.16 = 0;
    <D.98845>:
    retval.15 = iftmp.16;
    if (retval.15 != 0) goto <D.98849>; else goto <D.98850>;
    <D.98849>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98852>; else goto <D.98853>;
      <D.98852>:
      iftmp.17 = 0B;
      goto <D.98854>;
      <D.98853>:
      iftmp.17 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus9InterfaceE, -1);
      <D.98854>:
      obj = iftmp.17;
      if (obj != 0B) goto <D.98855>; else goto <D.98856>;
      <D.98855>:
      try
        {
          D.98857 = obj->D.86043._vptr.Interface;
          D.98858 = D.98857 + 32;
          D.98859 = *D.98858;
          D.97445 = Glib::wrap (object, 1); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.98859;(struct Interface)obj->4) (obj, &D.97445);
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&D.97445);
              D.97445 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98860 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98860);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98861>;
      <D.98856>:
      <D.98861>:
    }
    goto <D.98862>;
    <D.98850>:
    <D.98862>:
  }
  D.98863 = Gio::DBus::Interface::get_type ();
  D.98864 = MEM[(struct GTypeInstance *)self].g_class;
  D.98865 = g_type_interface_peek (D.98864, D.98863);
  base = g_type_interface_peek_parent (D.98865);
  if (base != 0B) goto <D.98866>; else goto <D.98867>;
  <D.98866>:
  D.98868 = base->set_object;
  if (D.98868 != 0B) goto <D.98869>; else goto <D.98870>;
  <D.98869>:
  D.98868 = base->set_object;
  D.98868 (self, object);
  goto <D.98871>;
  <D.98870>:
  <D.98871>:
  <D.98867>:
}


static GDBusObject* Gio::DBus::Interface_Class::dup_object_vfunc_callback(GDBusInterface*) (struct GDBusInterface * self)
{
  bool retval.18;
  bool iftmp.19;
  bool D.98887;
  struct CppObjectType * const iftmp.20;
  struct GDBusObject * D.98897;
  struct RefPtr D.97453;
  int (*__vtbl_ptr_type) () * D.98898;
  int (*__vtbl_ptr_type) () * D.98899;
  int (*__vtbl_ptr_type) () D.98900;
  void * D.98901;
  long unsigned int D.98904;
  struct GTypeClass * D.98905;
  void * D.98906;
  struct GDBusObject * (*<T1141f>) (struct GDBusInterface *) D.98909;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GDBusObject * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98886>; else goto <D.98884>;
    <D.98886>:
    D.98887 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98887 != 0) goto <D.98888>; else goto <D.98884>;
    <D.98888>:
    iftmp.19 = 1;
    goto <D.98885>;
    <D.98884>:
    iftmp.19 = 0;
    <D.98885>:
    retval.18 = iftmp.19;
    if (retval.18 != 0) goto <D.98889>; else goto <D.98890>;
    <D.98889>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98892>; else goto <D.98893>;
      <D.98892>:
      iftmp.20 = 0B;
      goto <D.98894>;
      <D.98893>:
      iftmp.20 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus9InterfaceE, -1);
      <D.98894>:
      obj = iftmp.20;
      if (obj != 0B) goto <D.98895>; else goto <D.98896>;
      <D.98895>:
      try
        {
          D.98898 = obj->D.86043._vptr.Interface;
          D.98899 = D.98898 + 40;
          D.98900 = *D.98899;
          D.97453 = OBJ_TYPE_REF(D.98900;(const struct Interface)obj->5) (obj); [return slot optimization]
          try
            {
              D.98897 = Glib::unwrap<Gio::DBus::Object> (&D.97453);
              return D.98897;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&D.97453);
              D.97453 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98901 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98901);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98902>;
      <D.98896>:
      <D.98902>:
    }
    goto <D.98903>;
    <D.98890>:
    <D.98903>:
  }
  D.98904 = Gio::DBus::Interface::get_type ();
  D.98905 = MEM[(struct GTypeInstance *)self].g_class;
  D.98906 = g_type_interface_peek (D.98905, D.98904);
  base = g_type_interface_peek_parent (D.98906);
  {
    if (base != 0B) goto <D.98907>; else goto <D.98908>;
    <D.98907>:
    D.98909 = base->dup_object;
    if (D.98909 != 0B) goto <D.98910>; else goto <D.98911>;
    <D.98910>:
    {
      struct GDBusObject * retval;

      D.98909 = base->dup_object;
      retval = D.98909 (self);
      D.98897 = retval;
      return D.98897;
    }
    <D.98911>:
    <D.98908>:
  }
  D.98897 = 0B;
  return D.98897;
}


static Glib::ObjectBase* Gio::DBus::Interface_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.98925;
  struct ObjectBase * iftmp.21;
  void * D.97461;
  void * D.98927;
  int (*__vtbl_ptr_type) () * D.98930;
  int (*__vtbl_ptr_type) () * D.98931;
  long int D.98932;
  sizetype D.98933;

  D.97461 = operator new (48);
  try
    {
      Gio::DBus::Interface::Interface (D.97461, object);
    }
  catch
    {
      operator delete (D.97461);
    }
  D.98927 = D.97461;
  if (D.98927 != 0B) goto <D.98928>; else goto <D.98929>;
  <D.98928>:
  D.98930 = MEM[(struct Interface *)D.98927].D.86043._vptr.Interface;
  D.98931 = D.98930 + 18446744073709551592;
  D.98932 = MEM[(long int *)D.98931];
  D.98933 = (sizetype) D.98932;
  iftmp.21 = D.98927 + D.98933;
  goto <D.98934>;
  <D.98929>:
  iftmp.21 = 0B;
  <D.98934>:
  D.98925 = iftmp.21;
  return D.98925;
}


Gio::DBus::Interface::Interface() (struct Interface * const this, const void * * __vtt_parm)
{
  struct trackable * D.98940;
  const void * * iftmp.22;
  struct ObjectBase * D.98948;
  const struct Interface_Class & D.98950;
  const void * * iftmp.23;
  struct Interface * D.98955;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.98963;
  int (*__vtbl_ptr_type) () * D.98964;
  long int D.98965;
  struct ObjectBase * D.98967;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * iftmp.27;
  const void * * iftmp.28;

  if (0 != 0) goto <D.98938>; else goto <D.98939>;
  <D.98938>:
  D.98940 = &this->D.86046;
  sigc::trackable::trackable (D.98940);
  goto <D.98941>;
  <D.98939>:
  <D.98941>:
  try
    {
      if (0 != 0) goto <D.98942>; else goto <D.98943>;
      <D.98942>:
      if (0 == 0) goto <D.98945>; else goto <D.98946>;
      <D.98945>:
      iftmp.22 = __vtt_parm + 32;
      goto <D.98947>;
      <D.98946>:
      iftmp.22 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.98947>:
      D.98948 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.98948, iftmp.22);
      goto <D.98949>;
      <D.98943>:
      <D.98949>:
      try
        {
          D.98950 = Gio::DBus::Interface_Class::init (&interface_class_);
          if (0 == 0) goto <D.98952>; else goto <D.98953>;
          <D.98952>:
          iftmp.23 = __vtt_parm + 8;
          goto <D.98954>;
          <D.98953>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.98954>:
          D.98955 = &this->D.86043;
          Glib::Interface::Interface (D.98955, iftmp.23, D.98950);
          try
            {
              if (0 == 0) goto <D.98957>; else goto <D.98958>;
              <D.98957>:
              iftmp.24 = *__vtt_parm;
              goto <D.98959>;
              <D.98958>:
              iftmp.24 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.98959>:
              this->D.86043._vptr.Interface = iftmp.24;
              if (0 == 0) goto <D.98961>; else goto <D.98962>;
              <D.98961>:
              D.98963 = this->D.86043._vptr.Interface;
              D.98964 = D.98963 + 18446744073709551592;
              D.98965 = MEM[(long int *)D.98964];
              iftmp.25 = (sizetype) D.98965;
              goto <D.98966>;
              <D.98962>:
              iftmp.25 = 8;
              <D.98966>:
              D.98967 = this + iftmp.25;
              if (0 == 0) goto <D.98969>; else goto <D.98970>;
              <D.98969>:
              iftmp.26 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98971>;
              <D.98970>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.98971>:
              D.98967->_vptr.ObjectBase = iftmp.26;
            }
          catch
            {
              if (0 == 0) goto <D.98973>; else goto <D.98974>;
              <D.98973>:
              iftmp.27 = __vtt_parm + 8;
              goto <D.98975>;
              <D.98974>:
              iftmp.27 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.98975>:
              D.98955 = &this->D.86043;
              Glib::Interface::~Interface (D.98955, iftmp.27);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98976>; else goto <D.98977>;
          <D.98976>:
          if (0 == 0) goto <D.98979>; else goto <D.98980>;
          <D.98979>:
          iftmp.28 = __vtt_parm + 32;
          goto <D.98981>;
          <D.98980>:
          iftmp.28 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.98981>:
          D.98948 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.98948, iftmp.28);
          goto <D.98982>;
          <D.98977>:
          <D.98982>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98983>; else goto <D.98984>;
      <D.98983>:
      D.98940 = &this->D.86046;
      sigc::trackable::~trackable (D.98940);
      goto <D.98985>;
      <D.98984>:
      <D.98985>:
    }
}


Gio::DBus::Interface::Interface() (struct Interface * const this)
{
  struct trackable * D.98991;
  const void * * iftmp.29;
  struct ObjectBase * D.98999;
  const struct Interface_Class & D.99001;
  const void * * iftmp.30;
  struct Interface * D.99006;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * D.99010;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.99015;
  int (*__vtbl_ptr_type) () * D.99016;
  long int D.99017;
  struct ObjectBase * D.99019;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * iftmp.34;
  const void * * iftmp.35;

  if (1 != 0) goto <D.98989>; else goto <D.98990>;
  <D.98989>:
  D.98991 = &this->D.86046;
  sigc::trackable::trackable (D.98991);
  goto <D.98992>;
  <D.98990>:
  <D.98992>:
  try
    {
      if (1 != 0) goto <D.98993>; else goto <D.98994>;
      <D.98993>:
      if (1 == 0) goto <D.98996>; else goto <D.98997>;
      <D.98996>:
      iftmp.29 = 32B;
      goto <D.98998>;
      <D.98997>:
      iftmp.29 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.98998>:
      D.98999 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.98999, iftmp.29);
      goto <D.99000>;
      <D.98994>:
      <D.99000>:
      try
        {
          D.99001 = Gio::DBus::Interface_Class::init (&interface_class_);
          if (1 == 0) goto <D.99003>; else goto <D.99004>;
          <D.99003>:
          iftmp.30 = 8B;
          goto <D.99005>;
          <D.99004>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.99005>:
          D.99006 = &this->D.86043;
          Glib::Interface::Interface (D.99006, iftmp.30, D.99001);
          try
            {
              if (1 == 0) goto <D.99008>; else goto <D.99009>;
              <D.99008>:
              D.99010 = 0B;
              iftmp.31 = *D.99010;
              goto <D.99011>;
              <D.99009>:
              iftmp.31 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.99011>:
              this->D.86043._vptr.Interface = iftmp.31;
              if (1 == 0) goto <D.99013>; else goto <D.99014>;
              <D.99013>:
              D.99015 = this->D.86043._vptr.Interface;
              D.99016 = D.99015 + 18446744073709551592;
              D.99017 = MEM[(long int *)D.99016];
              iftmp.32 = (sizetype) D.99017;
              goto <D.99018>;
              <D.99014>:
              iftmp.32 = 8;
              <D.99018>:
              D.99019 = this + iftmp.32;
              if (1 == 0) goto <D.99021>; else goto <D.99022>;
              <D.99021>:
              iftmp.33 = MEM[(const void * *)0B + 24B];
              goto <D.99023>;
              <D.99022>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.99023>:
              D.99019->_vptr.ObjectBase = iftmp.33;
            }
          catch
            {
              if (1 == 0) goto <D.99025>; else goto <D.99026>;
              <D.99025>:
              iftmp.34 = 8B;
              goto <D.99027>;
              <D.99026>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.99027>:
              D.99006 = &this->D.86043;
              Glib::Interface::~Interface (D.99006, iftmp.34);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99028>; else goto <D.99029>;
          <D.99028>:
          if (1 == 0) goto <D.99031>; else goto <D.99032>;
          <D.99031>:
          iftmp.35 = 32B;
          goto <D.99033>;
          <D.99032>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.99033>:
          D.98999 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.98999, iftmp.35);
          goto <D.99034>;
          <D.99029>:
          <D.99034>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99035>; else goto <D.99036>;
      <D.99035>:
      D.98991 = &this->D.86046;
      sigc::trackable::~trackable (D.98991);
      goto <D.99037>;
      <D.99036>:
      <D.99037>:
    }
}


Gio::DBus::Interface::Interface(GDBusInterface*) (struct Interface * const this, const void * * __vtt_parm, struct GDBusInterface * castitem)
{
  struct trackable * D.99043;
  const void * * iftmp.36;
  struct ObjectBase * D.99051;
  const void * * iftmp.37;
  struct Interface * D.99057;
  int (*__vtbl_ptr_type) () * iftmp.38;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.99065;
  int (*__vtbl_ptr_type) () * D.99066;
  long int D.99067;
  struct ObjectBase * D.99069;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  const void * * iftmp.42;

  if (0 != 0) goto <D.99041>; else goto <D.99042>;
  <D.99041>:
  D.99043 = &this->D.86046;
  sigc::trackable::trackable (D.99043);
  goto <D.99044>;
  <D.99042>:
  <D.99044>:
  try
    {
      if (0 != 0) goto <D.99045>; else goto <D.99046>;
      <D.99045>:
      if (0 == 0) goto <D.99048>; else goto <D.99049>;
      <D.99048>:
      iftmp.36 = __vtt_parm + 32;
      goto <D.99050>;
      <D.99049>:
      iftmp.36 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.99050>:
      D.99051 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.99051, iftmp.36);
      goto <D.99052>;
      <D.99046>:
      <D.99052>:
      try
        {
          if (0 == 0) goto <D.99054>; else goto <D.99055>;
          <D.99054>:
          iftmp.37 = __vtt_parm + 8;
          goto <D.99056>;
          <D.99055>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.99056>:
          D.99057 = &this->D.86043;
          Glib::Interface::Interface (D.99057, iftmp.37, castitem);
          try
            {
              if (0 == 0) goto <D.99059>; else goto <D.99060>;
              <D.99059>:
              iftmp.38 = *__vtt_parm;
              goto <D.99061>;
              <D.99060>:
              iftmp.38 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.99061>:
              this->D.86043._vptr.Interface = iftmp.38;
              if (0 == 0) goto <D.99063>; else goto <D.99064>;
              <D.99063>:
              D.99065 = this->D.86043._vptr.Interface;
              D.99066 = D.99065 + 18446744073709551592;
              D.99067 = MEM[(long int *)D.99066];
              iftmp.39 = (sizetype) D.99067;
              goto <D.99068>;
              <D.99064>:
              iftmp.39 = 8;
              <D.99068>:
              D.99069 = this + iftmp.39;
              if (0 == 0) goto <D.99071>; else goto <D.99072>;
              <D.99071>:
              iftmp.40 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99073>;
              <D.99072>:
              iftmp.40 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.99073>:
              D.99069->_vptr.ObjectBase = iftmp.40;
            }
          catch
            {
              if (0 == 0) goto <D.99075>; else goto <D.99076>;
              <D.99075>:
              iftmp.41 = __vtt_parm + 8;
              goto <D.99077>;
              <D.99076>:
              iftmp.41 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.99077>:
              D.99057 = &this->D.86043;
              Glib::Interface::~Interface (D.99057, iftmp.41);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99078>; else goto <D.99079>;
          <D.99078>:
          if (0 == 0) goto <D.99081>; else goto <D.99082>;
          <D.99081>:
          iftmp.42 = __vtt_parm + 32;
          goto <D.99083>;
          <D.99082>:
          iftmp.42 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.99083>:
          D.99051 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.99051, iftmp.42);
          goto <D.99084>;
          <D.99079>:
          <D.99084>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99085>; else goto <D.99086>;
      <D.99085>:
      D.99043 = &this->D.86046;
      sigc::trackable::~trackable (D.99043);
      goto <D.99087>;
      <D.99086>:
      <D.99087>:
    }
}


Gio::DBus::Interface::Interface(GDBusInterface*) (struct Interface * const this, struct GDBusInterface * castitem)
{
  struct trackable * D.99092;
  const void * * iftmp.43;
  struct ObjectBase * D.99100;
  const void * * iftmp.44;
  struct Interface * D.99106;
  int (*__vtbl_ptr_type) () * iftmp.45;
  const void * * D.99110;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.99115;
  int (*__vtbl_ptr_type) () * D.99116;
  long int D.99117;
  struct ObjectBase * D.99119;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  const void * * iftmp.49;

  if (1 != 0) goto <D.99090>; else goto <D.99091>;
  <D.99090>:
  D.99092 = &this->D.86046;
  sigc::trackable::trackable (D.99092);
  goto <D.99093>;
  <D.99091>:
  <D.99093>:
  try
    {
      if (1 != 0) goto <D.99094>; else goto <D.99095>;
      <D.99094>:
      if (1 == 0) goto <D.99097>; else goto <D.99098>;
      <D.99097>:
      iftmp.43 = 32B;
      goto <D.99099>;
      <D.99098>:
      iftmp.43 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.99099>:
      D.99100 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.99100, iftmp.43);
      goto <D.99101>;
      <D.99095>:
      <D.99101>:
      try
        {
          if (1 == 0) goto <D.99103>; else goto <D.99104>;
          <D.99103>:
          iftmp.44 = 8B;
          goto <D.99105>;
          <D.99104>:
          iftmp.44 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.99105>:
          D.99106 = &this->D.86043;
          Glib::Interface::Interface (D.99106, iftmp.44, castitem);
          try
            {
              if (1 == 0) goto <D.99108>; else goto <D.99109>;
              <D.99108>:
              D.99110 = 0B;
              iftmp.45 = *D.99110;
              goto <D.99111>;
              <D.99109>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.99111>:
              this->D.86043._vptr.Interface = iftmp.45;
              if (1 == 0) goto <D.99113>; else goto <D.99114>;
              <D.99113>:
              D.99115 = this->D.86043._vptr.Interface;
              D.99116 = D.99115 + 18446744073709551592;
              D.99117 = MEM[(long int *)D.99116];
              iftmp.46 = (sizetype) D.99117;
              goto <D.99118>;
              <D.99114>:
              iftmp.46 = 8;
              <D.99118>:
              D.99119 = this + iftmp.46;
              if (1 == 0) goto <D.99121>; else goto <D.99122>;
              <D.99121>:
              iftmp.47 = MEM[(const void * *)0B + 24B];
              goto <D.99123>;
              <D.99122>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.99123>:
              D.99119->_vptr.ObjectBase = iftmp.47;
            }
          catch
            {
              if (1 == 0) goto <D.99125>; else goto <D.99126>;
              <D.99125>:
              iftmp.48 = 8B;
              goto <D.99127>;
              <D.99126>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.99127>:
              D.99106 = &this->D.86043;
              Glib::Interface::~Interface (D.99106, iftmp.48);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99128>; else goto <D.99129>;
          <D.99128>:
          if (1 == 0) goto <D.99131>; else goto <D.99132>;
          <D.99131>:
          iftmp.49 = 32B;
          goto <D.99133>;
          <D.99132>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.99133>:
          D.99100 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.99100, iftmp.49);
          goto <D.99134>;
          <D.99129>:
          <D.99134>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99135>; else goto <D.99136>;
      <D.99135>:
      D.99092 = &this->D.86046;
      sigc::trackable::~trackable (D.99092);
      goto <D.99137>;
      <D.99136>:
      <D.99137>:
    }
}


Gio::DBus::Interface::Interface(const Glib::Interface_Class&) (struct Interface * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.99142;
  const void * * iftmp.50;
  struct ObjectBase * D.99150;
  const void * * iftmp.51;
  struct Interface * D.99156;
  int (*__vtbl_ptr_type) () * iftmp.52;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.99164;
  int (*__vtbl_ptr_type) () * D.99165;
  long int D.99166;
  struct ObjectBase * D.99168;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;

  if (0 != 0) goto <D.99140>; else goto <D.99141>;
  <D.99140>:
  D.99142 = &this->D.86046;
  sigc::trackable::trackable (D.99142);
  goto <D.99143>;
  <D.99141>:
  <D.99143>:
  try
    {
      if (0 != 0) goto <D.99144>; else goto <D.99145>;
      <D.99144>:
      if (0 == 0) goto <D.99147>; else goto <D.99148>;
      <D.99147>:
      iftmp.50 = __vtt_parm + 32;
      goto <D.99149>;
      <D.99148>:
      iftmp.50 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.99149>:
      D.99150 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.99150, iftmp.50);
      goto <D.99151>;
      <D.99145>:
      <D.99151>:
      try
        {
          if (0 == 0) goto <D.99153>; else goto <D.99154>;
          <D.99153>:
          iftmp.51 = __vtt_parm + 8;
          goto <D.99155>;
          <D.99154>:
          iftmp.51 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.99155>:
          D.99156 = &this->D.86043;
          Glib::Interface::Interface (D.99156, iftmp.51, interface_class);
          try
            {
              if (0 == 0) goto <D.99158>; else goto <D.99159>;
              <D.99158>:
              iftmp.52 = *__vtt_parm;
              goto <D.99160>;
              <D.99159>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.99160>:
              this->D.86043._vptr.Interface = iftmp.52;
              if (0 == 0) goto <D.99162>; else goto <D.99163>;
              <D.99162>:
              D.99164 = this->D.86043._vptr.Interface;
              D.99165 = D.99164 + 18446744073709551592;
              D.99166 = MEM[(long int *)D.99165];
              iftmp.53 = (sizetype) D.99166;
              goto <D.99167>;
              <D.99163>:
              iftmp.53 = 8;
              <D.99167>:
              D.99168 = this + iftmp.53;
              if (0 == 0) goto <D.99170>; else goto <D.99171>;
              <D.99170>:
              iftmp.54 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99172>;
              <D.99171>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.99172>:
              D.99168->_vptr.ObjectBase = iftmp.54;
            }
          catch
            {
              if (0 == 0) goto <D.99174>; else goto <D.99175>;
              <D.99174>:
              iftmp.55 = __vtt_parm + 8;
              goto <D.99176>;
              <D.99175>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.99176>:
              D.99156 = &this->D.86043;
              Glib::Interface::~Interface (D.99156, iftmp.55);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99177>; else goto <D.99178>;
          <D.99177>:
          if (0 == 0) goto <D.99180>; else goto <D.99181>;
          <D.99180>:
          iftmp.56 = __vtt_parm + 32;
          goto <D.99182>;
          <D.99181>:
          iftmp.56 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.99182>:
          D.99150 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.99150, iftmp.56);
          goto <D.99183>;
          <D.99178>:
          <D.99183>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99184>; else goto <D.99185>;
      <D.99184>:
      D.99142 = &this->D.86046;
      sigc::trackable::~trackable (D.99142);
      goto <D.99186>;
      <D.99185>:
      <D.99186>:
    }
}


Gio::DBus::Interface::Interface(const Glib::Interface_Class&) (struct Interface * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.99191;
  const void * * iftmp.57;
  struct ObjectBase * D.99199;
  const void * * iftmp.58;
  struct Interface * D.99205;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * D.99209;
  sizetype iftmp.60;
  int (*__vtbl_ptr_type) () * D.99214;
  int (*__vtbl_ptr_type) () * D.99215;
  long int D.99216;
  struct ObjectBase * D.99218;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * iftmp.62;
  const void * * iftmp.63;

  if (1 != 0) goto <D.99189>; else goto <D.99190>;
  <D.99189>:
  D.99191 = &this->D.86046;
  sigc::trackable::trackable (D.99191);
  goto <D.99192>;
  <D.99190>:
  <D.99192>:
  try
    {
      if (1 != 0) goto <D.99193>; else goto <D.99194>;
      <D.99193>:
      if (1 == 0) goto <D.99196>; else goto <D.99197>;
      <D.99196>:
      iftmp.57 = 32B;
      goto <D.99198>;
      <D.99197>:
      iftmp.57 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
      <D.99198>:
      D.99199 = &this->D.86045;
      Glib::ObjectBase::ObjectBase (D.99199, iftmp.57);
      goto <D.99200>;
      <D.99194>:
      <D.99200>:
      try
        {
          if (1 == 0) goto <D.99202>; else goto <D.99203>;
          <D.99202>:
          iftmp.58 = 8B;
          goto <D.99204>;
          <D.99203>:
          iftmp.58 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
          <D.99204>:
          D.99205 = &this->D.86043;
          Glib::Interface::Interface (D.99205, iftmp.58, interface_class);
          try
            {
              if (1 == 0) goto <D.99207>; else goto <D.99208>;
              <D.99207>:
              D.99209 = 0B;
              iftmp.59 = *D.99209;
              goto <D.99210>;
              <D.99208>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
              <D.99210>:
              this->D.86043._vptr.Interface = iftmp.59;
              if (1 == 0) goto <D.99212>; else goto <D.99213>;
              <D.99212>:
              D.99214 = this->D.86043._vptr.Interface;
              D.99215 = D.99214 + 18446744073709551592;
              D.99216 = MEM[(long int *)D.99215];
              iftmp.60 = (sizetype) D.99216;
              goto <D.99217>;
              <D.99213>:
              iftmp.60 = 8;
              <D.99217>:
              D.99218 = this + iftmp.60;
              if (1 == 0) goto <D.99220>; else goto <D.99221>;
              <D.99220>:
              iftmp.61 = MEM[(const void * *)0B + 24B];
              goto <D.99222>;
              <D.99221>:
              iftmp.61 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
              <D.99222>:
              D.99218->_vptr.ObjectBase = iftmp.61;
            }
          catch
            {
              if (1 == 0) goto <D.99224>; else goto <D.99225>;
              <D.99224>:
              iftmp.62 = 8B;
              goto <D.99226>;
              <D.99225>:
              iftmp.62 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
              <D.99226>:
              D.99205 = &this->D.86043;
              Glib::Interface::~Interface (D.99205, iftmp.62);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99227>; else goto <D.99228>;
          <D.99227>:
          if (1 == 0) goto <D.99230>; else goto <D.99231>;
          <D.99230>:
          iftmp.63 = 32B;
          goto <D.99232>;
          <D.99231>:
          iftmp.63 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
          <D.99232>:
          D.99199 = &this->D.86045;
          Glib::ObjectBase::~ObjectBase (D.99199, iftmp.63);
          goto <D.99233>;
          <D.99228>:
          <D.99233>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99234>; else goto <D.99235>;
      <D.99234>:
      D.99191 = &this->D.86046;
      sigc::trackable::~trackable (D.99191);
      goto <D.99236>;
      <D.99235>:
      <D.99236>:
    }
}


Gio::DBus::Interface::~Interface() (struct Interface * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.64;
  sizetype iftmp.65;
  int (*__vtbl_ptr_type) () * D.99246;
  int (*__vtbl_ptr_type) () * D.99247;
  long int D.99248;
  struct ObjectBase * D.99250;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * iftmp.67;
  struct Interface * D.99259;
  int D.99260;
  const void * * iftmp.68;
  struct ObjectBase * D.99267;
  struct trackable * D.99271;
  int D.99273;

  {
    if (0 == 0) goto <D.99240>; else goto <D.99241>;
    <D.99240>:
    iftmp.64 = *__vtt_parm;
    goto <D.99242>;
    <D.99241>:
    iftmp.64 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
    <D.99242>:
    this->D.86043._vptr.Interface = iftmp.64;
    if (0 == 0) goto <D.99244>; else goto <D.99245>;
    <D.99244>:
    D.99246 = this->D.86043._vptr.Interface;
    D.99247 = D.99246 + 18446744073709551592;
    D.99248 = MEM[(long int *)D.99247];
    iftmp.65 = (sizetype) D.99248;
    goto <D.99249>;
    <D.99245>:
    iftmp.65 = 8;
    <D.99249>:
    D.99250 = this + iftmp.65;
    if (0 == 0) goto <D.99252>; else goto <D.99253>;
    <D.99252>:
    iftmp.66 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.99254>;
    <D.99253>:
    iftmp.66 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
    <D.99254>:
    D.99250->_vptr.ObjectBase = iftmp.66;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.99256>; else goto <D.99257>;
                    <D.99256>:
                    iftmp.67 = __vtt_parm + 8;
                    goto <D.99258>;
                    <D.99257>:
                    iftmp.67 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
                    <D.99258>:
                    D.99259 = &this->D.86043;
                    Glib::Interface::~Interface (D.99259, iftmp.67);
                  }
              }
            finally
              {
                D.99260 = 0;
                if (D.99260 != 0) goto <D.99261>; else goto <D.99262>;
                <D.99261>:
                if (0 == 0) goto <D.99264>; else goto <D.99265>;
                <D.99264>:
                iftmp.68 = __vtt_parm + 32;
                goto <D.99266>;
                <D.99265>:
                iftmp.68 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
                <D.99266>:
                D.99267 = &this->D.86045;
                Glib::ObjectBase::~ObjectBase (D.99267, iftmp.68);
                goto <D.99268>;
                <D.99262>:
                <D.99268>:
              }
          }
        finally
          {
            D.99260 = 0;
            if (D.99260 != 0) goto <D.99269>; else goto <D.99270>;
            <D.99269>:
            D.99271 = &this->D.86046;
            sigc::trackable::~trackable (D.99271);
            goto <D.99272>;
            <D.99270>:
            <D.99272>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97508>:
  D.99273 = 0;
  if (D.99273 != 0) goto <D.99274>; else goto <D.99275>;
  <D.99274>:
  operator delete (this);
  goto <D.99276>;
  <D.99275>:
  <D.99276>:
}


virtual Gio::DBus::Interface::~Interface() (struct Interface * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.69;
  const void * * D.99292;
  sizetype iftmp.70;
  int (*__vtbl_ptr_type) () * D.99297;
  int (*__vtbl_ptr_type) () * D.99298;
  long int D.99299;
  struct ObjectBase * D.99301;
  int (*__vtbl_ptr_type) () * iftmp.71;
  const void * * iftmp.72;
  struct Interface * D.99310;
  int D.99311;
  const void * * iftmp.73;
  struct ObjectBase * D.99318;
  struct trackable * D.99322;
  int D.99324;

  {
    if (2 == 0) goto <D.99290>; else goto <D.99291>;
    <D.99290>:
    D.99292 = 0B;
    iftmp.69 = *D.99292;
    goto <D.99293>;
    <D.99291>:
    iftmp.69 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 32B];
    <D.99293>:
    this->D.86043._vptr.Interface = iftmp.69;
    if (2 == 0) goto <D.99295>; else goto <D.99296>;
    <D.99295>:
    D.99297 = this->D.86043._vptr.Interface;
    D.99298 = D.99297 + 18446744073709551592;
    D.99299 = MEM[(long int *)D.99298];
    iftmp.70 = (sizetype) D.99299;
    goto <D.99300>;
    <D.99296>:
    iftmp.70 = 8;
    <D.99300>:
    D.99301 = this + iftmp.70;
    if (2 == 0) goto <D.99303>; else goto <D.99304>;
    <D.99303>:
    iftmp.71 = MEM[(const void * *)0B + 24B];
    goto <D.99305>;
    <D.99304>:
    iftmp.71 = &MEM[(void *)&_ZTVN3Gio4DBus9InterfaceE + 144B];
    <D.99305>:
    D.99301->_vptr.ObjectBase = iftmp.71;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.99307>; else goto <D.99308>;
                    <D.99307>:
                    iftmp.72 = 8B;
                    goto <D.99309>;
                    <D.99308>:
                    iftmp.72 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 8B];
                    <D.99309>:
                    D.99310 = &this->D.86043;
                    Glib::Interface::~Interface (D.99310, iftmp.72);
                  }
              }
            finally
              {
                D.99311 = 2;
                if (D.99311 != 0) goto <D.99312>; else goto <D.99313>;
                <D.99312>:
                if (2 == 0) goto <D.99315>; else goto <D.99316>;
                <D.99315>:
                iftmp.73 = 32B;
                goto <D.99317>;
                <D.99316>:
                iftmp.73 = &MEM[(void *)&_ZTTN3Gio4DBus9InterfaceE + 32B];
                <D.99317>:
                D.99318 = &this->D.86045;
                Glib::ObjectBase::~ObjectBase (D.99318, iftmp.73);
                goto <D.99319>;
                <D.99313>:
                <D.99319>:
              }
          }
        finally
          {
            D.99311 = 2;
            if (D.99311 != 0) goto <D.99320>; else goto <D.99321>;
            <D.99320>:
            D.99322 = &this->D.86046;
            sigc::trackable::~trackable (D.99322);
            goto <D.99323>;
            <D.99321>:
            <D.99323>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97511>:
  D.99324 = 0;
  if (D.99324 != 0) goto <D.99325>; else goto <D.99326>;
  <D.99325>:
  operator delete (this);
  goto <D.99327>;
  <D.99326>:
  <D.99327>:
}


virtual Gio::DBus::Interface::~Interface() (struct Interface * const this)
{
  Gio::DBus::Interface::~Interface (this);
  <D.97516>:
  operator delete (this);
}


static void Gio::DBus::Interface::add_interface(GType) (GType gtype_implementer)
{
  const struct Interface_Class & D.99340;

  D.99340 = Gio::DBus::Interface_Class::init (&interface_class_);
  Glib::Interface_Class::add_interface (D.99340, gtype_implementer);
}


static GType Gio::DBus::Interface::get_type() ()
{
  GType D.99342;
  const struct Interface_Class & D.99343;
  const struct Class * D.99344;

  D.99343 = Gio::DBus::Interface_Class::init (&interface_class_);
  D.99344 = &D.99343->D.86066;
  D.99342 = Glib::Class::get_type (D.99344);
  return D.99342;
}


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

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


static GType Gio::DBus::Interface::get_base_type() ()
{
  GType D.99349;

  D.99349 = g_dbus_interface_get_type ();
  return D.99349;
}


Glib::RefPtr<Gio::DBus::InterfaceInfo> Gio::DBus::Interface::get_info() (struct Interface * const this)
{
  struct GDBusInterface * D.99353;
  struct GDBusInterfaceInfo * D.99354;

  D.99353 = Gio::DBus::Interface::gobj (this);
  D.99354 = g_dbus_interface_get_info (D.99353);
  *<retval> = Glib::wrap (D.99354, 0); [return slot optimization]
  return <retval>;
}


GDBusInterface* Gio::DBus::Interface::gobj() (struct Interface * const this)
{
  struct GDBusInterface * D.99357;
  int (*__vtbl_ptr_type) () * D.99358;
  int (*__vtbl_ptr_type) () * D.99359;
  long int D.99360;
  sizetype D.99361;
  struct ObjectBase * D.99362;

  D.99358 = this->D.86043._vptr.Interface;
  D.99359 = D.99358 + 18446744073709551592;
  D.99360 = MEM[(long int *)D.99359];
  D.99361 = (sizetype) D.99360;
  D.99362 = this + D.99361;
  D.99357 = D.99362->gobject_;
  return D.99357;
}


Glib::RefPtr<const Gio::DBus::InterfaceInfo> Gio::DBus::Interface::get_info() const (const struct Interface * const this)
{
  struct RefPtr D.97671;

  D.97671 = Gio::DBus::Interface::get_info (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::InterfaceInfo>::RefPtr<Gio::DBus::InterfaceInfo> (<retval>, &D.97671);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::InterfaceInfo>::~RefPtr (&D.97671);
      D.97671 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::DBus::InterfaceInfo; T_CppObject = const Gio::DBus::InterfaceInfo] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct InterfaceInfo * D.99368;
  const struct InterfaceInfo * D.99369;

  D.99368 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator-> (src);
  this->pCppObject_ = D.99368;
  D.99369 = this->pCppObject_;
  if (D.99369 != 0B) goto <D.99370>; else goto <D.99371>;
  <D.99370>:
  D.99369 = this->pCppObject_;
  Gio::DBus::InterfaceInfo::reference (D.99369);
  goto <D.99372>;
  <D.99371>:
  <D.99372>:
}


Glib::RefPtr<Gio::DBus::Object> Gio::DBus::Interface::get_object() (struct Interface * const this)
{
  struct GDBusInterface * D.99374;
  struct GDBusObject * D.99375;

  D.99374 = Gio::DBus::Interface::gobj (this);
  D.99375 = g_dbus_interface_get_object (D.99374);
  *<retval> = Glib::wrap (D.99375, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::DBus::Object> Gio::DBus::Interface::get_object() const (const struct Interface * const this)
{
  struct RefPtr D.97831;

  D.97831 = Gio::DBus::Interface::get_object (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::Object>::RefPtr<Gio::DBus::Object> (<retval>, &D.97831);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&D.97831);
      D.97831 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::DBus::Object; T_CppObject = const Gio::DBus::Object] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Object * D.99382;
  const struct Object * D.99383;
  int (*__vtbl_ptr_type) () * D.99386;
  int (*__vtbl_ptr_type) () * D.99387;
  long int D.99388;
  sizetype D.99389;
  const struct ObjectBase * D.99390;
  int (*__vtbl_ptr_type) () * D.99391;
  int (*__vtbl_ptr_type) () * D.99392;
  int (*__vtbl_ptr_type) () D.99393;

  D.99382 = Glib::RefPtr<Gio::DBus::Object>::operator-> (src);
  this->pCppObject_ = D.99382;
  D.99383 = this->pCppObject_;
  if (D.99383 != 0B) goto <D.99384>; else goto <D.99385>;
  <D.99384>:
  D.99383 = this->pCppObject_;
  D.99383 = this->pCppObject_;
  D.99386 = D.99383->D.96994._vptr.Interface;
  D.99387 = D.99386 + 18446744073709551592;
  D.99388 = MEM[(long int *)D.99387];
  D.99389 = (sizetype) D.99388;
  D.99390 = D.99383 + D.99389;
  D.99383 = this->pCppObject_;
  D.99383 = this->pCppObject_;
  D.99386 = D.99383->D.96994._vptr.Interface;
  D.99387 = D.99386 + 18446744073709551592;
  D.99388 = MEM[(long int *)D.99387];
  D.99389 = (sizetype) D.99388;
  D.99390 = D.99383 + D.99389;
  D.99391 = D.99390->_vptr.ObjectBase;
  D.99392 = D.99391 + 16;
  D.99393 = *D.99392;
  D.99383 = this->pCppObject_;
  D.99383 = this->pCppObject_;
  D.99386 = D.99383->D.96994._vptr.Interface;
  D.99387 = D.99386 + 18446744073709551592;
  D.99388 = MEM[(long int *)D.99387];
  D.99389 = (sizetype) D.99388;
  D.99390 = D.99383 + D.99389;
  OBJ_TYPE_REF(D.99393;(const struct ObjectBase)D.99390->2) (D.99390);
  goto <D.99394>;
  <D.99385>:
  <D.99394>:
}


Glib::RefPtr<Gio::DBus::Object> Gio::DBus::Interface::dup_object() (struct Interface * const this)
{
  struct GDBusInterface * D.99396;
  struct GDBusObject * D.99397;

  D.99396 = Gio::DBus::Interface::gobj (this);
  D.99397 = g_dbus_interface_dup_object (D.99396);
  *<retval> = Glib::wrap (D.99397, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::DBus::Object> Gio::DBus::Interface::dup_object() const (const struct Interface * const this)
{
  struct RefPtr D.97858;

  D.97858 = Gio::DBus::Interface::dup_object (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::Object>::RefPtr<Gio::DBus::Object> (<retval>, &D.97858);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&D.97858);
      D.97858 = {CLOBBER};
    }
}


void Gio::DBus::Interface::set_object(const Glib::RefPtr<Gio::DBus::Object>&) (struct Interface * const this, const struct RefPtr & object)
{
  struct BaseObjectType * D.99404;
  struct GDBusInterface * D.99405;

  D.99404 = Glib::unwrap<Gio::DBus::Object> (object);
  D.99405 = Gio::DBus::Interface::gobj (this);
  g_dbus_interface_set_object (D.99405, D.99404);
}


virtual Glib::RefPtr<Gio::DBus::InterfaceInfo> Gio::DBus::Interface::get_info_vfunc() const (const struct Interface * const this)
{
  long unsigned int D.99408;
  int (*__vtbl_ptr_type) () * D.99409;
  int (*__vtbl_ptr_type) () * D.99410;
  long int D.99411;
  sizetype D.99412;
  const struct ObjectBase * D.99413;
  struct GObject * D.99414;
  struct GTypeClass * D.99415;
  void * D.99416;
  struct GDBusInterfaceInfo * (*<T11419>) (struct GDBusInterface *) D.99419;
  const struct GDBusInterface * D.99422;
  struct GDBusInterfaceInfo * D.99423;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.99408 = Gio::DBus::Interface::get_type ();
  D.99409 = this->D.86043._vptr.Interface;
  D.99410 = D.99409 + 18446744073709551592;
  D.99411 = MEM[(long int *)D.99410];
  D.99412 = (sizetype) D.99411;
  D.99413 = this + D.99412;
  D.99414 = D.99413->gobject_;
  D.99415 = MEM[(struct GTypeInstance *)D.99414].g_class;
  D.99416 = g_type_interface_peek (D.99415, D.99408);
  base = g_type_interface_peek_parent (D.99416);
  {
    if (base != 0B) goto <D.99417>; else goto <D.99418>;
    <D.99417>:
    D.99419 = base->get_info;
    if (D.99419 != 0B) goto <D.99420>; else goto <D.99421>;
    <D.99420>:
    {
      struct RefPtr retval;

      try
        {
          D.99419 = base->get_info;
          D.99422 = Gio::DBus::Interface::gobj (this);
          D.99423 = D.99419 (D.99422);
          retval = Glib::wrap (D.99423, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::DBus::InterfaceInfo>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::InterfaceInfo>::~RefPtr (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.99421>:
    <D.99418>:
  }
  Glib::RefPtr<Gio::DBus::InterfaceInfo>::RefPtr (<retval>);
  return <retval>;
}


const GDBusInterface* Gio::DBus::Interface::gobj() const (const struct Interface * const this)
{
  const struct GDBusInterface * D.99433;
  int (*__vtbl_ptr_type) () * D.99434;
  int (*__vtbl_ptr_type) () * D.99435;
  long int D.99436;
  sizetype D.99437;
  const struct ObjectBase * D.99438;

  D.99434 = this->D.86043._vptr.Interface;
  D.99435 = D.99434 + 18446744073709551592;
  D.99436 = MEM[(long int *)D.99435];
  D.99437 = (sizetype) D.99436;
  D.99438 = this + D.99437;
  D.99433 = D.99438->gobject_;
  return D.99433;
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::DBus::InterfaceInfo] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct InterfaceInfo * D.99440;
  struct InterfaceInfo * D.99441;

  D.99440 = src->pCppObject_;
  this->pCppObject_ = D.99440;
  D.99441 = this->pCppObject_;
  if (D.99441 != 0B) goto <D.99442>; else goto <D.99443>;
  <D.99442>:
  D.99441 = this->pCppObject_;
  Gio::DBus::InterfaceInfo::reference (D.99441);
  goto <D.99444>;
  <D.99443>:
  <D.99444>:
}


Glib::RefPtr<T_CppObject>::RefPtr() [with T_CppObject = Gio::DBus::InterfaceInfo] (struct RefPtr * const this)
{
  this->pCppObject_ = 0B;
}


virtual Glib::RefPtr<Gio::DBus::Object> Gio::DBus::Interface::get_object_vfunc() const (const struct Interface * const this)
{
  long unsigned int D.99446;
  int (*__vtbl_ptr_type) () * D.99447;
  int (*__vtbl_ptr_type) () * D.99448;
  long int D.99449;
  sizetype D.99450;
  const struct ObjectBase * D.99451;
  struct GObject * D.99452;
  struct GTypeClass * D.99453;
  void * D.99454;
  struct GDBusObject * (*<T1141f>) (struct GDBusInterface *) D.99457;
  const struct GDBusInterface * D.99460;
  struct GDBusObject * D.99461;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.99446 = Gio::DBus::Interface::get_type ();
  D.99447 = this->D.86043._vptr.Interface;
  D.99448 = D.99447 + 18446744073709551592;
  D.99449 = MEM[(long int *)D.99448];
  D.99450 = (sizetype) D.99449;
  D.99451 = this + D.99450;
  D.99452 = D.99451->gobject_;
  D.99453 = MEM[(struct GTypeInstance *)D.99452].g_class;
  D.99454 = g_type_interface_peek (D.99453, D.99446);
  base = g_type_interface_peek_parent (D.99454);
  {
    if (base != 0B) goto <D.99455>; else goto <D.99456>;
    <D.99455>:
    D.99457 = base->get_object;
    if (D.99457 != 0B) goto <D.99458>; else goto <D.99459>;
    <D.99458>:
    {
      struct RefPtr retval;

      try
        {
          D.99457 = base->get_object;
          D.99460 = Gio::DBus::Interface::gobj (this);
          D.99461 = D.99457 (D.99460);
          retval = Glib::wrap (D.99461, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::DBus::Object>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.99459>:
    <D.99456>:
  }
  Glib::RefPtr<Gio::DBus::Object>::RefPtr (<retval>);
  return <retval>;
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::DBus::Object] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Object * D.99471;
  struct Object * D.99472;
  int (*__vtbl_ptr_type) () * D.99475;
  int (*__vtbl_ptr_type) () * D.99476;
  long int D.99477;
  sizetype D.99478;
  struct ObjectBase * D.99479;
  int (*__vtbl_ptr_type) () * D.99480;
  int (*__vtbl_ptr_type) () * D.99481;
  int (*__vtbl_ptr_type) () D.99482;

  D.99471 = src->pCppObject_;
  this->pCppObject_ = D.99471;
  D.99472 = this->pCppObject_;
  if (D.99472 != 0B) goto <D.99473>; else goto <D.99474>;
  <D.99473>:
  D.99472 = this->pCppObject_;
  D.99472 = this->pCppObject_;
  D.99475 = D.99472->D.96994._vptr.Interface;
  D.99476 = D.99475 + 18446744073709551592;
  D.99477 = MEM[(long int *)D.99476];
  D.99478 = (sizetype) D.99477;
  D.99479 = D.99472 + D.99478;
  D.99472 = this->pCppObject_;
  D.99472 = this->pCppObject_;
  D.99475 = D.99472->D.96994._vptr.Interface;
  D.99476 = D.99475 + 18446744073709551592;
  D.99477 = MEM[(long int *)D.99476];
  D.99478 = (sizetype) D.99477;
  D.99479 = D.99472 + D.99478;
  D.99480 = D.99479->_vptr.ObjectBase;
  D.99481 = D.99480 + 16;
  D.99482 = *D.99481;
  D.99472 = this->pCppObject_;
  D.99472 = this->pCppObject_;
  D.99475 = D.99472->D.96994._vptr.Interface;
  D.99476 = D.99475 + 18446744073709551592;
  D.99477 = MEM[(long int *)D.99476];
  D.99478 = (sizetype) D.99477;
  D.99479 = D.99472 + D.99478;
  OBJ_TYPE_REF(D.99482;(const struct ObjectBase)D.99479->2) (D.99479);
  goto <D.99483>;
  <D.99474>:
  <D.99483>:
}


Glib::RefPtr<T_CppObject>::RefPtr() [with T_CppObject = Gio::DBus::Object] (struct RefPtr * const this)
{
  this->pCppObject_ = 0B;
}


virtual void Gio::DBus::Interface::set_object_vfunc(const Glib::RefPtr<Gio::DBus::Object>&) (struct Interface * const this, const struct RefPtr & object)
{
  long unsigned int D.99484;
  int (*__vtbl_ptr_type) () * D.99485;
  int (*__vtbl_ptr_type) () * D.99486;
  long int D.99487;
  sizetype D.99488;
  struct ObjectBase * D.99489;
  struct GObject * D.99490;
  struct GTypeClass * D.99491;
  void * D.99492;
  void (*<T11423>) (struct GDBusInterface *, struct GDBusObject *) D.99495;
  struct BaseObjectType * D.99498;
  struct GDBusInterface * D.99499;
  struct BaseClassType * const base;

  D.99484 = Gio::DBus::Interface::get_type ();
  D.99485 = this->D.86043._vptr.Interface;
  D.99486 = D.99485 + 18446744073709551592;
  D.99487 = MEM[(long int *)D.99486];
  D.99488 = (sizetype) D.99487;
  D.99489 = this + D.99488;
  D.99490 = D.99489->gobject_;
  D.99491 = MEM[(struct GTypeInstance *)D.99490].g_class;
  D.99492 = g_type_interface_peek (D.99491, D.99484);
  base = g_type_interface_peek_parent (D.99492);
  if (base != 0B) goto <D.99493>; else goto <D.99494>;
  <D.99493>:
  D.99495 = base->set_object;
  if (D.99495 != 0B) goto <D.99496>; else goto <D.99497>;
  <D.99496>:
  D.99495 = base->set_object;
  D.99498 = Glib::unwrap<Gio::DBus::Object> (object);
  D.99499 = Gio::DBus::Interface::gobj (this);
  D.99495 (D.99499, D.99498);
  goto <D.99500>;
  <D.99497>:
  <D.99500>:
  <D.99494>:
}


virtual Glib::RefPtr<Gio::DBus::Object> Gio::DBus::Interface::dup_object_vfunc() const (const struct Interface * const this)
{
  long unsigned int D.99506;
  int (*__vtbl_ptr_type) () * D.99507;
  int (*__vtbl_ptr_type) () * D.99508;
  long int D.99509;
  sizetype D.99510;
  const struct ObjectBase * D.99511;
  struct GObject * D.99512;
  struct GTypeClass * D.99513;
  void * D.99514;
  struct GDBusObject * (*<T1141f>) (struct GDBusInterface *) D.99517;
  const struct GDBusInterface * D.99520;
  struct GDBusObject * D.99521;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.99506 = Gio::DBus::Interface::get_type ();
  D.99507 = this->D.86043._vptr.Interface;
  D.99508 = D.99507 + 18446744073709551592;
  D.99509 = MEM[(long int *)D.99508];
  D.99510 = (sizetype) D.99509;
  D.99511 = this + D.99510;
  D.99512 = D.99511->gobject_;
  D.99513 = MEM[(struct GTypeInstance *)D.99512].g_class;
  D.99514 = g_type_interface_peek (D.99513, D.99506);
  base = g_type_interface_peek_parent (D.99514);
  {
    if (base != 0B) goto <D.99515>; else goto <D.99516>;
    <D.99515>:
    D.99517 = base->dup_object;
    if (D.99517 != 0B) goto <D.99518>; else goto <D.99519>;
    <D.99518>:
    {
      struct RefPtr retval;

      try
        {
          D.99517 = base->dup_object;
          D.99520 = Gio::DBus::Interface::gobj (this);
          D.99521 = D.99517 (D.99520);
          retval = Glib::wrap (D.99521, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::DBus::Object>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::DBus::Object>::~RefPtr (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.99519>:
    <D.99516>:
  }
  Glib::RefPtr<Gio::DBus::Object>::RefPtr (<retval>);
  return <retval>;
}