void Gio::Proxy::connect_async(const Glib::RefPtr<Gio::IOStream>&, const Glib::RefPtr<const Gio::ProxyAddress>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&) (struct Proxy * const this, const struct RefPtr & connection, const struct RefPtr & proxy_address, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable)
{
  void * slot_copy.0;
  struct BaseObjectType * D.100049;
  const struct BaseObjectType * D.100050;
  struct BaseObjectType * D.100051;
  struct GProxy * D.100052;
  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.100049 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.100050 = Glib::unwrap<Gio::ProxyAddress> (proxy_address);
  D.100051 = Glib::unwrap<Gio::IOStream> (connection);
  D.100052 = Gio::Proxy::gobj (this);
  g_proxy_connect_async (D.100052, D.100051, D.100050, D.100049, 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.100059;

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

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


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.100060;
  struct slot_base * D.100061;

  D.100060 = &src->D.98501;
  D.100061 = &this->D.98501;
  sigc::slot_base::slot_base (D.100061, D.100060);
  try
    {

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


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.100062;
  struct BaseObjectType * iftmp.1;
  bool D.100064;
  struct Cancellable * D.100067;

  D.100064 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.100064 != 0) goto <D.100065>; else goto <D.100066>;
  <D.100065>:
  D.100067 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.100067);
  goto <D.100068>;
  <D.100066>:
  iftmp.1 = 0B;
  <D.100068>:
  D.100062 = iftmp.1;
  return D.100062;
}


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

  D.100071 = this->pCppObject_;
  D.100070 = D.100071 != 0B;
  return D.100070;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.100075;
  int (*__vtbl_ptr_type) () * D.100076;
  int (*__vtbl_ptr_type) () * D.100077;
  long int D.100078;
  sizetype D.100079;
  struct ObjectBase * D.100080;

  D.100076 = this->D.86174._vptr.Object;
  D.100077 = D.100076 + 18446744073709551592;
  D.100078 = MEM[(long int *)D.100077];
  D.100079 = (sizetype) D.100078;
  D.100080 = this + D.100079;
  D.100075 = D.100080->gobject_;
  return D.100075;
}


const typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<const T>&) [with T = Gio::ProxyAddress; typename T::BaseObjectType = _GProxyAddress] (const struct RefPtr & ptr)
{
  const struct BaseObjectType * D.100082;
  const struct BaseObjectType * iftmp.2;
  bool D.100084;
  const struct ProxyAddress * D.100087;

  D.100084 = Glib::RefPtr<const Gio::ProxyAddress>::operator bool (ptr);
  if (D.100084 != 0) goto <D.100085>; else goto <D.100086>;
  <D.100085>:
  D.100087 = Glib::RefPtr<const Gio::ProxyAddress>::operator-> (ptr);
  iftmp.2 = Gio::ProxyAddress::gobj (D.100087);
  goto <D.100088>;
  <D.100086>:
  iftmp.2 = 0B;
  <D.100088>:
  D.100082 = iftmp.2;
  return D.100082;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = const Gio::ProxyAddress] (const struct RefPtr * const this)
{
  bool D.100090;
  const struct ProxyAddress * D.100091;

  D.100091 = this->pCppObject_;
  D.100090 = D.100091 != 0B;
  return D.100090;
}


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

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


const GProxyAddress* Gio::ProxyAddress::gobj() const (const struct ProxyAddress * const this)
{
  const struct GProxyAddress * D.100095;
  int (*__vtbl_ptr_type) () * D.100096;
  int (*__vtbl_ptr_type) () * D.100097;
  long int D.100098;
  sizetype D.100099;
  const struct ObjectBase * D.100100;

  D.100096 = this->D.97618.D.97444.D.97112._vptr.Object;
  D.100097 = D.100096 + 18446744073709551592;
  D.100098 = MEM[(long int *)D.100097];
  D.100099 = (sizetype) D.100098;
  D.100100 = this + D.100099;
  D.100095 = D.100100->gobject_;
  return D.100095;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::IOStream; typename T::BaseObjectType = _GIOStream] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.100102;
  struct BaseObjectType * iftmp.3;
  bool D.100104;
  struct IOStream * D.100107;

  D.100104 = Glib::RefPtr<Gio::IOStream>::operator bool (ptr);
  if (D.100104 != 0) goto <D.100105>; else goto <D.100106>;
  <D.100105>:
  D.100107 = Glib::RefPtr<Gio::IOStream>::operator-> (ptr);
  iftmp.3 = Gio::IOStream::gobj (D.100107);
  goto <D.100108>;
  <D.100106>:
  iftmp.3 = 0B;
  <D.100108>:
  D.100102 = iftmp.3;
  return D.100102;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::IOStream] (const struct RefPtr * const this)
{
  bool D.100110;
  struct IOStream * D.100111;

  D.100111 = this->pCppObject_;
  D.100110 = D.100111 != 0B;
  return D.100110;
}


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

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


GIOStream* Gio::IOStream::gobj() (struct IOStream * const this)
{
  struct GIOStream * D.100115;
  int (*__vtbl_ptr_type) () * D.100116;
  int (*__vtbl_ptr_type) () * D.100117;
  long int D.100118;
  sizetype D.100119;
  struct ObjectBase * D.100120;

  D.100116 = this->D.98257._vptr.Object;
  D.100117 = D.100116 + 18446744073709551592;
  D.100118 = MEM[(long int *)D.100117];
  D.100119 = (sizetype) D.100118;
  D.100120 = this + D.100119;
  D.100115 = D.100120->gobject_;
  return D.100115;
}


GProxy* Gio::Proxy::gobj() (struct Proxy * const this)
{
  struct GProxy * D.100122;
  int (*__vtbl_ptr_type) () * D.100123;
  int (*__vtbl_ptr_type) () * D.100124;
  long int D.100125;
  sizetype D.100126;
  struct ObjectBase * D.100127;

  D.100123 = this->D.98394._vptr.Interface;
  D.100124 = D.100123 + 18446744073709551592;
  D.100125 = MEM[(long int *)D.100124];
  D.100126 = (sizetype) D.100125;
  D.100127 = this + D.100126;
  D.100122 = D.100127->gobject_;
  return D.100122;
}


