void Gio::UnixConnection::receive_credentials_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable)
{
  void * slot_copy.0;
  struct BaseObjectType * D.100774;
  struct GUnixConnection * D.100775;
  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.100774 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.100775 = Gio::UnixConnection::gobj (this);
  g_unix_connection_receive_credentials_async (D.100775, D.100774, 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.100780;

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

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


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.100781;
  struct slot_base * D.100782;

  D.100781 = &src->D.99288;
  D.100782 = &this->D.99288;
  sigc::slot_base::slot_base (D.100782, D.100781);
  try
    {

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


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.100783;
  struct BaseObjectType * iftmp.1;
  bool D.100785;
  struct Cancellable * D.100788;

  D.100785 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.100785 != 0) goto <D.100786>; else goto <D.100787>;
  <D.100786>:
  D.100788 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.100788);
  goto <D.100789>;
  <D.100787>:
  iftmp.1 = 0B;
  <D.100789>:
  D.100783 = iftmp.1;
  return D.100783;
}


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

  D.100792 = this->pCppObject_;
  D.100791 = D.100792 != 0B;
  return D.100791;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.100796;
  int (*__vtbl_ptr_type) () * D.100797;
  int (*__vtbl_ptr_type) () * D.100798;
  long int D.100799;
  sizetype D.100800;
  struct ObjectBase * D.100801;

  D.100797 = this->D.86174._vptr.Object;
  D.100798 = D.100797 + 18446744073709551592;
  D.100799 = MEM[(long int *)D.100798];
  D.100800 = (sizetype) D.100799;
  D.100801 = this + D.100800;
  D.100796 = D.100801->gobject_;
  return D.100796;
}


GUnixConnection* Gio::UnixConnection::gobj() (struct UnixConnection * const this)
{
  struct GUnixConnection * D.100803;
  int (*__vtbl_ptr_type) () * D.100804;
  int (*__vtbl_ptr_type) () * D.100805;
  long int D.100806;
  sizetype D.100807;
  struct ObjectBase * D.100808;

  D.100804 = this->D.99099.D.98951.D.86809._vptr.Object;
  D.100805 = D.100804 + 18446744073709551592;
  D.100806 = MEM[(long int *)D.100805];
  D.100807 = (sizetype) D.100806;
  D.100808 = this + D.100807;
  D.100803 = D.100808->gobject_;
  return D.100803;
}


void Gio::UnixConnection::receive_credentials_async(const SlotAsyncReady&) (struct UnixConnection * const this, const struct SlotAsyncReady & slot)
{
  void * slot_copy.2;
  struct GUnixConnection * D.100810;
  struct SlotAsyncReady * slot_copy;

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


void Gio::UnixConnection::send_credentials_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable)
{
  void * slot_copy.3;
  struct BaseObjectType * D.100813;
  struct GUnixConnection * D.100814;
  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.100813 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.100814 = Gio::UnixConnection::gobj (this);
  g_unix_connection_send_credentials_async (D.100814, D.100813, SignalProxy_async_callback, slot_copy);
}