void Gio::Proxy::connect_async(const Glib::RefPtr<Gio::IOStream>&, const Glib::RefPtr<const Gio::ProxyAddress>&, const SlotAsyncReady&) (struct Proxy * const this, const struct RefPtr & connection, const struct RefPtr & proxy_address, const struct SlotAsyncReady & slot)
{
  void * slot_copy.4;
  const struct BaseObjectType * D.100129;
  struct BaseObjectType * D.100130;
  struct GProxy * D.100131;
  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.100129 = Glib::unwrap<Gio::ProxyAddress> (proxy_address);
  D.100130 = Glib::unwrap<Gio::IOStream> (connection);
  D.100131 = Gio::Proxy::gobj (this);
  g_proxy_connect_async (D.100131, D.100130, D.100129, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::Proxy> Glib::wrap(GProxy*, bool) (struct GProxy * object, bool take_copy)
{
  int D.100137;
  struct Proxy * D.100138;

  D.100137 = (int) take_copy;
  D.100138 = Glib::wrap_auto_interface<Gio::Proxy> (object, D.100137);
  Glib::RefPtr<Gio::Proxy>::RefPtr (<retval>, D.100138);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::Proxy; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct Proxy * D.100143;
  long unsigned int D.100146;
  struct Proxy * iftmp.5;
  struct ObjectBase * pCppObject.6;
  const struct type_info * iftmp.7;
  int (*__vtbl_ptr_type) () * D.100160;
  const char * D.100162;
  void * result.8;
  bool D.100165;
  bool D.100166;
  int (*__vtbl_ptr_type) () * D.100169;
  int (*__vtbl_ptr_type) () * D.100170;
  long int D.100171;
  sizetype D.100172;
  struct ObjectBase * D.100173;
  int (*__vtbl_ptr_type) () * D.100174;
  int (*__vtbl_ptr_type) () * D.100175;
  int (*__vtbl_ptr_type) () D.100176;
  struct ObjectBase * pCppObject;
  struct Proxy * result;

  if (object == 0B) goto <D.100141>; else goto <D.100142>;
  <D.100141>:
  D.100143 = 0B;
  return D.100143;
  <D.100142>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.100144>; else goto <D.100145>;
  <D.100144>:
  D.100146 = Gio::Proxy::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.100146);
  goto <D.100147>;
  <D.100145>:
  <D.100147>:
  result = 0B;
  if (pCppObject != 0B) goto <D.100148>; else goto <D.100149>;
  <D.100148>:
  pCppObject.6 = pCppObject;
  if (pCppObject.6 == 0B) goto <D.100152>; else goto <D.100153>;
  <D.100152>:
  iftmp.5 = 0B;
  goto <D.100154>;
  <D.100153>:
  iftmp.5 = __dynamic_cast (pCppObject.6, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio5ProxyE, -1);
  <D.100154>:
  result = iftmp.5;
  if (result == 0B) goto <D.100155>; else goto <D.100156>;
  <D.100155>:
  if (pCppObject != 0B) goto <D.100158>; else goto <D.100159>;
  <D.100158>:
  D.100160 = pCppObject->_vptr.ObjectBase;
  iftmp.7 = MEM[(int (*__vtbl_ptr_type) () *)D.100160 + -8B];
  goto <D.100161>;
  <D.100159>:
  __cxa_bad_typeid ();
  <D.100161>:
  D.100162 = std::type_info::name (iftmp.7);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.100162);
  goto <D.100163>;
  <D.100156>:
  <D.100163>:
  goto <D.100164>;
  <D.100149>:
  result.8 = operator new (48);
  try
    {
      Gio::Proxy::Proxy (result.8, object);
    }
  catch
    {
      operator delete (result.8);
    }
  result = result.8;
  <D.100164>:
  D.100165 = result != 0B;
  D.100166 = D.100165 & take_copy;
  if (D.100166 != 0) goto <D.100167>; else goto <D.100168>;
  <D.100167>:
  D.100169 = result->D.98394._vptr.Interface;
  D.100170 = D.100169 + 18446744073709551592;
  D.100171 = MEM[(long int *)D.100170];
  D.100172 = (sizetype) D.100171;
  D.100173 = result + D.100172;
  D.100169 = result->D.98394._vptr.Interface;
  D.100170 = D.100169 + 18446744073709551592;
  D.100171 = MEM[(long int *)D.100170];
  D.100172 = (sizetype) D.100171;
  D.100173 = result + D.100172;
  D.100174 = D.100173->_vptr.ObjectBase;
  D.100175 = D.100174 + 16;
  D.100176 = *D.100175;
  D.100169 = result->D.98394._vptr.Interface;
  D.100170 = D.100169 + 18446744073709551592;
  D.100171 = MEM[(long int *)D.100170];
  D.100172 = (sizetype) D.100171;
  D.100173 = result + D.100172;
  OBJ_TYPE_REF(D.100176;(const struct ObjectBase)D.100173->2) (D.100173);
  goto <D.100177>;
  <D.100168>:
  <D.100177>:
  D.100143 = result;
  return D.100143;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.100184;
  const char * iftmp.9;
  const char * D.100186;
  char D.100187;

  D.100186 = this->__name;
  D.100187 = *D.100186;
  if (D.100187 == 42) goto <D.100188>; else goto <D.100189>;
  <D.100188>:
  D.100186 = this->__name;
  iftmp.9 = D.100186 + 1;
  goto <D.100190>;
  <D.100189>:
  iftmp.9 = this->__name;
  <D.100190>:
  D.100184 = iftmp.9;
  return D.100184;
}


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


const Glib::Interface_Class& Gio::Proxy_Class::init() (struct Proxy_Class * const this)
{
  long unsigned int D.100192;
  long unsigned int D.100195;
  const struct Interface_Class & D.100197;

  D.100192 = this->D.98430.D.98416.gtype_;
  if (D.100192 == 0) goto <D.100193>; else goto <D.100194>;
  <D.100193>:
  this->D.98430.D.98416.class_init_func_ = iface_init_function;
  D.100195 = g_proxy_get_type ();
  this->D.98430.D.98416.gtype_ = D.100195;
  goto <D.100196>;
  <D.100194>:
  <D.100196>:
  D.100197 = &this->D.98430;
  return D.100197;
}


static void Gio::Proxy_Class::iface_init_function(void*, void*) (void * g_iface, void * D.99089)
{
  bool retval.10;
  int retval.11;
  long int D.100205;
  long int D.100206;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[64] = "static void Gio::Proxy_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.100202>; else goto <D.100203>;
        <D.100202>:
        _g_boolean_var_ = 1;
        goto <D.100204>;
        <D.100203>:
        _g_boolean_var_ = 0;
        <D.100204>:
        retval.11 = _g_boolean_var_;
      }
      D.100205 = (long int) retval.11;
      D.100206 = __builtin_expect (D.100205, 1);
      retval.10 = D.100206 != 0;
      if (retval.10 != 0) goto <D.100207>; else goto <D.100208>;
      <D.100207>:
      goto <D.100209>;
      <D.100208>:
      g_assertion_message_expr ("giomm", "proxy.cc", 114, &__PRETTY_FUNCTION__, "klass != 0");
      <D.100209>:
    }
  }
}


static Glib::ObjectBase* Gio::Proxy_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.100210;
  struct ObjectBase * iftmp.12;
  void * D.99102;
  void * D.100212;
  int (*__vtbl_ptr_type) () * D.100215;
  int (*__vtbl_ptr_type) () * D.100216;
  long int D.100217;
  sizetype D.100218;

  D.99102 = operator new (48);
  try
    {
      Gio::Proxy::Proxy (D.99102, object);
    }
  catch
    {
      operator delete (D.99102);
    }
  D.100212 = D.99102;
  if (D.100212 != 0B) goto <D.100213>; else goto <D.100214>;
  <D.100213>:
  D.100215 = MEM[(struct Proxy *)D.100212].D.98394._vptr.Interface;
  D.100216 = D.100215 + 18446744073709551592;
  D.100217 = MEM[(long int *)D.100216];
  D.100218 = (sizetype) D.100217;
  iftmp.12 = D.100212 + D.100218;
  goto <D.100219>;
  <D.100214>:
  iftmp.12 = 0B;
  <D.100219>:
  D.100210 = iftmp.12;
  return D.100210;
}


Gio::Proxy::Proxy() (struct Proxy * const this, const void * * __vtt_parm)
{
  struct trackable * D.100225;
  const void * * iftmp.13;
  struct ObjectBase * D.100233;
  const struct Interface_Class & D.100235;
  const void * * iftmp.14;
  struct Interface * D.100240;
  int (*__vtbl_ptr_type) () * iftmp.15;
  sizetype iftmp.16;
  int (*__vtbl_ptr_type) () * D.100248;
  int (*__vtbl_ptr_type) () * D.100249;
  long int D.100250;
  struct ObjectBase * D.100252;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * iftmp.18;
  const void * * iftmp.19;

  if (0 != 0) goto <D.100223>; else goto <D.100224>;
  <D.100223>:
  D.100225 = &this->D.98397;
  sigc::trackable::trackable (D.100225);
  goto <D.100226>;
  <D.100224>:
  <D.100226>:
  try
    {
      if (0 != 0) goto <D.100227>; else goto <D.100228>;
      <D.100227>:
      if (0 == 0) goto <D.100230>; else goto <D.100231>;
      <D.100230>:
      iftmp.13 = __vtt_parm + 32;
      goto <D.100232>;
      <D.100231>:
      iftmp.13 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100232>:
      D.100233 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100233, iftmp.13);
      goto <D.100234>;
      <D.100228>:
      <D.100234>:
      try
        {
          D.100235 = Gio::Proxy_Class::init (&proxy_class_);
          if (0 == 0) goto <D.100237>; else goto <D.100238>;
          <D.100237>:
          iftmp.14 = __vtt_parm + 8;
          goto <D.100239>;
          <D.100238>:
          iftmp.14 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100239>:
          D.100240 = &this->D.98394;
          Glib::Interface::Interface (D.100240, iftmp.14, D.100235);
          try
            {
              if (0 == 0) goto <D.100242>; else goto <D.100243>;
              <D.100242>:
              iftmp.15 = *__vtt_parm;
              goto <D.100244>;
              <D.100243>:
              iftmp.15 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100244>:
              this->D.98394._vptr.Interface = iftmp.15;
              if (0 == 0) goto <D.100246>; else goto <D.100247>;
              <D.100246>:
              D.100248 = this->D.98394._vptr.Interface;
              D.100249 = D.100248 + 18446744073709551592;
              D.100250 = MEM[(long int *)D.100249];
              iftmp.16 = (sizetype) D.100250;
              goto <D.100251>;
              <D.100247>:
              iftmp.16 = 8;
              <D.100251>:
              D.100252 = this + iftmp.16;
              if (0 == 0) goto <D.100254>; else goto <D.100255>;
              <D.100254>:
              iftmp.17 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100256>;
              <D.100255>:
              iftmp.17 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100256>:
              D.100252->_vptr.ObjectBase = iftmp.17;
            }
          catch
            {
              if (0 == 0) goto <D.100258>; else goto <D.100259>;
              <D.100258>:
              iftmp.18 = __vtt_parm + 8;
              goto <D.100260>;
              <D.100259>:
              iftmp.18 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100260>:
              D.100240 = &this->D.98394;
              Glib::Interface::~Interface (D.100240, iftmp.18);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100261>; else goto <D.100262>;
          <D.100261>:
          if (0 == 0) goto <D.100264>; else goto <D.100265>;
          <D.100264>:
          iftmp.19 = __vtt_parm + 32;
          goto <D.100266>;
          <D.100265>:
          iftmp.19 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100266>:
          D.100233 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100233, iftmp.19);
          goto <D.100267>;
          <D.100262>:
          <D.100267>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100268>; else goto <D.100269>;
      <D.100268>:
      D.100225 = &this->D.98397;
      sigc::trackable::~trackable (D.100225);
      goto <D.100270>;
      <D.100269>:
      <D.100270>:
    }
}