void Gio::UnixConnection::send_credentials_async(const SlotAsyncReady&) (struct UnixConnection * const this, const struct SlotAsyncReady & slot)
{
  void * slot_copy.4;
  struct GUnixConnection * D.100818;
  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.100818 = Gio::UnixConnection::gobj (this);
  g_unix_connection_send_credentials_async (D.100818, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::UnixConnection> Glib::wrap(GUnixConnection*, bool) (struct GUnixConnection * object, bool take_copy)
{
  struct UnixConnection * iftmp.5;
  int D.100823;
  struct ObjectBase * D.100824;

  D.100823 = (int) take_copy;
  D.100824 = Glib::wrap_auto (object, D.100823);
  if (D.100824 == 0B) goto <D.100825>; else goto <D.100826>;
  <D.100825>:
  iftmp.5 = 0B;
  goto <D.100827>;
  <D.100826>:
  iftmp.5 = __dynamic_cast (D.100824, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14UnixConnectionE, -1);
  <D.100827>:
  Glib::RefPtr<Gio::UnixConnection>::RefPtr (<retval>, iftmp.5);
  return <retval>;
}


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


const Glib::Class& Gio::UnixConnection_Class::init() (struct UnixConnection_Class * const this)
{
  long unsigned int D.100830;
  long unsigned int D.100833;
  struct Class * D.100834;
  const struct Class & D.100836;

  D.100830 = this->D.99174.gtype_;
  if (D.100830 == 0) goto <D.100831>; else goto <D.100832>;
  <D.100831>:
  this->D.99174.class_init_func_ = class_init_function;
  D.100833 = g_unix_connection_get_type ();
  D.100834 = &this->D.99174;
  Glib::Class::register_derived_type (D.100834, D.100833);
  goto <D.100835>;
  <D.100832>:
  <D.100835>:
  D.100836 = &this->D.99174;
  return D.100836;
}


static void Gio::UnixConnection_Class::class_init_function(void*, void*) (void * g_class, void * class_data)
{
  struct BaseClassType * const klass;

  klass = g_class;
  Gio::SocketConnection_Class::class_init_function (klass, class_data);
}


static Glib::ObjectBase* Gio::UnixConnection_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.100839;
  struct ObjectBase * iftmp.6;
  void * D.99640;
  void * D.100841;
  int (*__vtbl_ptr_type) () * D.100844;
  int (*__vtbl_ptr_type) () * D.100845;
  long int D.100846;
  sizetype D.100847;

  D.99640 = operator new (48);
  try
    {
      Gio::UnixConnection::UnixConnection (D.99640, object);
    }
  catch
    {
      operator delete (D.99640);
    }
  D.100841 = D.99640;
  if (D.100841 != 0B) goto <D.100842>; else goto <D.100843>;
  <D.100842>:
  D.100844 = MEM[(struct UnixConnection *)D.100841].D.99099.D.98951.D.86809._vptr.Object;
  D.100845 = D.100844 + 18446744073709551592;
  D.100846 = MEM[(long int *)D.100845];
  D.100847 = (sizetype) D.100846;
  iftmp.6 = D.100841 + D.100847;
  goto <D.100848>;
  <D.100843>:
  iftmp.6 = 0B;
  <D.100848>:
  D.100839 = iftmp.6;
  return D.100839;
}


GUnixConnection* Gio::UnixConnection::gobj_copy() (struct UnixConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.100852;
  int (*__vtbl_ptr_type) () * D.100853;
  long int D.100854;
  sizetype D.100855;
  struct ObjectBase * D.100856;
  int (*__vtbl_ptr_type) () * D.100857;
  int (*__vtbl_ptr_type) () * D.100858;
  int (*__vtbl_ptr_type) () D.100859;
  struct GUnixConnection * D.100860;

  D.100852 = this->D.99099.D.98951.D.86809._vptr.Object;
  D.100853 = D.100852 + 18446744073709551592;
  D.100854 = MEM[(long int *)D.100853];
  D.100855 = (sizetype) D.100854;
  D.100856 = this + D.100855;
  D.100852 = this->D.99099.D.98951.D.86809._vptr.Object;
  D.100853 = D.100852 + 18446744073709551592;
  D.100854 = MEM[(long int *)D.100853];
  D.100855 = (sizetype) D.100854;
  D.100856 = this + D.100855;
  D.100857 = D.100856->_vptr.ObjectBase;
  D.100858 = D.100857 + 16;
  D.100859 = *D.100858;
  D.100852 = this->D.99099.D.98951.D.86809._vptr.Object;
  D.100853 = D.100852 + 18446744073709551592;
  D.100854 = MEM[(long int *)D.100853];
  D.100855 = (sizetype) D.100854;
  D.100856 = this + D.100855;
  OBJ_TYPE_REF(D.100859;(const struct ObjectBase)D.100856->2) (D.100856);
  D.100860 = Gio::UnixConnection::gobj (this);
  return D.100860;
}


Gio::UnixConnection::UnixConnection(const Glib::ConstructParams&) (struct UnixConnection * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.100864;
  const void * * iftmp.7;
  struct ObjectBase * D.100872;
  const void * * iftmp.8;
  struct SocketConnection * D.100878;
  int (*__vtbl_ptr_type) () * iftmp.9;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.100886;
  int (*__vtbl_ptr_type) () * D.100887;
  long int D.100888;
  struct ObjectBase * D.100890;
  int (*__vtbl_ptr_type) () * iftmp.11;
  const void * * iftmp.12;
  const void * * iftmp.13;

  if (0 != 0) goto <D.100862>; else goto <D.100863>;
  <D.100862>:
  D.100864 = &this->D.99102;
  sigc::trackable::trackable (D.100864);
  goto <D.100865>;
  <D.100863>:
  <D.100865>:
  try
    {
      if (0 != 0) goto <D.100866>; else goto <D.100867>;
      <D.100866>:
      if (0 == 0) goto <D.100869>; else goto <D.100870>;
      <D.100869>:
      iftmp.7 = __vtt_parm + 64;
      goto <D.100871>;
      <D.100870>:
      iftmp.7 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
      <D.100871>:
      D.100872 = &this->D.99101;
      Glib::ObjectBase::ObjectBase (D.100872, iftmp.7);
      goto <D.100873>;
      <D.100867>:
      <D.100873>:
      try
        {
          if (0 == 0) goto <D.100875>; else goto <D.100876>;
          <D.100875>:
          iftmp.8 = __vtt_parm + 8;
          goto <D.100877>;
          <D.100876>:
          iftmp.8 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
          <D.100877>:
          D.100878 = &this->D.99099;
          Gio::SocketConnection::SocketConnection (D.100878, iftmp.8, construct_params);
          try
            {
              if (0 == 0) goto <D.100880>; else goto <D.100881>;
              <D.100880>:
              iftmp.9 = *__vtt_parm;
              goto <D.100882>;
              <D.100881>:
              iftmp.9 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
              <D.100882>:
              this->D.99099.D.98951.D.86809._vptr.Object = iftmp.9;
              if (0 == 0) goto <D.100884>; else goto <D.100885>;
              <D.100884>:
              D.100886 = this->D.99099.D.98951.D.86809._vptr.Object;
              D.100887 = D.100886 + 18446744073709551592;
              D.100888 = MEM[(long int *)D.100887];
              iftmp.10 = (sizetype) D.100888;
              goto <D.100889>;
              <D.100885>:
              iftmp.10 = 8;
              <D.100889>:
              D.100890 = this + iftmp.10;
              if (0 == 0) goto <D.100892>; else goto <D.100893>;
              <D.100892>:
              iftmp.11 = MEM[(const void * *)__vtt_parm + 56B];
              goto <D.100894>;
              <D.100893>:
              iftmp.11 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
              <D.100894>:
              D.100890->_vptr.ObjectBase = iftmp.11;
            }
          catch
            {
              if (0 == 0) goto <D.100896>; else goto <D.100897>;
              <D.100896>:
              iftmp.12 = __vtt_parm + 8;
              goto <D.100898>;
              <D.100897>:
              iftmp.12 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
              <D.100898>:
              D.100878 = &this->D.99099;
              Gio::SocketConnection::~SocketConnection (D.100878, iftmp.12);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100899>; else goto <D.100900>;
          <D.100899>:
          if (0 == 0) goto <D.100902>; else goto <D.100903>;
          <D.100902>:
          iftmp.13 = __vtt_parm + 64;
          goto <D.100904>;
          <D.100903>:
          iftmp.13 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
          <D.100904>:
          D.100872 = &this->D.99101;
          Glib::ObjectBase::~ObjectBase (D.100872, iftmp.13);
          goto <D.100905>;
          <D.100900>:
          <D.100905>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100906>; else goto <D.100907>;
      <D.100906>:
      D.100864 = &this->D.99102;
      sigc::trackable::~trackable (D.100864);
      goto <D.100908>;
      <D.100907>:
      <D.100908>:
    }
}


Gio::UnixConnection::UnixConnection(const Glib::ConstructParams&) (struct UnixConnection * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.100913;
  const void * * iftmp.14;
  struct ObjectBase * D.100921;
  const void * * iftmp.15;
  struct SocketConnection * D.100927;
  int (*__vtbl_ptr_type) () * iftmp.16;
  const void * * D.100931;
  sizetype iftmp.17;
  int (*__vtbl_ptr_type) () * D.100936;
  int (*__vtbl_ptr_type) () * D.100937;
  long int D.100938;
  struct ObjectBase * D.100940;
  int (*__vtbl_ptr_type) () * iftmp.18;
  const void * * iftmp.19;
  const void * * iftmp.20;

  if (1 != 0) goto <D.100911>; else goto <D.100912>;
  <D.100911>:
  D.100913 = &this->D.99102;
  sigc::trackable::trackable (D.100913);
  goto <D.100914>;
  <D.100912>:
  <D.100914>:
  try
    {
      if (1 != 0) goto <D.100915>; else goto <D.100916>;
      <D.100915>:
      if (1 == 0) goto <D.100918>; else goto <D.100919>;
      <D.100918>:
      iftmp.14 = 64B;
      goto <D.100920>;
      <D.100919>:
      iftmp.14 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
      <D.100920>:
      D.100921 = &this->D.99101;
      Glib::ObjectBase::ObjectBase (D.100921, iftmp.14);
      goto <D.100922>;
      <D.100916>:
      <D.100922>:
      try
        {
          if (1 == 0) goto <D.100924>; else goto <D.100925>;
          <D.100924>:
          iftmp.15 = 8B;
          goto <D.100926>;
          <D.100925>:
          iftmp.15 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
          <D.100926>:
          D.100927 = &this->D.99099;
          Gio::SocketConnection::SocketConnection (D.100927, iftmp.15, construct_params);
          try
            {
              if (1 == 0) goto <D.100929>; else goto <D.100930>;
              <D.100929>:
              D.100931 = 0B;
              iftmp.16 = *D.100931;
              goto <D.100932>;
              <D.100930>:
              iftmp.16 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
              <D.100932>:
              this->D.99099.D.98951.D.86809._vptr.Object = iftmp.16;
              if (1 == 0) goto <D.100934>; else goto <D.100935>;
              <D.100934>:
              D.100936 = this->D.99099.D.98951.D.86809._vptr.Object;
              D.100937 = D.100936 + 18446744073709551592;
              D.100938 = MEM[(long int *)D.100937];
              iftmp.17 = (sizetype) D.100938;
              goto <D.100939>;
              <D.100935>:
              iftmp.17 = 8;
              <D.100939>:
              D.100940 = this + iftmp.17;
              if (1 == 0) goto <D.100942>; else goto <D.100943>;
              <D.100942>:
              iftmp.18 = MEM[(const void * *)0B + 56B];
              goto <D.100944>;
              <D.100943>:
              iftmp.18 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
              <D.100944>:
              D.100940->_vptr.ObjectBase = iftmp.18;
            }
          catch
            {
              if (1 == 0) goto <D.100946>; else goto <D.100947>;
              <D.100946>:
              iftmp.19 = 8B;
              goto <D.100948>;
              <D.100947>:
              iftmp.19 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
              <D.100948>:
              D.100927 = &this->D.99099;
              Gio::SocketConnection::~SocketConnection (D.100927, iftmp.19);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100949>; else goto <D.100950>;
          <D.100949>:
          if (1 == 0) goto <D.100952>; else goto <D.100953>;
          <D.100952>:
          iftmp.20 = 64B;
          goto <D.100954>;
          <D.100953>:
          iftmp.20 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
          <D.100954>:
          D.100921 = &this->D.99101;
          Glib::ObjectBase::~ObjectBase (D.100921, iftmp.20);
          goto <D.100955>;
          <D.100950>:
          <D.100955>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100956>; else goto <D.100957>;
      <D.100956>:
      D.100913 = &this->D.99102;
      sigc::trackable::~trackable (D.100913);
      goto <D.100958>;
      <D.100957>:
      <D.100958>:
    }
}


Gio::UnixConnection::UnixConnection(GUnixConnection*) (struct UnixConnection * const this, const void * * __vtt_parm, struct GUnixConnection * castitem)
{
  struct trackable * D.100963;
  const void * * iftmp.21;
  struct ObjectBase * D.100971;
  const void * * iftmp.22;
  struct SocketConnection * D.100977;
  int (*__vtbl_ptr_type) () * iftmp.23;
  sizetype iftmp.24;
  int (*__vtbl_ptr_type) () * D.100985;
  int (*__vtbl_ptr_type) () * D.100986;
  long int D.100987;
  struct ObjectBase * D.100989;
  int (*__vtbl_ptr_type) () * iftmp.25;
  const void * * iftmp.26;
  const void * * iftmp.27;

  if (0 != 0) goto <D.100961>; else goto <D.100962>;
  <D.100961>:
  D.100963 = &this->D.99102;
  sigc::trackable::trackable (D.100963);
  goto <D.100964>;
  <D.100962>:
  <D.100964>:
  try
    {
      if (0 != 0) goto <D.100965>; else goto <D.100966>;
      <D.100965>:
      if (0 == 0) goto <D.100968>; else goto <D.100969>;
      <D.100968>:
      iftmp.21 = __vtt_parm + 64;
      goto <D.100970>;
      <D.100969>:
      iftmp.21 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
      <D.100970>:
      D.100971 = &this->D.99101;
      Glib::ObjectBase::ObjectBase (D.100971, iftmp.21);
      goto <D.100972>;
      <D.100966>:
      <D.100972>:
      try
        {
          if (0 == 0) goto <D.100974>; else goto <D.100975>;
          <D.100974>:
          iftmp.22 = __vtt_parm + 8;
          goto <D.100976>;
          <D.100975>:
          iftmp.22 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
          <D.100976>:
          D.100977 = &this->D.99099;
          Gio::SocketConnection::SocketConnection (D.100977, iftmp.22, castitem);
          try
            {
              if (0 == 0) goto <D.100979>; else goto <D.100980>;
              <D.100979>:
              iftmp.23 = *__vtt_parm;
              goto <D.100981>;
              <D.100980>:
              iftmp.23 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
              <D.100981>:
              this->D.99099.D.98951.D.86809._vptr.Object = iftmp.23;
              if (0 == 0) goto <D.100983>; else goto <D.100984>;
              <D.100983>:
              D.100985 = this->D.99099.D.98951.D.86809._vptr.Object;
              D.100986 = D.100985 + 18446744073709551592;
              D.100987 = MEM[(long int *)D.100986];
              iftmp.24 = (sizetype) D.100987;
              goto <D.100988>;
              <D.100984>:
              iftmp.24 = 8;
              <D.100988>:
              D.100989 = this + iftmp.24;
              if (0 == 0) goto <D.100991>; else goto <D.100992>;
              <D.100991>:
              iftmp.25 = MEM[(const void * *)__vtt_parm + 56B];
              goto <D.100993>;
              <D.100992>:
              iftmp.25 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
              <D.100993>:
              D.100989->_vptr.ObjectBase = iftmp.25;
            }
          catch
            {
              if (0 == 0) goto <D.100995>; else goto <D.100996>;
              <D.100995>:
              iftmp.26 = __vtt_parm + 8;
              goto <D.100997>;
              <D.100996>:
              iftmp.26 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
              <D.100997>:
              D.100977 = &this->D.99099;
              Gio::SocketConnection::~SocketConnection (D.100977, iftmp.26);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100998>; else goto <D.100999>;
          <D.100998>:
          if (0 == 0) goto <D.101001>; else goto <D.101002>;
          <D.101001>:
          iftmp.27 = __vtt_parm + 64;
          goto <D.101003>;
          <D.101002>:
          iftmp.27 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
          <D.101003>:
          D.100971 = &this->D.99101;
          Glib::ObjectBase::~ObjectBase (D.100971, iftmp.27);
          goto <D.101004>;
          <D.100999>:
          <D.101004>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101005>; else goto <D.101006>;
      <D.101005>:
      D.100963 = &this->D.99102;
      sigc::trackable::~trackable (D.100963);
      goto <D.101007>;
      <D.101006>:
      <D.101007>:
    }
}


Gio::UnixConnection::UnixConnection(GUnixConnection*) (struct UnixConnection * const this, struct GUnixConnection * castitem)
{
  struct trackable * D.101012;
  const void * * iftmp.28;
  struct ObjectBase * D.101020;
  const void * * iftmp.29;
  struct SocketConnection * D.101026;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * D.101030;
  sizetype iftmp.31;
  int (*__vtbl_ptr_type) () * D.101035;
  int (*__vtbl_ptr_type) () * D.101036;
  long int D.101037;
  struct ObjectBase * D.101039;
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * iftmp.33;
  const void * * iftmp.34;

  if (1 != 0) goto <D.101010>; else goto <D.101011>;
  <D.101010>:
  D.101012 = &this->D.99102;
  sigc::trackable::trackable (D.101012);
  goto <D.101013>;
  <D.101011>:
  <D.101013>:
  try
    {
      if (1 != 0) goto <D.101014>; else goto <D.101015>;
      <D.101014>:
      if (1 == 0) goto <D.101017>; else goto <D.101018>;
      <D.101017>:
      iftmp.28 = 64B;
      goto <D.101019>;
      <D.101018>:
      iftmp.28 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
      <D.101019>:
      D.101020 = &this->D.99101;
      Glib::ObjectBase::ObjectBase (D.101020, iftmp.28);
      goto <D.101021>;
      <D.101015>:
      <D.101021>:
      try
        {
          if (1 == 0) goto <D.101023>; else goto <D.101024>;
          <D.101023>:
          iftmp.29 = 8B;
          goto <D.101025>;
          <D.101024>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
          <D.101025>:
          D.101026 = &this->D.99099;
          Gio::SocketConnection::SocketConnection (D.101026, iftmp.29, castitem);
          try
            {
              if (1 == 0) goto <D.101028>; else goto <D.101029>;
              <D.101028>:
              D.101030 = 0B;
              iftmp.30 = *D.101030;
              goto <D.101031>;
              <D.101029>:
              iftmp.30 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
              <D.101031>:
              this->D.99099.D.98951.D.86809._vptr.Object = iftmp.30;
              if (1 == 0) goto <D.101033>; else goto <D.101034>;
              <D.101033>:
              D.101035 = this->D.99099.D.98951.D.86809._vptr.Object;
              D.101036 = D.101035 + 18446744073709551592;
              D.101037 = MEM[(long int *)D.101036];
              iftmp.31 = (sizetype) D.101037;
              goto <D.101038>;
              <D.101034>:
              iftmp.31 = 8;
              <D.101038>:
              D.101039 = this + iftmp.31;
              if (1 == 0) goto <D.101041>; else goto <D.101042>;
              <D.101041>:
              iftmp.32 = MEM[(const void * *)0B + 56B];
              goto <D.101043>;
              <D.101042>:
              iftmp.32 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
              <D.101043>:
              D.101039->_vptr.ObjectBase = iftmp.32;
            }
          catch
            {
              if (1 == 0) goto <D.101045>; else goto <D.101046>;
              <D.101045>:
              iftmp.33 = 8B;
              goto <D.101047>;
              <D.101046>:
              iftmp.33 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
              <D.101047>:
              D.101026 = &this->D.99099;
              Gio::SocketConnection::~SocketConnection (D.101026, iftmp.33);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101048>; else goto <D.101049>;
          <D.101048>:
          if (1 == 0) goto <D.101051>; else goto <D.101052>;
          <D.101051>:
          iftmp.34 = 64B;
          goto <D.101053>;
          <D.101052>:
          iftmp.34 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
          <D.101053>:
          D.101020 = &this->D.99101;
          Glib::ObjectBase::~ObjectBase (D.101020, iftmp.34);
          goto <D.101054>;
          <D.101049>:
          <D.101054>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101055>; else goto <D.101056>;
      <D.101055>:
      D.101012 = &this->D.99102;
      sigc::trackable::~trackable (D.101012);
      goto <D.101057>;
      <D.101056>:
      <D.101057>:
    }
}


Gio::UnixConnection::~UnixConnection() (struct UnixConnection * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.35;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.101067;
  int (*__vtbl_ptr_type) () * D.101068;
  long int D.101069;
  struct ObjectBase * D.101071;
  int (*__vtbl_ptr_type) () * iftmp.37;
  const void * * iftmp.38;
  struct SocketConnection * D.101080;
  int D.101081;
  const void * * iftmp.39;
  struct ObjectBase * D.101088;
  struct trackable * D.101092;
  int D.101094;

  {
    if (0 == 0) goto <D.101061>; else goto <D.101062>;
    <D.101061>:
    iftmp.35 = *__vtt_parm;
    goto <D.101063>;
    <D.101062>:
    iftmp.35 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
    <D.101063>:
    this->D.99099.D.98951.D.86809._vptr.Object = iftmp.35;
    if (0 == 0) goto <D.101065>; else goto <D.101066>;
    <D.101065>:
    D.101067 = this->D.99099.D.98951.D.86809._vptr.Object;
    D.101068 = D.101067 + 18446744073709551592;
    D.101069 = MEM[(long int *)D.101068];
    iftmp.36 = (sizetype) D.101069;
    goto <D.101070>;
    <D.101066>:
    iftmp.36 = 8;
    <D.101070>:
    D.101071 = this + iftmp.36;
    if (0 == 0) goto <D.101073>; else goto <D.101074>;
    <D.101073>:
    iftmp.37 = MEM[(const void * *)__vtt_parm + 56B];
    goto <D.101075>;
    <D.101074>:
    iftmp.37 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
    <D.101075>:
    D.101071->_vptr.ObjectBase = iftmp.37;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.101077>; else goto <D.101078>;
                    <D.101077>:
                    iftmp.38 = __vtt_parm + 8;
                    goto <D.101079>;
                    <D.101078>:
                    iftmp.38 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
                    <D.101079>:
                    D.101080 = &this->D.99099;
                    Gio::SocketConnection::~SocketConnection (D.101080, iftmp.38);
                  }
              }
            finally
              {
                D.101081 = 0;
                if (D.101081 != 0) goto <D.101082>; else goto <D.101083>;
                <D.101082>:
                if (0 == 0) goto <D.101085>; else goto <D.101086>;
                <D.101085>:
                iftmp.39 = __vtt_parm + 64;
                goto <D.101087>;
                <D.101086>:
                iftmp.39 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
                <D.101087>:
                D.101088 = &this->D.99101;
                Glib::ObjectBase::~ObjectBase (D.101088, iftmp.39);
                goto <D.101089>;
                <D.101083>:
                <D.101089>:
              }
          }
        finally
          {
            D.101081 = 0;
            if (D.101081 != 0) goto <D.101090>; else goto <D.101091>;
            <D.101090>:
            D.101092 = &this->D.99102;
            sigc::trackable::~trackable (D.101092);
            goto <D.101093>;
            <D.101091>:
            <D.101093>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99668>:
  D.101094 = 0;
  if (D.101094 != 0) goto <D.101095>; else goto <D.101096>;
  <D.101095>:
  operator delete (this);
  goto <D.101097>;
  <D.101096>:
  <D.101097>:
}


virtual Gio::UnixConnection::~UnixConnection() (struct UnixConnection * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * D.101113;
  sizetype iftmp.41;
  int (*__vtbl_ptr_type) () * D.101118;
  int (*__vtbl_ptr_type) () * D.101119;
  long int D.101120;
  struct ObjectBase * D.101122;
  int (*__vtbl_ptr_type) () * iftmp.42;
  const void * * iftmp.43;
  struct SocketConnection * D.101131;
  int D.101132;
  const void * * iftmp.44;
  struct ObjectBase * D.101139;
  struct trackable * D.101143;
  int D.101145;

  {
    if (2 == 0) goto <D.101111>; else goto <D.101112>;
    <D.101111>:
    D.101113 = 0B;
    iftmp.40 = *D.101113;
    goto <D.101114>;
    <D.101112>:
    iftmp.40 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 32B];
    <D.101114>:
    this->D.99099.D.98951.D.86809._vptr.Object = iftmp.40;
    if (2 == 0) goto <D.101116>; else goto <D.101117>;
    <D.101116>:
    D.101118 = this->D.99099.D.98951.D.86809._vptr.Object;
    D.101119 = D.101118 + 18446744073709551592;
    D.101120 = MEM[(long int *)D.101119];
    iftmp.41 = (sizetype) D.101120;
    goto <D.101121>;
    <D.101117>:
    iftmp.41 = 8;
    <D.101121>:
    D.101122 = this + iftmp.41;
    if (2 == 0) goto <D.101124>; else goto <D.101125>;
    <D.101124>:
    iftmp.42 = MEM[(const void * *)0B + 56B];
    goto <D.101126>;
    <D.101125>:
    iftmp.42 = &MEM[(void *)&_ZTVN3Gio14UnixConnectionE + 112B];
    <D.101126>:
    D.101122->_vptr.ObjectBase = iftmp.42;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.101128>; else goto <D.101129>;
                    <D.101128>:
                    iftmp.43 = 8B;
                    goto <D.101130>;
                    <D.101129>:
                    iftmp.43 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 8B];
                    <D.101130>:
                    D.101131 = &this->D.99099;
                    Gio::SocketConnection::~SocketConnection (D.101131, iftmp.43);
                  }
              }
            finally
              {
                D.101132 = 2;
                if (D.101132 != 0) goto <D.101133>; else goto <D.101134>;
                <D.101133>:
                if (2 == 0) goto <D.101136>; else goto <D.101137>;
                <D.101136>:
                iftmp.44 = 64B;
                goto <D.101138>;
                <D.101137>:
                iftmp.44 = &MEM[(void *)&_ZTTN3Gio14UnixConnectionE + 64B];
                <D.101138>:
                D.101139 = &this->D.99101;
                Glib::ObjectBase::~ObjectBase (D.101139, iftmp.44);
                goto <D.101140>;
                <D.101134>:
                <D.101140>:
              }
          }
        finally
          {
            D.101132 = 2;
            if (D.101132 != 0) goto <D.101141>; else goto <D.101142>;
            <D.101141>:
            D.101143 = &this->D.99102;
            sigc::trackable::~trackable (D.101143);
            goto <D.101144>;
            <D.101142>:
            <D.101144>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99671>:
  D.101145 = 0;
  if (D.101145 != 0) goto <D.101146>; else goto <D.101147>;
  <D.101146>:
  operator delete (this);
  goto <D.101148>;
  <D.101147>:
  <D.101148>:
}


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


static GType Gio::UnixConnection::get_type() ()
{
  GType D.101161;
  const struct Class & D.101162;

  D.101162 = Gio::UnixConnection_Class::init (&unixconnection_class_);
  D.101161 = Glib::Class::get_type (D.101162);
  return D.101161;
}


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

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


static GType Gio::UnixConnection::get_base_type() ()
{
  GType D.101167;

  D.101167 = g_unix_connection_get_type ();
  return D.101167;
}


bool Gio::UnixConnection::send_fd(int, const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, int fd, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101170;
  struct GUnixConnection * D.101171;
  int D.101172;
  struct GError * gerror.45;
  bool D.101176;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.101170 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101171 = Gio::UnixConnection::gobj (this);
      D.101172 = g_unix_connection_send_fd (D.101171, fd, D.101170, &gerror);
      retvalue = D.101172 != 0;
      gerror.45 = gerror;
      if (gerror.45 != 0B) goto <D.101174>; else goto <D.101175>;
      <D.101174>:
      gerror.45 = gerror;
      Glib::Error::throw_exception (gerror.45);
      <D.101175>:
      D.101176 = retvalue;
      return D.101176;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::UnixConnection::send_fd(int) (struct UnixConnection * const this, int fd)
{
  struct GUnixConnection * D.101182;
  int D.101183;
  struct GError * gerror.46;
  bool D.101187;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.101182 = Gio::UnixConnection::gobj (this);
      D.101183 = g_unix_connection_send_fd (D.101182, fd, 0B, &gerror);
      retvalue = D.101183 != 0;
      gerror.46 = gerror;
      if (gerror.46 != 0B) goto <D.101185>; else goto <D.101186>;
      <D.101185>:
      gerror.46 = gerror;
      Glib::Error::throw_exception (gerror.46);
      <D.101186>:
      D.101187 = retvalue;
      return D.101187;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


int Gio::UnixConnection::receive_fd(const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101192;
  struct GUnixConnection * D.101193;
  struct GError * gerror.47;
  int D.101197;
  struct GError * gerror;
  int retvalue;

  try
    {
      gerror = 0B;
      D.101192 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101193 = Gio::UnixConnection::gobj (this);
      retvalue = g_unix_connection_receive_fd (D.101193, D.101192, &gerror);
      gerror.47 = gerror;
      if (gerror.47 != 0B) goto <D.101195>; else goto <D.101196>;
      <D.101195>:
      gerror.47 = gerror;
      Glib::Error::throw_exception (gerror.47);
      <D.101196>:
      D.101197 = retvalue;
      return D.101197;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


int Gio::UnixConnection::receive_fd() (struct UnixConnection * const this)
{
  struct GUnixConnection * D.101203;
  struct GError * gerror.48;
  int D.101207;
  struct GError * gerror;
  int retvalue;

  try
    {
      gerror = 0B;
      D.101203 = Gio::UnixConnection::gobj (this);
      retvalue = g_unix_connection_receive_fd (D.101203, 0B, &gerror);
      gerror.48 = gerror;
      if (gerror.48 != 0B) goto <D.101205>; else goto <D.101206>;
      <D.101205>:
      gerror.48 = gerror;
      Glib::Error::throw_exception (gerror.48);
      <D.101206>:
      D.101207 = retvalue;
      return D.101207;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Credentials> Gio::UnixConnection::receive_credentials(const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101213;
  struct GUnixConnection * D.101214;
  struct GCredentials * D.101215;
  struct GError * gerror.49;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101213 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101214 = Gio::UnixConnection::gobj (this);
      D.101215 = g_unix_connection_receive_credentials (D.101214, D.101213, &gerror);
      *<retval> = Glib::wrap (D.101215, 0); [return slot optimization]
      try
        {
          gerror.49 = gerror;
          if (gerror.49 != 0B) goto <D.101217>; else goto <D.101218>;
          <D.101217>:
          gerror.49 = gerror;
          Glib::Error::throw_exception (gerror.49);
          <D.101218>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Credentials>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Credentials] (struct RefPtr * const this)
{
  struct Credentials * D.101225;
  int (*__vtbl_ptr_type) () * D.101228;
  int (*__vtbl_ptr_type) () * D.101229;
  long int D.101230;
  sizetype D.101231;
  struct ObjectBase * D.101232;
  int (*__vtbl_ptr_type) () * D.101233;
  int (*__vtbl_ptr_type) () * D.101234;
  int (*__vtbl_ptr_type) () D.101235;

  {
    try
      {
        D.101225 = this->pCppObject_;
        if (D.101225 != 0B) goto <D.101226>; else goto <D.101227>;
        <D.101226>:
        D.101225 = this->pCppObject_;
        D.101225 = this->pCppObject_;
        D.101228 = D.101225->D.97634._vptr.Object;
        D.101229 = D.101228 + 18446744073709551592;
        D.101230 = MEM[(long int *)D.101229];
        D.101231 = (sizetype) D.101230;
        D.101232 = D.101225 + D.101231;
        D.101225 = this->pCppObject_;
        D.101225 = this->pCppObject_;
        D.101228 = D.101225->D.97634._vptr.Object;
        D.101229 = D.101228 + 18446744073709551592;
        D.101230 = MEM[(long int *)D.101229];
        D.101231 = (sizetype) D.101230;
        D.101232 = D.101225 + D.101231;
        D.101233 = D.101232->_vptr.ObjectBase;
        D.101234 = D.101233 + 24;
        D.101235 = *D.101234;
        D.101225 = this->pCppObject_;
        D.101225 = this->pCppObject_;
        D.101228 = D.101225->D.97634._vptr.Object;
        D.101229 = D.101228 + 18446744073709551592;
        D.101230 = MEM[(long int *)D.101229];
        D.101231 = (sizetype) D.101230;
        D.101232 = D.101225 + D.101231;
        OBJ_TYPE_REF(D.101235;(const struct ObjectBase)D.101232->3) (D.101232);
        goto <D.101236>;
        <D.101227>:
        <D.101236>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100430>:
}


Glib::RefPtr<Gio::Credentials> Gio::UnixConnection::receive_credentials() (struct UnixConnection * const this)
{
  struct GUnixConnection * D.101239;
  struct GCredentials * D.101240;
  struct GError * gerror.50;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101239 = Gio::UnixConnection::gobj (this);
      D.101240 = g_unix_connection_receive_credentials (D.101239, 0B, &gerror);
      *<retval> = Glib::wrap (D.101240, 0); [return slot optimization]
      try
        {
          gerror.50 = gerror;
          if (gerror.50 != 0B) goto <D.101242>; else goto <D.101243>;
          <D.101242>:
          gerror.50 = gerror;
          Glib::Error::throw_exception (gerror.50);
          <D.101243>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Credentials>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::Credentials> Gio::UnixConnection::receive_credentials(const Glib::RefPtr<Gio::Cancellable>&) const (const struct UnixConnection * const this, const struct RefPtr & cancellable)
{
  struct RefPtr D.99987;

  D.99987 = Gio::UnixConnection::receive_credentials (this, cancellable); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Credentials>::RefPtr<Gio::Credentials> (<retval>, &D.99987);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Credentials>::~RefPtr (&D.99987);
      D.99987 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Credentials; T_CppObject = const Gio::Credentials] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Credentials * D.101253;
  const struct Credentials * D.101254;
  int (*__vtbl_ptr_type) () * D.101257;
  int (*__vtbl_ptr_type) () * D.101258;
  long int D.101259;
  sizetype D.101260;
  const struct ObjectBase * D.101261;
  int (*__vtbl_ptr_type) () * D.101262;
  int (*__vtbl_ptr_type) () * D.101263;
  int (*__vtbl_ptr_type) () D.101264;

  D.101253 = Glib::RefPtr<Gio::Credentials>::operator-> (src);
  this->pCppObject_ = D.101253;
  D.101254 = this->pCppObject_;
  if (D.101254 != 0B) goto <D.101255>; else goto <D.101256>;
  <D.101255>:
  D.101254 = this->pCppObject_;
  D.101254 = this->pCppObject_;
  D.101257 = D.101254->D.97634._vptr.Object;
  D.101258 = D.101257 + 18446744073709551592;
  D.101259 = MEM[(long int *)D.101258];
  D.101260 = (sizetype) D.101259;
  D.101261 = D.101254 + D.101260;
  D.101254 = this->pCppObject_;
  D.101254 = this->pCppObject_;
  D.101257 = D.101254->D.97634._vptr.Object;
  D.101258 = D.101257 + 18446744073709551592;
  D.101259 = MEM[(long int *)D.101258];
  D.101260 = (sizetype) D.101259;
  D.101261 = D.101254 + D.101260;
  D.101262 = D.101261->_vptr.ObjectBase;
  D.101263 = D.101262 + 16;
  D.101264 = *D.101263;
  D.101254 = this->pCppObject_;
  D.101254 = this->pCppObject_;
  D.101257 = D.101254->D.97634._vptr.Object;
  D.101258 = D.101257 + 18446744073709551592;
  D.101259 = MEM[(long int *)D.101258];
  D.101260 = (sizetype) D.101259;
  D.101261 = D.101254 + D.101260;
  OBJ_TYPE_REF(D.101264;(const struct ObjectBase)D.101261->2) (D.101261);
  goto <D.101265>;
  <D.101256>:
  <D.101265>:
}


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

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


Glib::RefPtr<const Gio::Credentials> Gio::UnixConnection::receive_credentials() const (const struct UnixConnection * const this)
{
  struct RefPtr D.100010;

  D.100010 = Gio::UnixConnection::receive_credentials (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Credentials>::RefPtr<Gio::Credentials> (<retval>, &D.100010);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Credentials>::~RefPtr (&D.100010);
      D.100010 = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Credentials> Gio::UnixConnection::receive_credentials_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct UnixConnection * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.101273;
  struct GUnixConnection * D.101274;
  struct GCredentials * D.101275;
  struct GError * gerror.51;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101273 = Glib::unwrap<Gio::AsyncResult> (result);
      D.101274 = Gio::UnixConnection::gobj (this);
      D.101275 = g_unix_connection_receive_credentials_finish (D.101274, D.101273, &gerror);
      *<retval> = Glib::wrap (D.101275, 0); [return slot optimization]
      try
        {
          gerror.51 = gerror;
          if (gerror.51 != 0B) goto <D.101277>; else goto <D.101278>;
          <D.101277>:
          gerror.51 = gerror;
          Glib::Error::throw_exception (gerror.51);
          <D.101278>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Credentials>::~RefPtr (<retval>);
        }
    }
  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.101285;
  struct BaseObjectType * iftmp.52;
  bool D.101287;
  struct AsyncResult * D.101290;

  D.101287 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.101287 != 0) goto <D.101288>; else goto <D.101289>;
  <D.101288>:
  D.101290 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.52 = Gio::AsyncResult::gobj (D.101290);
  goto <D.101291>;
  <D.101289>:
  iftmp.52 = 0B;
  <D.101291>:
  D.101285 = iftmp.52;
  return D.101285;
}


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

  D.101294 = this->pCppObject_;
  D.101293 = D.101294 != 0B;
  return D.101293;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.101298;
  int (*__vtbl_ptr_type) () * D.101299;
  int (*__vtbl_ptr_type) () * D.101300;
  long int D.101301;
  sizetype D.101302;
  struct ObjectBase * D.101303;

  D.101299 = this->D.86030._vptr.Interface;
  D.101300 = D.101299 + 18446744073709551592;
  D.101301 = MEM[(long int *)D.101300];
  D.101302 = (sizetype) D.101301;
  D.101303 = this + D.101302;
  D.101298 = D.101303->gobject_;
  return D.101298;
}


bool Gio::UnixConnection::send_credentials(const Glib::RefPtr<Gio::Cancellable>&) (struct UnixConnection * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101305;
  struct GUnixConnection * D.101306;
  int D.101307;
  struct GError * gerror.53;
  bool D.101311;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.101305 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101306 = Gio::UnixConnection::gobj (this);
      D.101307 = g_unix_connection_send_credentials (D.101306, D.101305, &gerror);
      retvalue = D.101307 != 0;
      gerror.53 = gerror;
      if (gerror.53 != 0B) goto <D.101309>; else goto <D.101310>;
      <D.101309>:
      gerror.53 = gerror;
      Glib::Error::throw_exception (gerror.53);
      <D.101310>:
      D.101311 = retvalue;
      return D.101311;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::UnixConnection::send_credentials() (struct UnixConnection * const this)
{
  struct GUnixConnection * D.101317;
  int D.101318;
  struct GError * gerror.54;
  bool D.101322;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.101317 = Gio::UnixConnection::gobj (this);
      D.101318 = g_unix_connection_send_credentials (D.101317, 0B, &gerror);
      retvalue = D.101318 != 0;
      gerror.54 = gerror;
      if (gerror.54 != 0B) goto <D.101320>; else goto <D.101321>;
      <D.101320>:
      gerror.54 = gerror;
      Glib::Error::throw_exception (gerror.54);
      <D.101321>:
      D.101322 = retvalue;
      return D.101322;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::UnixConnection::send_credentials_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct UnixConnection * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.101327;
  struct GUnixConnection * D.101328;
  int D.101329;
  struct GError * gerror.55;
  bool D.101333;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.101327 = Glib::unwrap<Gio::AsyncResult> (result);
      D.101328 = Gio::UnixConnection::gobj (this);
      D.101329 = g_unix_connection_send_credentials_finish (D.101328, D.101327, &gerror);
      retvalue = D.101329 != 0;
      gerror.55 = gerror;
      if (gerror.55 != 0B) goto <D.101331>; else goto <D.101332>;
      <D.101331>:
      gerror.55 = gerror;
      Glib::Error::throw_exception (gerror.55);
      <D.101332>:
      D.101333 = retvalue;
      return D.101333;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}