Gio::Proxy::Proxy() (struct Proxy * const this)
{
  struct trackable * D.100276;
  const void * * iftmp.20;
  struct ObjectBase * D.100284;
  const struct Interface_Class & D.100286;
  const void * * iftmp.21;
  struct Interface * D.100291;
  int (*__vtbl_ptr_type) () * iftmp.22;
  const void * * D.100295;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.100300;
  int (*__vtbl_ptr_type) () * D.100301;
  long int D.100302;
  struct ObjectBase * D.100304;
  int (*__vtbl_ptr_type) () * iftmp.24;
  const void * * iftmp.25;
  const void * * iftmp.26;

  if (1 != 0) goto <D.100274>; else goto <D.100275>;
  <D.100274>:
  D.100276 = &this->D.98397;
  sigc::trackable::trackable (D.100276);
  goto <D.100277>;
  <D.100275>:
  <D.100277>:
  try
    {
      if (1 != 0) goto <D.100278>; else goto <D.100279>;
      <D.100278>:
      if (1 == 0) goto <D.100281>; else goto <D.100282>;
      <D.100281>:
      iftmp.20 = 32B;
      goto <D.100283>;
      <D.100282>:
      iftmp.20 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100283>:
      D.100284 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100284, iftmp.20);
      goto <D.100285>;
      <D.100279>:
      <D.100285>:
      try
        {
          D.100286 = Gio::Proxy_Class::init (&proxy_class_);
          if (1 == 0) goto <D.100288>; else goto <D.100289>;
          <D.100288>:
          iftmp.21 = 8B;
          goto <D.100290>;
          <D.100289>:
          iftmp.21 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100290>:
          D.100291 = &this->D.98394;
          Glib::Interface::Interface (D.100291, iftmp.21, D.100286);
          try
            {
              if (1 == 0) goto <D.100293>; else goto <D.100294>;
              <D.100293>:
              D.100295 = 0B;
              iftmp.22 = *D.100295;
              goto <D.100296>;
              <D.100294>:
              iftmp.22 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100296>:
              this->D.98394._vptr.Interface = iftmp.22;
              if (1 == 0) goto <D.100298>; else goto <D.100299>;
              <D.100298>:
              D.100300 = this->D.98394._vptr.Interface;
              D.100301 = D.100300 + 18446744073709551592;
              D.100302 = MEM[(long int *)D.100301];
              iftmp.23 = (sizetype) D.100302;
              goto <D.100303>;
              <D.100299>:
              iftmp.23 = 8;
              <D.100303>:
              D.100304 = this + iftmp.23;
              if (1 == 0) goto <D.100306>; else goto <D.100307>;
              <D.100306>:
              iftmp.24 = MEM[(const void * *)0B + 24B];
              goto <D.100308>;
              <D.100307>:
              iftmp.24 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100308>:
              D.100304->_vptr.ObjectBase = iftmp.24;
            }
          catch
            {
              if (1 == 0) goto <D.100310>; else goto <D.100311>;
              <D.100310>:
              iftmp.25 = 8B;
              goto <D.100312>;
              <D.100311>:
              iftmp.25 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100312>:
              D.100291 = &this->D.98394;
              Glib::Interface::~Interface (D.100291, iftmp.25);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100313>; else goto <D.100314>;
          <D.100313>:
          if (1 == 0) goto <D.100316>; else goto <D.100317>;
          <D.100316>:
          iftmp.26 = 32B;
          goto <D.100318>;
          <D.100317>:
          iftmp.26 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100318>:
          D.100284 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100284, iftmp.26);
          goto <D.100319>;
          <D.100314>:
          <D.100319>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100320>; else goto <D.100321>;
      <D.100320>:
      D.100276 = &this->D.98397;
      sigc::trackable::~trackable (D.100276);
      goto <D.100322>;
      <D.100321>:
      <D.100322>:
    }
}


Gio::Proxy::Proxy(GProxy*) (struct Proxy * const this, const void * * __vtt_parm, struct GProxy * castitem)
{
  struct trackable * D.100328;
  const void * * iftmp.27;
  struct ObjectBase * D.100336;
  const void * * iftmp.28;
  struct Interface * D.100342;
  int (*__vtbl_ptr_type) () * iftmp.29;
  sizetype iftmp.30;
  int (*__vtbl_ptr_type) () * D.100350;
  int (*__vtbl_ptr_type) () * D.100351;
  long int D.100352;
  struct ObjectBase * D.100354;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * iftmp.32;
  const void * * iftmp.33;

  if (0 != 0) goto <D.100326>; else goto <D.100327>;
  <D.100326>:
  D.100328 = &this->D.98397;
  sigc::trackable::trackable (D.100328);
  goto <D.100329>;
  <D.100327>:
  <D.100329>:
  try
    {
      if (0 != 0) goto <D.100330>; else goto <D.100331>;
      <D.100330>:
      if (0 == 0) goto <D.100333>; else goto <D.100334>;
      <D.100333>:
      iftmp.27 = __vtt_parm + 32;
      goto <D.100335>;
      <D.100334>:
      iftmp.27 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100335>:
      D.100336 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100336, iftmp.27);
      goto <D.100337>;
      <D.100331>:
      <D.100337>:
      try
        {
          if (0 == 0) goto <D.100339>; else goto <D.100340>;
          <D.100339>:
          iftmp.28 = __vtt_parm + 8;
          goto <D.100341>;
          <D.100340>:
          iftmp.28 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100341>:
          D.100342 = &this->D.98394;
          Glib::Interface::Interface (D.100342, iftmp.28, castitem);
          try
            {
              if (0 == 0) goto <D.100344>; else goto <D.100345>;
              <D.100344>:
              iftmp.29 = *__vtt_parm;
              goto <D.100346>;
              <D.100345>:
              iftmp.29 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100346>:
              this->D.98394._vptr.Interface = iftmp.29;
              if (0 == 0) goto <D.100348>; else goto <D.100349>;
              <D.100348>:
              D.100350 = this->D.98394._vptr.Interface;
              D.100351 = D.100350 + 18446744073709551592;
              D.100352 = MEM[(long int *)D.100351];
              iftmp.30 = (sizetype) D.100352;
              goto <D.100353>;
              <D.100349>:
              iftmp.30 = 8;
              <D.100353>:
              D.100354 = this + iftmp.30;
              if (0 == 0) goto <D.100356>; else goto <D.100357>;
              <D.100356>:
              iftmp.31 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100358>;
              <D.100357>:
              iftmp.31 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100358>:
              D.100354->_vptr.ObjectBase = iftmp.31;
            }
          catch
            {
              if (0 == 0) goto <D.100360>; else goto <D.100361>;
              <D.100360>:
              iftmp.32 = __vtt_parm + 8;
              goto <D.100362>;
              <D.100361>:
              iftmp.32 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100362>:
              D.100342 = &this->D.98394;
              Glib::Interface::~Interface (D.100342, iftmp.32);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100363>; else goto <D.100364>;
          <D.100363>:
          if (0 == 0) goto <D.100366>; else goto <D.100367>;
          <D.100366>:
          iftmp.33 = __vtt_parm + 32;
          goto <D.100368>;
          <D.100367>:
          iftmp.33 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100368>:
          D.100336 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100336, iftmp.33);
          goto <D.100369>;
          <D.100364>:
          <D.100369>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100370>; else goto <D.100371>;
      <D.100370>:
      D.100328 = &this->D.98397;
      sigc::trackable::~trackable (D.100328);
      goto <D.100372>;
      <D.100371>:
      <D.100372>:
    }
}


Gio::Proxy::Proxy(GProxy*) (struct Proxy * const this, struct GProxy * castitem)
{
  struct trackable * D.100377;
  const void * * iftmp.34;
  struct ObjectBase * D.100385;
  const void * * iftmp.35;
  struct Interface * D.100391;
  int (*__vtbl_ptr_type) () * iftmp.36;
  const void * * D.100395;
  sizetype iftmp.37;
  int (*__vtbl_ptr_type) () * D.100400;
  int (*__vtbl_ptr_type) () * D.100401;
  long int D.100402;
  struct ObjectBase * D.100404;
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * iftmp.39;
  const void * * iftmp.40;

  if (1 != 0) goto <D.100375>; else goto <D.100376>;
  <D.100375>:
  D.100377 = &this->D.98397;
  sigc::trackable::trackable (D.100377);
  goto <D.100378>;
  <D.100376>:
  <D.100378>:
  try
    {
      if (1 != 0) goto <D.100379>; else goto <D.100380>;
      <D.100379>:
      if (1 == 0) goto <D.100382>; else goto <D.100383>;
      <D.100382>:
      iftmp.34 = 32B;
      goto <D.100384>;
      <D.100383>:
      iftmp.34 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100384>:
      D.100385 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100385, iftmp.34);
      goto <D.100386>;
      <D.100380>:
      <D.100386>:
      try
        {
          if (1 == 0) goto <D.100388>; else goto <D.100389>;
          <D.100388>:
          iftmp.35 = 8B;
          goto <D.100390>;
          <D.100389>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100390>:
          D.100391 = &this->D.98394;
          Glib::Interface::Interface (D.100391, iftmp.35, castitem);
          try
            {
              if (1 == 0) goto <D.100393>; else goto <D.100394>;
              <D.100393>:
              D.100395 = 0B;
              iftmp.36 = *D.100395;
              goto <D.100396>;
              <D.100394>:
              iftmp.36 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100396>:
              this->D.98394._vptr.Interface = iftmp.36;
              if (1 == 0) goto <D.100398>; else goto <D.100399>;
              <D.100398>:
              D.100400 = this->D.98394._vptr.Interface;
              D.100401 = D.100400 + 18446744073709551592;
              D.100402 = MEM[(long int *)D.100401];
              iftmp.37 = (sizetype) D.100402;
              goto <D.100403>;
              <D.100399>:
              iftmp.37 = 8;
              <D.100403>:
              D.100404 = this + iftmp.37;
              if (1 == 0) goto <D.100406>; else goto <D.100407>;
              <D.100406>:
              iftmp.38 = MEM[(const void * *)0B + 24B];
              goto <D.100408>;
              <D.100407>:
              iftmp.38 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100408>:
              D.100404->_vptr.ObjectBase = iftmp.38;
            }
          catch
            {
              if (1 == 0) goto <D.100410>; else goto <D.100411>;
              <D.100410>:
              iftmp.39 = 8B;
              goto <D.100412>;
              <D.100411>:
              iftmp.39 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100412>:
              D.100391 = &this->D.98394;
              Glib::Interface::~Interface (D.100391, iftmp.39);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100413>; else goto <D.100414>;
          <D.100413>:
          if (1 == 0) goto <D.100416>; else goto <D.100417>;
          <D.100416>:
          iftmp.40 = 32B;
          goto <D.100418>;
          <D.100417>:
          iftmp.40 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100418>:
          D.100385 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100385, iftmp.40);
          goto <D.100419>;
          <D.100414>:
          <D.100419>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100420>; else goto <D.100421>;
      <D.100420>:
      D.100377 = &this->D.98397;
      sigc::trackable::~trackable (D.100377);
      goto <D.100422>;
      <D.100421>:
      <D.100422>:
    }
}


Gio::Proxy::Proxy(const Glib::Interface_Class&) (struct Proxy * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.100427;
  const void * * iftmp.41;
  struct ObjectBase * D.100435;
  const void * * iftmp.42;
  struct Interface * D.100441;
  int (*__vtbl_ptr_type) () * iftmp.43;
  sizetype iftmp.44;
  int (*__vtbl_ptr_type) () * D.100449;
  int (*__vtbl_ptr_type) () * D.100450;
  long int D.100451;
  struct ObjectBase * D.100453;
  int (*__vtbl_ptr_type) () * iftmp.45;
  const void * * iftmp.46;
  const void * * iftmp.47;

  if (0 != 0) goto <D.100425>; else goto <D.100426>;
  <D.100425>:
  D.100427 = &this->D.98397;
  sigc::trackable::trackable (D.100427);
  goto <D.100428>;
  <D.100426>:
  <D.100428>:
  try
    {
      if (0 != 0) goto <D.100429>; else goto <D.100430>;
      <D.100429>:
      if (0 == 0) goto <D.100432>; else goto <D.100433>;
      <D.100432>:
      iftmp.41 = __vtt_parm + 32;
      goto <D.100434>;
      <D.100433>:
      iftmp.41 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100434>:
      D.100435 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100435, iftmp.41);
      goto <D.100436>;
      <D.100430>:
      <D.100436>:
      try
        {
          if (0 == 0) goto <D.100438>; else goto <D.100439>;
          <D.100438>:
          iftmp.42 = __vtt_parm + 8;
          goto <D.100440>;
          <D.100439>:
          iftmp.42 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100440>:
          D.100441 = &this->D.98394;
          Glib::Interface::Interface (D.100441, iftmp.42, interface_class);
          try
            {
              if (0 == 0) goto <D.100443>; else goto <D.100444>;
              <D.100443>:
              iftmp.43 = *__vtt_parm;
              goto <D.100445>;
              <D.100444>:
              iftmp.43 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100445>:
              this->D.98394._vptr.Interface = iftmp.43;
              if (0 == 0) goto <D.100447>; else goto <D.100448>;
              <D.100447>:
              D.100449 = this->D.98394._vptr.Interface;
              D.100450 = D.100449 + 18446744073709551592;
              D.100451 = MEM[(long int *)D.100450];
              iftmp.44 = (sizetype) D.100451;
              goto <D.100452>;
              <D.100448>:
              iftmp.44 = 8;
              <D.100452>:
              D.100453 = this + iftmp.44;
              if (0 == 0) goto <D.100455>; else goto <D.100456>;
              <D.100455>:
              iftmp.45 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100457>;
              <D.100456>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100457>:
              D.100453->_vptr.ObjectBase = iftmp.45;
            }
          catch
            {
              if (0 == 0) goto <D.100459>; else goto <D.100460>;
              <D.100459>:
              iftmp.46 = __vtt_parm + 8;
              goto <D.100461>;
              <D.100460>:
              iftmp.46 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100461>:
              D.100441 = &this->D.98394;
              Glib::Interface::~Interface (D.100441, iftmp.46);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100462>; else goto <D.100463>;
          <D.100462>:
          if (0 == 0) goto <D.100465>; else goto <D.100466>;
          <D.100465>:
          iftmp.47 = __vtt_parm + 32;
          goto <D.100467>;
          <D.100466>:
          iftmp.47 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100467>:
          D.100435 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100435, iftmp.47);
          goto <D.100468>;
          <D.100463>:
          <D.100468>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100469>; else goto <D.100470>;
      <D.100469>:
      D.100427 = &this->D.98397;
      sigc::trackable::~trackable (D.100427);
      goto <D.100471>;
      <D.100470>:
      <D.100471>:
    }
}


Gio::Proxy::Proxy(const Glib::Interface_Class&) (struct Proxy * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.100476;
  const void * * iftmp.48;
  struct ObjectBase * D.100484;
  const void * * iftmp.49;
  struct Interface * D.100490;
  int (*__vtbl_ptr_type) () * iftmp.50;
  const void * * D.100494;
  sizetype iftmp.51;
  int (*__vtbl_ptr_type) () * D.100499;
  int (*__vtbl_ptr_type) () * D.100500;
  long int D.100501;
  struct ObjectBase * D.100503;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * iftmp.53;
  const void * * iftmp.54;

  if (1 != 0) goto <D.100474>; else goto <D.100475>;
  <D.100474>:
  D.100476 = &this->D.98397;
  sigc::trackable::trackable (D.100476);
  goto <D.100477>;
  <D.100475>:
  <D.100477>:
  try
    {
      if (1 != 0) goto <D.100478>; else goto <D.100479>;
      <D.100478>:
      if (1 == 0) goto <D.100481>; else goto <D.100482>;
      <D.100481>:
      iftmp.48 = 32B;
      goto <D.100483>;
      <D.100482>:
      iftmp.48 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
      <D.100483>:
      D.100484 = &this->D.98396;
      Glib::ObjectBase::ObjectBase (D.100484, iftmp.48);
      goto <D.100485>;
      <D.100479>:
      <D.100485>:
      try
        {
          if (1 == 0) goto <D.100487>; else goto <D.100488>;
          <D.100487>:
          iftmp.49 = 8B;
          goto <D.100489>;
          <D.100488>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
          <D.100489>:
          D.100490 = &this->D.98394;
          Glib::Interface::Interface (D.100490, iftmp.49, interface_class);
          try
            {
              if (1 == 0) goto <D.100492>; else goto <D.100493>;
              <D.100492>:
              D.100494 = 0B;
              iftmp.50 = *D.100494;
              goto <D.100495>;
              <D.100493>:
              iftmp.50 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
              <D.100495>:
              this->D.98394._vptr.Interface = iftmp.50;
              if (1 == 0) goto <D.100497>; else goto <D.100498>;
              <D.100497>:
              D.100499 = this->D.98394._vptr.Interface;
              D.100500 = D.100499 + 18446744073709551592;
              D.100501 = MEM[(long int *)D.100500];
              iftmp.51 = (sizetype) D.100501;
              goto <D.100502>;
              <D.100498>:
              iftmp.51 = 8;
              <D.100502>:
              D.100503 = this + iftmp.51;
              if (1 == 0) goto <D.100505>; else goto <D.100506>;
              <D.100505>:
              iftmp.52 = MEM[(const void * *)0B + 24B];
              goto <D.100507>;
              <D.100506>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
              <D.100507>:
              D.100503->_vptr.ObjectBase = iftmp.52;
            }
          catch
            {
              if (1 == 0) goto <D.100509>; else goto <D.100510>;
              <D.100509>:
              iftmp.53 = 8B;
              goto <D.100511>;
              <D.100510>:
              iftmp.53 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
              <D.100511>:
              D.100490 = &this->D.98394;
              Glib::Interface::~Interface (D.100490, iftmp.53);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100512>; else goto <D.100513>;
          <D.100512>:
          if (1 == 0) goto <D.100515>; else goto <D.100516>;
          <D.100515>:
          iftmp.54 = 32B;
          goto <D.100517>;
          <D.100516>:
          iftmp.54 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
          <D.100517>:
          D.100484 = &this->D.98396;
          Glib::ObjectBase::~ObjectBase (D.100484, iftmp.54);
          goto <D.100518>;
          <D.100513>:
          <D.100518>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100519>; else goto <D.100520>;
      <D.100519>:
      D.100476 = &this->D.98397;
      sigc::trackable::~trackable (D.100476);
      goto <D.100521>;
      <D.100520>:
      <D.100521>:
    }
}


Gio::Proxy::~Proxy() (struct Proxy * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.55;
  sizetype iftmp.56;
  int (*__vtbl_ptr_type) () * D.100531;
  int (*__vtbl_ptr_type) () * D.100532;
  long int D.100533;
  struct ObjectBase * D.100535;
  int (*__vtbl_ptr_type) () * iftmp.57;
  const void * * iftmp.58;
  struct Interface * D.100544;
  int D.100545;
  const void * * iftmp.59;
  struct ObjectBase * D.100552;
  struct trackable * D.100556;
  int D.100558;

  {
    if (0 == 0) goto <D.100525>; else goto <D.100526>;
    <D.100525>:
    iftmp.55 = *__vtt_parm;
    goto <D.100527>;
    <D.100526>:
    iftmp.55 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
    <D.100527>:
    this->D.98394._vptr.Interface = iftmp.55;
    if (0 == 0) goto <D.100529>; else goto <D.100530>;
    <D.100529>:
    D.100531 = this->D.98394._vptr.Interface;
    D.100532 = D.100531 + 18446744073709551592;
    D.100533 = MEM[(long int *)D.100532];
    iftmp.56 = (sizetype) D.100533;
    goto <D.100534>;
    <D.100530>:
    iftmp.56 = 8;
    <D.100534>:
    D.100535 = this + iftmp.56;
    if (0 == 0) goto <D.100537>; else goto <D.100538>;
    <D.100537>:
    iftmp.57 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.100539>;
    <D.100538>:
    iftmp.57 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
    <D.100539>:
    D.100535->_vptr.ObjectBase = iftmp.57;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.100541>; else goto <D.100542>;
                    <D.100541>:
                    iftmp.58 = __vtt_parm + 8;
                    goto <D.100543>;
                    <D.100542>:
                    iftmp.58 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
                    <D.100543>:
                    D.100544 = &this->D.98394;
                    Glib::Interface::~Interface (D.100544, iftmp.58);
                  }
              }
            finally
              {
                D.100545 = 0;
                if (D.100545 != 0) goto <D.100546>; else goto <D.100547>;
                <D.100546>:
                if (0 == 0) goto <D.100549>; else goto <D.100550>;
                <D.100549>:
                iftmp.59 = __vtt_parm + 32;
                goto <D.100551>;
                <D.100550>:
                iftmp.59 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
                <D.100551>:
                D.100552 = &this->D.98396;
                Glib::ObjectBase::~ObjectBase (D.100552, iftmp.59);
                goto <D.100553>;
                <D.100547>:
                <D.100553>:
              }
          }
        finally
          {
            D.100545 = 0;
            if (D.100545 != 0) goto <D.100554>; else goto <D.100555>;
            <D.100554>:
            D.100556 = &this->D.98397;
            sigc::trackable::~trackable (D.100556);
            goto <D.100557>;
            <D.100555>:
            <D.100557>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99149>:
  D.100558 = 0;
  if (D.100558 != 0) goto <D.100559>; else goto <D.100560>;
  <D.100559>:
  operator delete (this);
  goto <D.100561>;
  <D.100560>:
  <D.100561>:
}


virtual Gio::Proxy::~Proxy() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.60;
  const void * * D.100577;
  sizetype iftmp.61;
  int (*__vtbl_ptr_type) () * D.100582;
  int (*__vtbl_ptr_type) () * D.100583;
  long int D.100584;
  struct ObjectBase * D.100586;
  int (*__vtbl_ptr_type) () * iftmp.62;
  const void * * iftmp.63;
  struct Interface * D.100595;
  int D.100596;
  const void * * iftmp.64;
  struct ObjectBase * D.100603;
  struct trackable * D.100607;
  int D.100609;

  {
    if (2 == 0) goto <D.100575>; else goto <D.100576>;
    <D.100575>:
    D.100577 = 0B;
    iftmp.60 = *D.100577;
    goto <D.100578>;
    <D.100576>:
    iftmp.60 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 32B];
    <D.100578>:
    this->D.98394._vptr.Interface = iftmp.60;
    if (2 == 0) goto <D.100580>; else goto <D.100581>;
    <D.100580>:
    D.100582 = this->D.98394._vptr.Interface;
    D.100583 = D.100582 + 18446744073709551592;
    D.100584 = MEM[(long int *)D.100583];
    iftmp.61 = (sizetype) D.100584;
    goto <D.100585>;
    <D.100581>:
    iftmp.61 = 8;
    <D.100585>:
    D.100586 = this + iftmp.61;
    if (2 == 0) goto <D.100588>; else goto <D.100589>;
    <D.100588>:
    iftmp.62 = MEM[(const void * *)0B + 24B];
    goto <D.100590>;
    <D.100589>:
    iftmp.62 = &MEM[(void *)&_ZTVN3Gio5ProxyE + 112B];
    <D.100590>:
    D.100586->_vptr.ObjectBase = iftmp.62;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.100592>; else goto <D.100593>;
                    <D.100592>:
                    iftmp.63 = 8B;
                    goto <D.100594>;
                    <D.100593>:
                    iftmp.63 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 8B];
                    <D.100594>:
                    D.100595 = &this->D.98394;
                    Glib::Interface::~Interface (D.100595, iftmp.63);
                  }
              }
            finally
              {
                D.100596 = 2;
                if (D.100596 != 0) goto <D.100597>; else goto <D.100598>;
                <D.100597>:
                if (2 == 0) goto <D.100600>; else goto <D.100601>;
                <D.100600>:
                iftmp.64 = 32B;
                goto <D.100602>;
                <D.100601>:
                iftmp.64 = &MEM[(void *)&_ZTTN3Gio5ProxyE + 32B];
                <D.100602>:
                D.100603 = &this->D.98396;
                Glib::ObjectBase::~ObjectBase (D.100603, iftmp.64);
                goto <D.100604>;
                <D.100598>:
                <D.100604>:
              }
          }
        finally
          {
            D.100596 = 2;
            if (D.100596 != 0) goto <D.100605>; else goto <D.100606>;
            <D.100605>:
            D.100607 = &this->D.98397;
            sigc::trackable::~trackable (D.100607);
            goto <D.100608>;
            <D.100606>:
            <D.100608>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99152>:
  D.100609 = 0;
  if (D.100609 != 0) goto <D.100610>; else goto <D.100611>;
  <D.100610>:
  operator delete (this);
  goto <D.100612>;
  <D.100611>:
  <D.100612>:
}


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


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

  D.100625 = Gio::Proxy_Class::init (&proxy_class_);
  Glib::Interface_Class::add_interface (D.100625, gtype_implementer);
}


static GType Gio::Proxy::get_type() ()
{
  GType D.100627;
  const struct Interface_Class & D.100628;
  const struct Class * D.100629;

  D.100628 = Gio::Proxy_Class::init (&proxy_class_);
  D.100629 = &D.100628->D.98416;
  D.100627 = Glib::Class::get_type (D.100629);
  return D.100627;
}


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

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


static GType Gio::Proxy::get_base_type() ()
{
  GType D.100634;

  D.100634 = g_proxy_get_type ();
  return D.100634;
}


static Glib::RefPtr<Gio::Proxy> Gio::Proxy::get_default_for_protocol(const Glib::ustring&) (const struct ustring & protocol)
{
  const char * D.100638;
  struct GProxy * D.100639;

  D.100638 = Glib::ustring::c_str (protocol);
  D.100639 = g_proxy_get_default_for_protocol (D.100638);
  *<retval> = Glib::wrap (D.100639, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Gio::IOStream> Gio::Proxy::connect(const Glib::RefPtr<Gio::IOStream>&, const Glib::RefPtr<const Gio::ProxyAddress>&, const Glib::RefPtr<Gio::Cancellable>&) (struct Proxy * const this, const struct RefPtr & connection, const struct RefPtr & proxy_address, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.100644;
  const struct BaseObjectType * D.100645;
  struct BaseObjectType * D.100646;
  struct GProxy * D.100647;
  struct GIOStream * D.100648;
  struct GError * gerror.65;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.100644 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.100645 = Glib::unwrap<Gio::ProxyAddress> (proxy_address);
      D.100646 = Glib::unwrap<Gio::IOStream> (connection);
      D.100647 = Gio::Proxy::gobj (this);
      D.100648 = g_proxy_connect (D.100647, D.100646, D.100645, D.100644, &gerror);
      *<retval> = Glib::wrap (D.100648, 0); [return slot optimization]
      try
        {
          gerror.65 = gerror;
          if (gerror.65 != 0B) goto <D.100650>; else goto <D.100651>;
          <D.100650>:
          gerror.65 = gerror;
          Glib::Error::throw_exception (gerror.65);
          <D.100651>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::IOStream>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::IOStream] (struct RefPtr * const this)
{
  struct IOStream * D.100660;
  int (*__vtbl_ptr_type) () * D.100663;
  int (*__vtbl_ptr_type) () * D.100664;
  long int D.100665;
  sizetype D.100666;
  struct ObjectBase * D.100667;
  int (*__vtbl_ptr_type) () * D.100668;
  int (*__vtbl_ptr_type) () * D.100669;
  int (*__vtbl_ptr_type) () D.100670;

  {
    try
      {
        D.100660 = this->pCppObject_;
        if (D.100660 != 0B) goto <D.100661>; else goto <D.100662>;
        <D.100661>:
        D.100660 = this->pCppObject_;
        D.100660 = this->pCppObject_;
        D.100663 = D.100660->D.98257._vptr.Object;
        D.100664 = D.100663 + 18446744073709551592;
        D.100665 = MEM[(long int *)D.100664];
        D.100666 = (sizetype) D.100665;
        D.100667 = D.100660 + D.100666;
        D.100660 = this->pCppObject_;
        D.100660 = this->pCppObject_;
        D.100663 = D.100660->D.98257._vptr.Object;
        D.100664 = D.100663 + 18446744073709551592;
        D.100665 = MEM[(long int *)D.100664];
        D.100666 = (sizetype) D.100665;
        D.100667 = D.100660 + D.100666;
        D.100668 = D.100667->_vptr.ObjectBase;
        D.100669 = D.100668 + 24;
        D.100670 = *D.100669;
        D.100660 = this->pCppObject_;
        D.100660 = this->pCppObject_;
        D.100663 = D.100660->D.98257._vptr.Object;
        D.100664 = D.100663 + 18446744073709551592;
        D.100665 = MEM[(long int *)D.100664];
        D.100666 = (sizetype) D.100665;
        D.100667 = D.100660 + D.100666;
        OBJ_TYPE_REF(D.100670;(const struct ObjectBase)D.100667->3) (D.100667);
        goto <D.100671>;
        <D.100662>:
        <D.100671>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99722>:
}


Glib::RefPtr<Gio::IOStream> Gio::Proxy::connect_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct Proxy * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.100674;
  struct GProxy * D.100675;
  struct GIOStream * D.100676;
  struct GError * gerror.66;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.100674 = Glib::unwrap<Gio::AsyncResult> (result);
      D.100675 = Gio::Proxy::gobj (this);
      D.100676 = g_proxy_connect_finish (D.100675, D.100674, &gerror);
      *<retval> = Glib::wrap (D.100676, 0); [return slot optimization]
      try
        {
          gerror.66 = gerror;
          if (gerror.66 != 0B) goto <D.100678>; else goto <D.100679>;
          <D.100678>:
          gerror.66 = gerror;
          Glib::Error::throw_exception (gerror.66);
          <D.100679>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::IOStream>::~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.100686;
  struct BaseObjectType * iftmp.67;
  bool D.100688;
  struct AsyncResult * D.100691;

  D.100688 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.100688 != 0) goto <D.100689>; else goto <D.100690>;
  <D.100689>:
  D.100691 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.67 = Gio::AsyncResult::gobj (D.100691);
  goto <D.100692>;
  <D.100690>:
  iftmp.67 = 0B;
  <D.100692>:
  D.100686 = iftmp.67;
  return D.100686;
}


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

  D.100695 = this->pCppObject_;
  D.100694 = D.100695 != 0B;
  return D.100694;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.100699;
  int (*__vtbl_ptr_type) () * D.100700;
  int (*__vtbl_ptr_type) () * D.100701;
  long int D.100702;
  sizetype D.100703;
  struct ObjectBase * D.100704;

  D.100700 = this->D.86030._vptr.Interface;
  D.100701 = D.100700 + 18446744073709551592;
  D.100702 = MEM[(long int *)D.100701];
  D.100703 = (sizetype) D.100702;
  D.100704 = this + D.100703;
  D.100699 = D.100704->gobject_;
  return D.100699;
}


bool Gio::Proxy::supports_hostname() const (const struct Proxy * const this)
{
  bool D.100706;
  const struct GProxy * D.100707;
  int D.100708;

  D.100707 = Gio::Proxy::gobj (this);
  D.100708 = g_proxy_supports_hostname (D.100707);
  D.100706 = D.100708 != 0;
  return D.100706;
}


const GProxy* Gio::Proxy::gobj() const (const struct Proxy * const this)
{
  const struct GProxy * D.100711;
  int (*__vtbl_ptr_type) () * D.100712;
  int (*__vtbl_ptr_type) () * D.100713;
  long int D.100714;
  sizetype D.100715;
  const struct ObjectBase * D.100716;

  D.100712 = this->D.98394._vptr.Interface;
  D.100713 = D.100712 + 18446744073709551592;
  D.100714 = MEM[(long int *)D.100713];
  D.100715 = (sizetype) D.100714;
  D.100716 = this + D.100715;
  D.100711 = D.100716->gobject_;
  return D.100711;
}