void Gio::SocketClient::connect_async(const Glib::RefPtr<Gio::SocketConnectable>&, const Glib::RefPtr<Gio::Cancellable>&, const SlotAsyncReady&) (struct SocketClient * const this, const struct RefPtr & connectable, const struct RefPtr & cancellable, const struct SlotAsyncReady & slot)
{
  void * slot_copy.0;
  struct BaseObjectType * D.102810;
  struct SocketConnectable * D.102811;
  struct GSocketConnectable * D.102812;
  struct GSocketClient * D.102813;
  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.102810 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.102811 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (connectable);
  D.102812 = Gio::SocketConnectable::gobj (D.102811);
  D.102813 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_async (D.102813, D.102812, D.102810, 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.102818;

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

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


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.102819;
  struct slot_base * D.102820;

  D.102819 = &src->D.99524;
  D.102820 = &this->D.99524;
  sigc::slot_base::slot_base (D.102820, D.102819);
  try
    {

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


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.102821;
  struct BaseObjectType * iftmp.1;
  bool D.102823;
  struct Cancellable * D.102826;

  D.102823 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.102823 != 0) goto <D.102824>; else goto <D.102825>;
  <D.102824>:
  D.102826 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.102826);
  goto <D.102827>;
  <D.102825>:
  iftmp.1 = 0B;
  <D.102827>:
  D.102821 = iftmp.1;
  return D.102821;
}


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

  D.102830 = this->pCppObject_;
  D.102829 = D.102830 != 0B;
  return D.102829;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.102834;
  int (*__vtbl_ptr_type) () * D.102835;
  int (*__vtbl_ptr_type) () * D.102836;
  long int D.102837;
  sizetype D.102838;
  struct ObjectBase * D.102839;

  D.102835 = this->D.86174._vptr.Object;
  D.102836 = D.102835 + 18446744073709551592;
  D.102837 = MEM[(long int *)D.102836];
  D.102838 = (sizetype) D.102837;
  D.102839 = this + D.102838;
  D.102834 = D.102839->gobject_;
  return D.102834;
}


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

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


GSocketConnectable* Gio::SocketConnectable::gobj() (struct SocketConnectable * const this)
{
  struct GSocketConnectable * D.102843;
  int (*__vtbl_ptr_type) () * D.102844;
  int (*__vtbl_ptr_type) () * D.102845;
  long int D.102846;
  sizetype D.102847;
  struct ObjectBase * D.102848;

  D.102844 = this->D.86415._vptr.Interface;
  D.102845 = D.102844 + 18446744073709551592;
  D.102846 = MEM[(long int *)D.102845];
  D.102847 = (sizetype) D.102846;
  D.102848 = this + D.102847;
  D.102843 = D.102848->gobject_;
  return D.102843;
}


GSocketClient* Gio::SocketClient::gobj() (struct SocketClient * const this)
{
  struct GSocketClient * D.102850;
  int (*__vtbl_ptr_type) () * D.102851;
  int (*__vtbl_ptr_type) () * D.102852;
  long int D.102853;
  sizetype D.102854;
  struct ObjectBase * D.102855;

  D.102851 = this->D.99412._vptr.Object;
  D.102852 = D.102851 + 18446744073709551592;
  D.102853 = MEM[(long int *)D.102852];
  D.102854 = (sizetype) D.102853;
  D.102855 = this + D.102854;
  D.102850 = D.102855->gobject_;
  return D.102850;
}


void Gio::SocketClient::connect_async(const Glib::RefPtr<Gio::SocketConnectable>&, const SlotAsyncReady&) (struct SocketClient * const this, const struct RefPtr & connectable, const struct SlotAsyncReady & slot)
{
  void * slot_copy.2;
  struct SocketConnectable * D.102857;
  struct GSocketConnectable * D.102858;
  struct GSocketClient * D.102859;
  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.102857 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (connectable);
  D.102858 = Gio::SocketConnectable::gobj (D.102857);
  D.102859 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_async (D.102859, D.102858, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_host_async(const Glib::ustring&, guint16, const Glib::RefPtr<Gio::Cancellable>&, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & host_and_port, guint16 default_port, const struct RefPtr & cancellable, const struct SlotAsyncReady & slot)
{
  void * slot_copy.3;
  struct BaseObjectType * D.102862;
  int D.102863;
  const char * D.102864;
  struct GSocketClient * D.102865;
  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.102862 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.102863 = (int) default_port;
  D.102864 = Glib::ustring::c_str (host_and_port);
  D.102865 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_host_async (D.102865, D.102864, D.102863, D.102862, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_host_async(const Glib::ustring&, guint16, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & host_and_port, guint16 default_port, const struct SlotAsyncReady & slot)
{
  void * slot_copy.4;
  int D.102870;
  const char * D.102871;
  struct GSocketClient * D.102872;
  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.102870 = (int) default_port;
  D.102871 = Glib::ustring::c_str (host_and_port);
  D.102872 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_host_async (D.102872, D.102871, D.102870, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_service_async(const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & domain, const struct ustring & service, const struct RefPtr & cancellable, const struct SlotAsyncReady & slot)
{
  void * slot_copy.5;
  struct BaseObjectType * D.102876;
  const char * D.102877;
  const char * D.102878;
  struct GSocketClient * D.102879;
  struct SlotAsyncReady * slot_copy;

  slot_copy.5 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.5, slot);
    }
  catch
    {
      operator delete (slot_copy.5);
    }
  slot_copy = slot_copy.5;
  D.102876 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.102877 = Glib::ustring::c_str (service);
  D.102878 = Glib::ustring::c_str (domain);
  D.102879 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_service_async (D.102879, D.102878, D.102877, D.102876, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_service_async(const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & domain, const struct ustring & service, const struct SlotAsyncReady & slot)
{
  void * slot_copy.6;
  const char * D.102885;
  const char * D.102886;
  struct GSocketClient * D.102887;
  struct SlotAsyncReady * slot_copy;

  slot_copy.6 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.6, slot);
    }
  catch
    {
      operator delete (slot_copy.6);
    }
  slot_copy = slot_copy.6;
  D.102885 = Glib::ustring::c_str (service);
  D.102886 = Glib::ustring::c_str (domain);
  D.102887 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_service_async (D.102887, D.102886, D.102885, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_uri_async(const Glib::ustring&, guint16, const Glib::RefPtr<Gio::Cancellable>&, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & uri, guint16 default_port, const struct RefPtr & cancellable, const struct SlotAsyncReady & slot)
{
  void * slot_copy.7;
  struct BaseObjectType * D.102892;
  int D.102893;
  const char * D.102894;
  struct GSocketClient * D.102895;
  struct SlotAsyncReady * slot_copy;

  slot_copy.7 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.7, slot);
    }
  catch
    {
      operator delete (slot_copy.7);
    }
  slot_copy = slot_copy.7;
  D.102892 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.102893 = (int) default_port;
  D.102894 = Glib::ustring::c_str (uri);
  D.102895 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_uri_async (D.102895, D.102894, D.102893, D.102892, SignalProxy_async_callback, slot_copy);
}


void Gio::SocketClient::connect_to_uri_async(const Glib::ustring&, guint16, const SlotAsyncReady&) (struct SocketClient * const this, const struct ustring & uri, guint16 default_port, const struct SlotAsyncReady & slot)
{
  void * slot_copy.8;
  int D.102900;
  const char * D.102901;
  struct GSocketClient * D.102902;
  struct SlotAsyncReady * slot_copy;

  slot_copy.8 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.8, slot);
    }
  catch
    {
      operator delete (slot_copy.8);
    }
  slot_copy = slot_copy.8;
  D.102900 = (int) default_port;
  D.102901 = Glib::ustring::c_str (uri);
  D.102902 = Gio::SocketClient::gobj (this);
  g_socket_client_connect_to_uri_async (D.102902, D.102901, D.102900, 0B, SignalProxy_async_callback, slot_copy);
}


static GType Glib::Value<Gio::SocketClientEvent>::value_type() ()
{
  GType D.102906;

  D.102906 = g_socket_client_event_get_type ();
  return D.102906;
}


Glib::RefPtr<Gio::SocketClient> Glib::wrap(GSocketClient*, bool) (struct GSocketClient * object, bool take_copy)
{
  struct SocketClient * iftmp.9;
  int D.102911;
  struct ObjectBase * D.102912;

  D.102911 = (int) take_copy;
  D.102912 = Glib::wrap_auto (object, D.102911);
  if (D.102912 == 0B) goto <D.102913>; else goto <D.102914>;
  <D.102913>:
  iftmp.9 = 0B;
  goto <D.102915>;
  <D.102914>:
  iftmp.9 = __dynamic_cast (D.102912, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio12SocketClientE, -1);
  <D.102915>:
  Glib::RefPtr<Gio::SocketClient>::RefPtr (<retval>, iftmp.9);
  return <retval>;
}


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


const Glib::Class& Gio::SocketClient_Class::init() (struct SocketClient_Class * const this)
{
  long unsigned int D.102918;
  long unsigned int D.102921;
  struct Class * D.102922;
  const struct Class & D.102924;

  D.102918 = this->D.99454.gtype_;
  if (D.102918 == 0) goto <D.102919>; else goto <D.102920>;
  <D.102919>:
  this->D.99454.class_init_func_ = class_init_function;
  D.102921 = g_socket_client_get_type ();
  D.102922 = &this->D.99454;
  Glib::Class::register_derived_type (D.102922, D.102921);
  goto <D.102923>;
  <D.102920>:
  <D.102923>:
  D.102924 = &this->D.99454;
  return D.102924;
}


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

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
}


static Glib::ObjectBase* Gio::SocketClient_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.102927;
  struct ObjectBase * iftmp.10;
  void * D.100301;
  void * D.102929;
  int (*__vtbl_ptr_type) () * D.102932;
  int (*__vtbl_ptr_type) () * D.102933;
  long int D.102934;
  sizetype D.102935;

  D.100301 = operator new (48);
  try
    {
      Gio::SocketClient::SocketClient (D.100301, object);
    }
  catch
    {
      operator delete (D.100301);
    }
  D.102929 = D.100301;
  if (D.102929 != 0B) goto <D.102930>; else goto <D.102931>;
  <D.102930>:
  D.102932 = MEM[(struct SocketClient *)D.102929].D.99412._vptr.Object;
  D.102933 = D.102932 + 18446744073709551592;
  D.102934 = MEM[(long int *)D.102933];
  D.102935 = (sizetype) D.102934;
  iftmp.10 = D.102929 + D.102935;
  goto <D.102936>;
  <D.102931>:
  iftmp.10 = 0B;
  <D.102936>:
  D.102927 = iftmp.10;
  return D.102927;
}


GSocketClient* Gio::SocketClient::gobj_copy() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.102940;
  int (*__vtbl_ptr_type) () * D.102941;
  long int D.102942;
  sizetype D.102943;
  struct ObjectBase * D.102944;
  int (*__vtbl_ptr_type) () * D.102945;
  int (*__vtbl_ptr_type) () * D.102946;
  int (*__vtbl_ptr_type) () D.102947;
  struct GSocketClient * D.102948;

  D.102940 = this->D.99412._vptr.Object;
  D.102941 = D.102940 + 18446744073709551592;
  D.102942 = MEM[(long int *)D.102941];
  D.102943 = (sizetype) D.102942;
  D.102944 = this + D.102943;
  D.102940 = this->D.99412._vptr.Object;
  D.102941 = D.102940 + 18446744073709551592;
  D.102942 = MEM[(long int *)D.102941];
  D.102943 = (sizetype) D.102942;
  D.102944 = this + D.102943;
  D.102945 = D.102944->_vptr.ObjectBase;
  D.102946 = D.102945 + 16;
  D.102947 = *D.102946;
  D.102940 = this->D.99412._vptr.Object;
  D.102941 = D.102940 + 18446744073709551592;
  D.102942 = MEM[(long int *)D.102941];
  D.102943 = (sizetype) D.102942;
  D.102944 = this + D.102943;
  OBJ_TYPE_REF(D.102947;(const struct ObjectBase)D.102944->2) (D.102944);
  D.102948 = Gio::SocketClient::gobj (this);
  return D.102948;
}


Gio::SocketClient::SocketClient(const Glib::ConstructParams&) (struct SocketClient * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.102952;
  const void * * iftmp.11;
  struct ObjectBase * D.102960;
  const void * * iftmp.12;
  struct Object * D.102966;
  int (*__vtbl_ptr_type) () * iftmp.13;
  sizetype iftmp.14;
  int (*__vtbl_ptr_type) () * D.102974;
  int (*__vtbl_ptr_type) () * D.102975;
  long int D.102976;
  struct ObjectBase * D.102978;
  int (*__vtbl_ptr_type) () * iftmp.15;
  const void * * iftmp.16;
  const void * * iftmp.17;

  if (0 != 0) goto <D.102950>; else goto <D.102951>;
  <D.102950>:
  D.102952 = &this->D.99415;
  sigc::trackable::trackable (D.102952);
  goto <D.102953>;
  <D.102951>:
  <D.102953>:
  try
    {
      if (0 != 0) goto <D.102954>; else goto <D.102955>;
      <D.102954>:
      if (0 == 0) goto <D.102957>; else goto <D.102958>;
      <D.102957>:
      iftmp.11 = __vtt_parm + 32;
      goto <D.102959>;
      <D.102958>:
      iftmp.11 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.102959>:
      D.102960 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.102960, iftmp.11);
      goto <D.102961>;
      <D.102955>:
      <D.102961>:
      try
        {
          if (0 == 0) goto <D.102963>; else goto <D.102964>;
          <D.102963>:
          iftmp.12 = __vtt_parm + 8;
          goto <D.102965>;
          <D.102964>:
          iftmp.12 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
          <D.102965>:
          D.102966 = &this->D.99412;
          Glib::Object::Object (D.102966, iftmp.12, construct_params);
          try
            {
              if (0 == 0) goto <D.102968>; else goto <D.102969>;
              <D.102968>:
              iftmp.13 = *__vtt_parm;
              goto <D.102970>;
              <D.102969>:
              iftmp.13 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.102970>:
              this->D.99412._vptr.Object = iftmp.13;
              if (0 == 0) goto <D.102972>; else goto <D.102973>;
              <D.102972>:
              D.102974 = this->D.99412._vptr.Object;
              D.102975 = D.102974 + 18446744073709551592;
              D.102976 = MEM[(long int *)D.102975];
              iftmp.14 = (sizetype) D.102976;
              goto <D.102977>;
              <D.102973>:
              iftmp.14 = 8;
              <D.102977>:
              D.102978 = this + iftmp.14;
              if (0 == 0) goto <D.102980>; else goto <D.102981>;
              <D.102980>:
              iftmp.15 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.102982>;
              <D.102981>:
              iftmp.15 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.102982>:
              D.102978->_vptr.ObjectBase = iftmp.15;
            }
          catch
            {
              if (0 == 0) goto <D.102984>; else goto <D.102985>;
              <D.102984>:
              iftmp.16 = __vtt_parm + 8;
              goto <D.102986>;
              <D.102985>:
              iftmp.16 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.102986>:
              D.102966 = &this->D.99412;
              Glib::Object::~Object (D.102966, iftmp.16);
            }
        }
      catch
        {
          if (0 != 0) goto <D.102987>; else goto <D.102988>;
          <D.102987>:
          if (0 == 0) goto <D.102990>; else goto <D.102991>;
          <D.102990>:
          iftmp.17 = __vtt_parm + 32;
          goto <D.102992>;
          <D.102991>:
          iftmp.17 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.102992>:
          D.102960 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.102960, iftmp.17);
          goto <D.102993>;
          <D.102988>:
          <D.102993>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.102994>; else goto <D.102995>;
      <D.102994>:
      D.102952 = &this->D.99415;
      sigc::trackable::~trackable (D.102952);
      goto <D.102996>;
      <D.102995>:
      <D.102996>:
    }
}


Gio::SocketClient::SocketClient(const Glib::ConstructParams&) (struct SocketClient * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.103001;
  const void * * iftmp.18;
  struct ObjectBase * D.103009;
  const void * * iftmp.19;
  struct Object * D.103015;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * D.103019;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.103024;
  int (*__vtbl_ptr_type) () * D.103025;
  long int D.103026;
  struct ObjectBase * D.103028;
  int (*__vtbl_ptr_type) () * iftmp.22;
  const void * * iftmp.23;
  const void * * iftmp.24;

  if (1 != 0) goto <D.102999>; else goto <D.103000>;
  <D.102999>:
  D.103001 = &this->D.99415;
  sigc::trackable::trackable (D.103001);
  goto <D.103002>;
  <D.103000>:
  <D.103002>:
  try
    {
      if (1 != 0) goto <D.103003>; else goto <D.103004>;
      <D.103003>:
      if (1 == 0) goto <D.103006>; else goto <D.103007>;
      <D.103006>:
      iftmp.18 = 32B;
      goto <D.103008>;
      <D.103007>:
      iftmp.18 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.103008>:
      D.103009 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.103009, iftmp.18);
      goto <D.103010>;
      <D.103004>:
      <D.103010>:
      try
        {
          if (1 == 0) goto <D.103012>; else goto <D.103013>;
          <D.103012>:
          iftmp.19 = 8B;
          goto <D.103014>;
          <D.103013>:
          iftmp.19 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
          <D.103014>:
          D.103015 = &this->D.99412;
          Glib::Object::Object (D.103015, iftmp.19, construct_params);
          try
            {
              if (1 == 0) goto <D.103017>; else goto <D.103018>;
              <D.103017>:
              D.103019 = 0B;
              iftmp.20 = *D.103019;
              goto <D.103020>;
              <D.103018>:
              iftmp.20 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.103020>:
              this->D.99412._vptr.Object = iftmp.20;
              if (1 == 0) goto <D.103022>; else goto <D.103023>;
              <D.103022>:
              D.103024 = this->D.99412._vptr.Object;
              D.103025 = D.103024 + 18446744073709551592;
              D.103026 = MEM[(long int *)D.103025];
              iftmp.21 = (sizetype) D.103026;
              goto <D.103027>;
              <D.103023>:
              iftmp.21 = 8;
              <D.103027>:
              D.103028 = this + iftmp.21;
              if (1 == 0) goto <D.103030>; else goto <D.103031>;
              <D.103030>:
              iftmp.22 = MEM[(const void * *)0B + 24B];
              goto <D.103032>;
              <D.103031>:
              iftmp.22 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.103032>:
              D.103028->_vptr.ObjectBase = iftmp.22;
            }
          catch
            {
              if (1 == 0) goto <D.103034>; else goto <D.103035>;
              <D.103034>:
              iftmp.23 = 8B;
              goto <D.103036>;
              <D.103035>:
              iftmp.23 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103036>:
              D.103015 = &this->D.99412;
              Glib::Object::~Object (D.103015, iftmp.23);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103037>; else goto <D.103038>;
          <D.103037>:
          if (1 == 0) goto <D.103040>; else goto <D.103041>;
          <D.103040>:
          iftmp.24 = 32B;
          goto <D.103042>;
          <D.103041>:
          iftmp.24 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.103042>:
          D.103009 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.103009, iftmp.24);
          goto <D.103043>;
          <D.103038>:
          <D.103043>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103044>; else goto <D.103045>;
      <D.103044>:
      D.103001 = &this->D.99415;
      sigc::trackable::~trackable (D.103001);
      goto <D.103046>;
      <D.103045>:
      <D.103046>:
    }
}


Gio::SocketClient::SocketClient(GSocketClient*) (struct SocketClient * const this, const void * * __vtt_parm, struct GSocketClient * castitem)
{
  struct trackable * D.103051;
  const void * * iftmp.25;
  struct ObjectBase * D.103059;
  const void * * iftmp.26;
  struct Object * D.103065;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  int (*__vtbl_ptr_type) () * D.103073;
  int (*__vtbl_ptr_type) () * D.103074;
  long int D.103075;
  struct ObjectBase * D.103077;
  int (*__vtbl_ptr_type) () * iftmp.29;
  const void * * iftmp.30;
  const void * * iftmp.31;

  if (0 != 0) goto <D.103049>; else goto <D.103050>;
  <D.103049>:
  D.103051 = &this->D.99415;
  sigc::trackable::trackable (D.103051);
  goto <D.103052>;
  <D.103050>:
  <D.103052>:
  try
    {
      if (0 != 0) goto <D.103053>; else goto <D.103054>;
      <D.103053>:
      if (0 == 0) goto <D.103056>; else goto <D.103057>;
      <D.103056>:
      iftmp.25 = __vtt_parm + 32;
      goto <D.103058>;
      <D.103057>:
      iftmp.25 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.103058>:
      D.103059 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.103059, iftmp.25);
      goto <D.103060>;
      <D.103054>:
      <D.103060>:
      try
        {
          if (0 == 0) goto <D.103062>; else goto <D.103063>;
          <D.103062>:
          iftmp.26 = __vtt_parm + 8;
          goto <D.103064>;
          <D.103063>:
          iftmp.26 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
          <D.103064>:
          D.103065 = &this->D.99412;
          Glib::Object::Object (D.103065, iftmp.26, castitem);
          try
            {
              if (0 == 0) goto <D.103067>; else goto <D.103068>;
              <D.103067>:
              iftmp.27 = *__vtt_parm;
              goto <D.103069>;
              <D.103068>:
              iftmp.27 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.103069>:
              this->D.99412._vptr.Object = iftmp.27;
              if (0 == 0) goto <D.103071>; else goto <D.103072>;
              <D.103071>:
              D.103073 = this->D.99412._vptr.Object;
              D.103074 = D.103073 + 18446744073709551592;
              D.103075 = MEM[(long int *)D.103074];
              iftmp.28 = (sizetype) D.103075;
              goto <D.103076>;
              <D.103072>:
              iftmp.28 = 8;
              <D.103076>:
              D.103077 = this + iftmp.28;
              if (0 == 0) goto <D.103079>; else goto <D.103080>;
              <D.103079>:
              iftmp.29 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.103081>;
              <D.103080>:
              iftmp.29 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.103081>:
              D.103077->_vptr.ObjectBase = iftmp.29;
            }
          catch
            {
              if (0 == 0) goto <D.103083>; else goto <D.103084>;
              <D.103083>:
              iftmp.30 = __vtt_parm + 8;
              goto <D.103085>;
              <D.103084>:
              iftmp.30 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103085>:
              D.103065 = &this->D.99412;
              Glib::Object::~Object (D.103065, iftmp.30);
            }
        }
      catch
        {
          if (0 != 0) goto <D.103086>; else goto <D.103087>;
          <D.103086>:
          if (0 == 0) goto <D.103089>; else goto <D.103090>;
          <D.103089>:
          iftmp.31 = __vtt_parm + 32;
          goto <D.103091>;
          <D.103090>:
          iftmp.31 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.103091>:
          D.103059 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.103059, iftmp.31);
          goto <D.103092>;
          <D.103087>:
          <D.103092>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.103093>; else goto <D.103094>;
      <D.103093>:
      D.103051 = &this->D.99415;
      sigc::trackable::~trackable (D.103051);
      goto <D.103095>;
      <D.103094>:
      <D.103095>:
    }
}


Gio::SocketClient::SocketClient(GSocketClient*) (struct SocketClient * const this, struct GSocketClient * castitem)
{
  struct trackable * D.103100;
  const void * * iftmp.32;
  struct ObjectBase * D.103108;
  const void * * iftmp.33;
  struct Object * D.103114;
  int (*__vtbl_ptr_type) () * iftmp.34;
  const void * * D.103118;
  sizetype iftmp.35;
  int (*__vtbl_ptr_type) () * D.103123;
  int (*__vtbl_ptr_type) () * D.103124;
  long int D.103125;
  struct ObjectBase * D.103127;
  int (*__vtbl_ptr_type) () * iftmp.36;
  const void * * iftmp.37;
  const void * * iftmp.38;

  if (1 != 0) goto <D.103098>; else goto <D.103099>;
  <D.103098>:
  D.103100 = &this->D.99415;
  sigc::trackable::trackable (D.103100);
  goto <D.103101>;
  <D.103099>:
  <D.103101>:
  try
    {
      if (1 != 0) goto <D.103102>; else goto <D.103103>;
      <D.103102>:
      if (1 == 0) goto <D.103105>; else goto <D.103106>;
      <D.103105>:
      iftmp.32 = 32B;
      goto <D.103107>;
      <D.103106>:
      iftmp.32 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.103107>:
      D.103108 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.103108, iftmp.32);
      goto <D.103109>;
      <D.103103>:
      <D.103109>:
      try
        {
          if (1 == 0) goto <D.103111>; else goto <D.103112>;
          <D.103111>:
          iftmp.33 = 8B;
          goto <D.103113>;
          <D.103112>:
          iftmp.33 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
          <D.103113>:
          D.103114 = &this->D.99412;
          Glib::Object::Object (D.103114, iftmp.33, castitem);
          try
            {
              if (1 == 0) goto <D.103116>; else goto <D.103117>;
              <D.103116>:
              D.103118 = 0B;
              iftmp.34 = *D.103118;
              goto <D.103119>;
              <D.103117>:
              iftmp.34 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.103119>:
              this->D.99412._vptr.Object = iftmp.34;
              if (1 == 0) goto <D.103121>; else goto <D.103122>;
              <D.103121>:
              D.103123 = this->D.99412._vptr.Object;
              D.103124 = D.103123 + 18446744073709551592;
              D.103125 = MEM[(long int *)D.103124];
              iftmp.35 = (sizetype) D.103125;
              goto <D.103126>;
              <D.103122>:
              iftmp.35 = 8;
              <D.103126>:
              D.103127 = this + iftmp.35;
              if (1 == 0) goto <D.103129>; else goto <D.103130>;
              <D.103129>:
              iftmp.36 = MEM[(const void * *)0B + 24B];
              goto <D.103131>;
              <D.103130>:
              iftmp.36 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.103131>:
              D.103127->_vptr.ObjectBase = iftmp.36;
            }
          catch
            {
              if (1 == 0) goto <D.103133>; else goto <D.103134>;
              <D.103133>:
              iftmp.37 = 8B;
              goto <D.103135>;
              <D.103134>:
              iftmp.37 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103135>:
              D.103114 = &this->D.99412;
              Glib::Object::~Object (D.103114, iftmp.37);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103136>; else goto <D.103137>;
          <D.103136>:
          if (1 == 0) goto <D.103139>; else goto <D.103140>;
          <D.103139>:
          iftmp.38 = 32B;
          goto <D.103141>;
          <D.103140>:
          iftmp.38 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.103141>:
          D.103108 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.103108, iftmp.38);
          goto <D.103142>;
          <D.103137>:
          <D.103142>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103143>; else goto <D.103144>;
      <D.103143>:
      D.103100 = &this->D.99415;
      sigc::trackable::~trackable (D.103100);
      goto <D.103145>;
      <D.103144>:
      <D.103145>:
    }
}


Gio::SocketClient::~SocketClient() (struct SocketClient * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.39;
  sizetype iftmp.40;
  int (*__vtbl_ptr_type) () * D.103155;
  int (*__vtbl_ptr_type) () * D.103156;
  long int D.103157;
  struct ObjectBase * D.103159;
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * iftmp.42;
  struct Object * D.103168;
  int D.103169;
  const void * * iftmp.43;
  struct ObjectBase * D.103176;
  struct trackable * D.103180;
  int D.103182;

  {
    if (0 == 0) goto <D.103149>; else goto <D.103150>;
    <D.103149>:
    iftmp.39 = *__vtt_parm;
    goto <D.103151>;
    <D.103150>:
    iftmp.39 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
    <D.103151>:
    this->D.99412._vptr.Object = iftmp.39;
    if (0 == 0) goto <D.103153>; else goto <D.103154>;
    <D.103153>:
    D.103155 = this->D.99412._vptr.Object;
    D.103156 = D.103155 + 18446744073709551592;
    D.103157 = MEM[(long int *)D.103156];
    iftmp.40 = (sizetype) D.103157;
    goto <D.103158>;
    <D.103154>:
    iftmp.40 = 8;
    <D.103158>:
    D.103159 = this + iftmp.40;
    if (0 == 0) goto <D.103161>; else goto <D.103162>;
    <D.103161>:
    iftmp.41 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.103163>;
    <D.103162>:
    iftmp.41 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
    <D.103163>:
    D.103159->_vptr.ObjectBase = iftmp.41;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.103165>; else goto <D.103166>;
                    <D.103165>:
                    iftmp.42 = __vtt_parm + 8;
                    goto <D.103167>;
                    <D.103166>:
                    iftmp.42 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
                    <D.103167>:
                    D.103168 = &this->D.99412;
                    Glib::Object::~Object (D.103168, iftmp.42);
                  }
              }
            finally
              {
                D.103169 = 0;
                if (D.103169 != 0) goto <D.103170>; else goto <D.103171>;
                <D.103170>:
                if (0 == 0) goto <D.103173>; else goto <D.103174>;
                <D.103173>:
                iftmp.43 = __vtt_parm + 32;
                goto <D.103175>;
                <D.103174>:
                iftmp.43 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
                <D.103175>:
                D.103176 = &this->D.99414;
                Glib::ObjectBase::~ObjectBase (D.103176, iftmp.43);
                goto <D.103177>;
                <D.103171>:
                <D.103177>:
              }
          }
        finally
          {
            D.103169 = 0;
            if (D.103169 != 0) goto <D.103178>; else goto <D.103179>;
            <D.103178>:
            D.103180 = &this->D.99415;
            sigc::trackable::~trackable (D.103180);
            goto <D.103181>;
            <D.103179>:
            <D.103181>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100329>:
  D.103182 = 0;
  if (D.103182 != 0) goto <D.103183>; else goto <D.103184>;
  <D.103183>:
  operator delete (this);
  goto <D.103185>;
  <D.103184>:
  <D.103185>:
}


virtual Gio::SocketClient::~SocketClient() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * D.103201;
  sizetype iftmp.45;
  int (*__vtbl_ptr_type) () * D.103206;
  int (*__vtbl_ptr_type) () * D.103207;
  long int D.103208;
  struct ObjectBase * D.103210;
  int (*__vtbl_ptr_type) () * iftmp.46;
  const void * * iftmp.47;
  struct Object * D.103219;
  int D.103220;
  const void * * iftmp.48;
  struct ObjectBase * D.103227;
  struct trackable * D.103231;
  int D.103233;

  {
    if (2 == 0) goto <D.103199>; else goto <D.103200>;
    <D.103199>:
    D.103201 = 0B;
    iftmp.44 = *D.103201;
    goto <D.103202>;
    <D.103200>:
    iftmp.44 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
    <D.103202>:
    this->D.99412._vptr.Object = iftmp.44;
    if (2 == 0) goto <D.103204>; else goto <D.103205>;
    <D.103204>:
    D.103206 = this->D.99412._vptr.Object;
    D.103207 = D.103206 + 18446744073709551592;
    D.103208 = MEM[(long int *)D.103207];
    iftmp.45 = (sizetype) D.103208;
    goto <D.103209>;
    <D.103205>:
    iftmp.45 = 8;
    <D.103209>:
    D.103210 = this + iftmp.45;
    if (2 == 0) goto <D.103212>; else goto <D.103213>;
    <D.103212>:
    iftmp.46 = MEM[(const void * *)0B + 24B];
    goto <D.103214>;
    <D.103213>:
    iftmp.46 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
    <D.103214>:
    D.103210->_vptr.ObjectBase = iftmp.46;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.103216>; else goto <D.103217>;
                    <D.103216>:
                    iftmp.47 = 8B;
                    goto <D.103218>;
                    <D.103217>:
                    iftmp.47 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
                    <D.103218>:
                    D.103219 = &this->D.99412;
                    Glib::Object::~Object (D.103219, iftmp.47);
                  }
              }
            finally
              {
                D.103220 = 2;
                if (D.103220 != 0) goto <D.103221>; else goto <D.103222>;
                <D.103221>:
                if (2 == 0) goto <D.103224>; else goto <D.103225>;
                <D.103224>:
                iftmp.48 = 32B;
                goto <D.103226>;
                <D.103225>:
                iftmp.48 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
                <D.103226>:
                D.103227 = &this->D.99414;
                Glib::ObjectBase::~ObjectBase (D.103227, iftmp.48);
                goto <D.103228>;
                <D.103222>:
                <D.103228>:
              }
          }
        finally
          {
            D.103220 = 2;
            if (D.103220 != 0) goto <D.103229>; else goto <D.103230>;
            <D.103229>:
            D.103231 = &this->D.99415;
            sigc::trackable::~trackable (D.103231);
            goto <D.103232>;
            <D.103230>:
            <D.103232>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100332>:
  D.103233 = 0;
  if (D.103233 != 0) goto <D.103234>; else goto <D.103235>;
  <D.103234>:
  operator delete (this);
  goto <D.103236>;
  <D.103235>:
  <D.103236>:
}


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


static GType Gio::SocketClient::get_type() ()
{
  GType D.103249;
  const struct Class & D.103250;

  D.103250 = Gio::SocketClient_Class::init (&socketclient_class_);
  D.103249 = Glib::Class::get_type (D.103250);
  return D.103249;
}


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

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


static GType Gio::SocketClient::get_base_type() ()
{
  GType D.103255;

  D.103255 = g_socket_client_get_type ();
  return D.103255;
}


Gio::SocketClient::SocketClient() (struct SocketClient * const this, const void * * __vtt_parm)
{
  struct trackable * D.103260;
  const void * * iftmp.49;
  struct ObjectBase * D.103268;
  struct ConstructParams D.100355;
  const struct Class & D.103270;
  const void * * iftmp.50;
  struct Object * D.103275;
  int (*__vtbl_ptr_type) () * iftmp.51;
  sizetype iftmp.52;
  int (*__vtbl_ptr_type) () * D.103283;
  int (*__vtbl_ptr_type) () * D.103284;
  long int D.103285;
  struct ObjectBase * D.103287;
  int (*__vtbl_ptr_type) () * iftmp.53;
  const void * * iftmp.54;
  const void * * iftmp.55;

  if (0 != 0) goto <D.103258>; else goto <D.103259>;
  <D.103258>:
  D.103260 = &this->D.99415;
  sigc::trackable::trackable (D.103260);
  goto <D.103261>;
  <D.103259>:
  <D.103261>:
  try
    {
      if (0 != 0) goto <D.103262>; else goto <D.103263>;
      <D.103262>:
      if (0 == 0) goto <D.103265>; else goto <D.103266>;
      <D.103265>:
      iftmp.49 = __vtt_parm + 32;
      goto <D.103267>;
      <D.103266>:
      iftmp.49 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.103267>:
      D.103268 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.103268, iftmp.49, 0B);
      goto <D.103269>;
      <D.103263>:
      <D.103269>:
      try
        {
          D.103270 = Gio::SocketClient_Class::init (&socketclient_class_);
          Glib::ConstructParams::ConstructParams (&D.100355, D.103270);
          try
            {
              if (0 == 0) goto <D.103272>; else goto <D.103273>;
              <D.103272>:
              iftmp.50 = __vtt_parm + 8;
              goto <D.103274>;
              <D.103273>:
              iftmp.50 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103274>:
              D.103275 = &this->D.99412;
              Glib::Object::Object (D.103275, iftmp.50, &D.100355);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.100355);
              D.100355 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.103277>; else goto <D.103278>;
              <D.103277>:
              iftmp.51 = *__vtt_parm;
              goto <D.103279>;
              <D.103278>:
              iftmp.51 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.103279>:
              this->D.99412._vptr.Object = iftmp.51;
              if (0 == 0) goto <D.103281>; else goto <D.103282>;
              <D.103281>:
              D.103283 = this->D.99412._vptr.Object;
              D.103284 = D.103283 + 18446744073709551592;
              D.103285 = MEM[(long int *)D.103284];
              iftmp.52 = (sizetype) D.103285;
              goto <D.103286>;
              <D.103282>:
              iftmp.52 = 8;
              <D.103286>:
              D.103287 = this + iftmp.52;
              if (0 == 0) goto <D.103289>; else goto <D.103290>;
              <D.103289>:
              iftmp.53 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.103291>;
              <D.103290>:
              iftmp.53 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.103291>:
              D.103287->_vptr.ObjectBase = iftmp.53;
            }
          catch
            {
              if (0 == 0) goto <D.103293>; else goto <D.103294>;
              <D.103293>:
              iftmp.54 = __vtt_parm + 8;
              goto <D.103295>;
              <D.103294>:
              iftmp.54 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103295>:
              D.103275 = &this->D.99412;
              Glib::Object::~Object (D.103275, iftmp.54);
            }
        }
      catch
        {
          if (0 != 0) goto <D.103296>; else goto <D.103297>;
          <D.103296>:
          if (0 == 0) goto <D.103299>; else goto <D.103300>;
          <D.103299>:
          iftmp.55 = __vtt_parm + 32;
          goto <D.103301>;
          <D.103300>:
          iftmp.55 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.103301>:
          D.103268 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.103268, iftmp.55);
          goto <D.103302>;
          <D.103297>:
          <D.103302>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.103303>; else goto <D.103304>;
      <D.103303>:
      D.103260 = &this->D.99415;
      sigc::trackable::~trackable (D.103260);
      goto <D.103305>;
      <D.103304>:
      <D.103305>:
    }
}


Gio::SocketClient::SocketClient() (struct SocketClient * const this)
{
  struct trackable * D.103312;
  const void * * iftmp.56;
  struct ObjectBase * D.103320;
  struct ConstructParams D.100357;
  const struct Class & D.103322;
  const void * * iftmp.57;
  struct Object * D.103327;
  int (*__vtbl_ptr_type) () * iftmp.58;
  const void * * D.103331;
  sizetype iftmp.59;
  int (*__vtbl_ptr_type) () * D.103336;
  int (*__vtbl_ptr_type) () * D.103337;
  long int D.103338;
  struct ObjectBase * D.103340;
  int (*__vtbl_ptr_type) () * iftmp.60;
  const void * * iftmp.61;
  const void * * iftmp.62;

  if (1 != 0) goto <D.103310>; else goto <D.103311>;
  <D.103310>:
  D.103312 = &this->D.99415;
  sigc::trackable::trackable (D.103312);
  goto <D.103313>;
  <D.103311>:
  <D.103313>:
  try
    {
      if (1 != 0) goto <D.103314>; else goto <D.103315>;
      <D.103314>:
      if (1 == 0) goto <D.103317>; else goto <D.103318>;
      <D.103317>:
      iftmp.56 = 32B;
      goto <D.103319>;
      <D.103318>:
      iftmp.56 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
      <D.103319>:
      D.103320 = &this->D.99414;
      Glib::ObjectBase::ObjectBase (D.103320, iftmp.56, 0B);
      goto <D.103321>;
      <D.103315>:
      <D.103321>:
      try
        {
          D.103322 = Gio::SocketClient_Class::init (&socketclient_class_);
          Glib::ConstructParams::ConstructParams (&D.100357, D.103322);
          try
            {
              if (1 == 0) goto <D.103324>; else goto <D.103325>;
              <D.103324>:
              iftmp.57 = 8B;
              goto <D.103326>;
              <D.103325>:
              iftmp.57 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103326>:
              D.103327 = &this->D.99412;
              Glib::Object::Object (D.103327, iftmp.57, &D.100357);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.100357);
              D.100357 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.103329>; else goto <D.103330>;
              <D.103329>:
              D.103331 = 0B;
              iftmp.58 = *D.103331;
              goto <D.103332>;
              <D.103330>:
              iftmp.58 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 32B];
              <D.103332>:
              this->D.99412._vptr.Object = iftmp.58;
              if (1 == 0) goto <D.103334>; else goto <D.103335>;
              <D.103334>:
              D.103336 = this->D.99412._vptr.Object;
              D.103337 = D.103336 + 18446744073709551592;
              D.103338 = MEM[(long int *)D.103337];
              iftmp.59 = (sizetype) D.103338;
              goto <D.103339>;
              <D.103335>:
              iftmp.59 = 8;
              <D.103339>:
              D.103340 = this + iftmp.59;
              if (1 == 0) goto <D.103342>; else goto <D.103343>;
              <D.103342>:
              iftmp.60 = MEM[(const void * *)0B + 24B];
              goto <D.103344>;
              <D.103343>:
              iftmp.60 = &MEM[(void *)&_ZTVN3Gio12SocketClientE + 112B];
              <D.103344>:
              D.103340->_vptr.ObjectBase = iftmp.60;
            }
          catch
            {
              if (1 == 0) goto <D.103346>; else goto <D.103347>;
              <D.103346>:
              iftmp.61 = 8B;
              goto <D.103348>;
              <D.103347>:
              iftmp.61 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 8B];
              <D.103348>:
              D.103327 = &this->D.99412;
              Glib::Object::~Object (D.103327, iftmp.61);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103349>; else goto <D.103350>;
          <D.103349>:
          if (1 == 0) goto <D.103352>; else goto <D.103353>;
          <D.103352>:
          iftmp.62 = 32B;
          goto <D.103354>;
          <D.103353>:
          iftmp.62 = &MEM[(void *)&_ZTTN3Gio12SocketClientE + 32B];
          <D.103354>:
          D.103320 = &this->D.99414;
          Glib::ObjectBase::~ObjectBase (D.103320, iftmp.62);
          goto <D.103355>;
          <D.103350>:
          <D.103355>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103356>; else goto <D.103357>;
      <D.103356>:
      D.103312 = &this->D.99415;
      sigc::trackable::~trackable (D.103312);
      goto <D.103358>;
      <D.103357>:
      <D.103358>:
    }
}


static Glib::RefPtr<Gio::SocketClient> Gio::SocketClient::create() ()
{
  void * D.100361;

  D.100361 = operator new (48);
  try
    {
      Gio::SocketClient::SocketClient (D.100361);
    }
  catch
    {
      operator delete (D.100361);
    }
  Glib::RefPtr<Gio::SocketClient>::RefPtr (<retval>, D.100361);
  return <retval>;
}


Gio::SocketFamily Gio::SocketClient::get_family() const (const struct SocketClient * const this)
{
  SocketFamily D.103367;
  const struct GSocketClient * D.103368;

  D.103368 = Gio::SocketClient::gobj (this);
  D.103367 = g_socket_client_get_family (D.103368);
  return D.103367;
}


const GSocketClient* Gio::SocketClient::gobj() const (const struct SocketClient * const this)
{
  const struct GSocketClient * D.103371;
  int (*__vtbl_ptr_type) () * D.103372;
  int (*__vtbl_ptr_type) () * D.103373;
  long int D.103374;
  sizetype D.103375;
  const struct ObjectBase * D.103376;

  D.103372 = this->D.99412._vptr.Object;
  D.103373 = D.103372 + 18446744073709551592;
  D.103374 = MEM[(long int *)D.103373];
  D.103375 = (sizetype) D.103374;
  D.103376 = this + D.103375;
  D.103371 = D.103376->gobject_;
  return D.103371;
}


void Gio::SocketClient::set_family(Gio::SocketFamily) (struct SocketClient * const this, SocketFamily family)
{
  struct GSocketClient * D.103378;

  D.103378 = Gio::SocketClient::gobj (this);
  g_socket_client_set_family (D.103378, family);
}


Gio::SocketType Gio::SocketClient::get_socket_type() const (const struct SocketClient * const this)
{
  SocketType D.103379;
  const struct GSocketClient * D.103380;

  D.103380 = Gio::SocketClient::gobj (this);
  D.103379 = g_socket_client_get_socket_type (D.103380);
  return D.103379;
}


void Gio::SocketClient::set_socket_type(Gio::SocketType) (struct SocketClient * const this, SocketType type)
{
  struct GSocketClient * D.103383;

  D.103383 = Gio::SocketClient::gobj (this);
  g_socket_client_set_socket_type (D.103383, type);
}


Gio::SocketProtocol Gio::SocketClient::get_protocol() const (const struct SocketClient * const this)
{
  SocketProtocol D.103384;
  const struct GSocketClient * D.103385;

  D.103385 = Gio::SocketClient::gobj (this);
  D.103384 = g_socket_client_get_protocol (D.103385);
  return D.103384;
}


void Gio::SocketClient::set_protocol(Gio::SocketProtocol) (struct SocketClient * const this, SocketProtocol protocol)
{
  struct GSocketClient * D.103388;

  D.103388 = Gio::SocketClient::gobj (this);
  g_socket_client_set_protocol (D.103388, protocol);
}


Glib::RefPtr<Gio::SocketAddress> Gio::SocketClient::get_local_address() (struct SocketClient * const this)
{
  struct GSocketClient * D.103390;
  struct GSocketAddress * D.103391;

  D.103390 = Gio::SocketClient::gobj (this);
  D.103391 = g_socket_client_get_local_address (D.103390);
  *<retval> = Glib::wrap (D.103391, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::SocketAddress> Gio::SocketClient::get_local_address() const (const struct SocketClient * const this)
{
  struct RefPtr D.100649;

  D.100649 = Gio::SocketClient::get_local_address (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::SocketAddress>::RefPtr<Gio::SocketAddress> (<retval>, &D.100649);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::SocketAddress>::~RefPtr (&D.100649);
      D.100649 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::SocketAddress; T_CppObject = const Gio::SocketAddress] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct SocketAddress * D.103398;
  const struct SocketAddress * D.103399;
  int (*__vtbl_ptr_type) () * D.103402;
  int (*__vtbl_ptr_type) () * D.103403;
  long int D.103404;
  sizetype D.103405;
  const struct ObjectBase * D.103406;
  int (*__vtbl_ptr_type) () * D.103407;
  int (*__vtbl_ptr_type) () * D.103408;
  int (*__vtbl_ptr_type) () D.103409;

  D.103398 = Glib::RefPtr<Gio::SocketAddress>::operator-> (src);
  this->pCppObject_ = D.103398;
  D.103399 = this->pCppObject_;
  if (D.103399 != 0B) goto <D.103400>; else goto <D.103401>;
  <D.103400>:
  D.103399 = this->pCppObject_;
  D.103399 = this->pCppObject_;
  D.103402 = D.103399->D.97373._vptr.Object;
  D.103403 = D.103402 + 18446744073709551592;
  D.103404 = MEM[(long int *)D.103403];
  D.103405 = (sizetype) D.103404;
  D.103406 = D.103399 + D.103405;
  D.103399 = this->pCppObject_;
  D.103399 = this->pCppObject_;
  D.103402 = D.103399->D.97373._vptr.Object;
  D.103403 = D.103402 + 18446744073709551592;
  D.103404 = MEM[(long int *)D.103403];
  D.103405 = (sizetype) D.103404;
  D.103406 = D.103399 + D.103405;
  D.103407 = D.103406->_vptr.ObjectBase;
  D.103408 = D.103407 + 16;
  D.103409 = *D.103408;
  D.103399 = this->pCppObject_;
  D.103399 = this->pCppObject_;
  D.103402 = D.103399->D.97373._vptr.Object;
  D.103403 = D.103402 + 18446744073709551592;
  D.103404 = MEM[(long int *)D.103403];
  D.103405 = (sizetype) D.103404;
  D.103406 = D.103399 + D.103405;
  OBJ_TYPE_REF(D.103409;(const struct ObjectBase)D.103406->2) (D.103406);
  goto <D.103410>;
  <D.103401>:
  <D.103410>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketAddress] (struct RefPtr * const this)
{
  struct SocketAddress * D.103413;
  int (*__vtbl_ptr_type) () * D.103416;
  int (*__vtbl_ptr_type) () * D.103417;
  long int D.103418;
  sizetype D.103419;
  struct ObjectBase * D.103420;
  int (*__vtbl_ptr_type) () * D.103421;
  int (*__vtbl_ptr_type) () * D.103422;
  int (*__vtbl_ptr_type) () D.103423;

  {
    try
      {
        D.103413 = this->pCppObject_;
        if (D.103413 != 0B) goto <D.103414>; else goto <D.103415>;
        <D.103414>:
        D.103413 = this->pCppObject_;
        D.103413 = this->pCppObject_;
        D.103416 = D.103413->D.97373._vptr.Object;
        D.103417 = D.103416 + 18446744073709551592;
        D.103418 = MEM[(long int *)D.103417];
        D.103419 = (sizetype) D.103418;
        D.103420 = D.103413 + D.103419;
        D.103413 = this->pCppObject_;
        D.103413 = this->pCppObject_;
        D.103416 = D.103413->D.97373._vptr.Object;
        D.103417 = D.103416 + 18446744073709551592;
        D.103418 = MEM[(long int *)D.103417];
        D.103419 = (sizetype) D.103418;
        D.103420 = D.103413 + D.103419;
        D.103421 = D.103420->_vptr.ObjectBase;
        D.103422 = D.103421 + 24;
        D.103423 = *D.103422;
        D.103413 = this->pCppObject_;
        D.103413 = this->pCppObject_;
        D.103416 = D.103413->D.97373._vptr.Object;
        D.103417 = D.103416 + 18446744073709551592;
        D.103418 = MEM[(long int *)D.103417];
        D.103419 = (sizetype) D.103418;
        D.103420 = D.103413 + D.103419;
        OBJ_TYPE_REF(D.103423;(const struct ObjectBase)D.103420->3) (D.103420);
        goto <D.103424>;
        <D.103415>:
        <D.103424>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102360>:
}


void Gio::SocketClient::set_local_address(const Glib::RefPtr<Gio::SocketAddress>&) (struct SocketClient * const this, const struct RefPtr & address)
{
  struct BaseObjectType * D.103426;
  struct GSocketClient * D.103427;

  D.103426 = Glib::unwrap<Gio::SocketAddress> (address);
  D.103427 = Gio::SocketClient::gobj (this);
  g_socket_client_set_local_address (D.103427, D.103426);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::SocketAddress; typename T::BaseObjectType = _GSocketAddress] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.103429;
  struct BaseObjectType * iftmp.63;
  bool D.103431;
  struct SocketAddress * D.103434;

  D.103431 = Glib::RefPtr<Gio::SocketAddress>::operator bool (ptr);
  if (D.103431 != 0) goto <D.103432>; else goto <D.103433>;
  <D.103432>:
  D.103434 = Glib::RefPtr<Gio::SocketAddress>::operator-> (ptr);
  iftmp.63 = Gio::SocketAddress::gobj (D.103434);
  goto <D.103435>;
  <D.103433>:
  iftmp.63 = 0B;
  <D.103435>:
  D.103429 = iftmp.63;
  return D.103429;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::SocketAddress] (const struct RefPtr * const this)
{
  bool D.103437;
  struct SocketAddress * D.103438;

  D.103438 = this->pCppObject_;
  D.103437 = D.103438 != 0B;
  return D.103437;
}


GSocketAddress* Gio::SocketAddress::gobj() (struct SocketAddress * const this)
{
  struct GSocketAddress * D.103440;
  int (*__vtbl_ptr_type) () * D.103441;
  int (*__vtbl_ptr_type) () * D.103442;
  long int D.103443;
  sizetype D.103444;
  struct ObjectBase * D.103445;

  D.103441 = this->D.97373._vptr.Object;
  D.103442 = D.103441 + 18446744073709551592;
  D.103443 = MEM[(long int *)D.103442];
  D.103444 = (sizetype) D.103443;
  D.103445 = this + D.103444;
  D.103440 = D.103445->gobject_;
  return D.103440;
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect(const Glib::RefPtr<Gio::SocketConnectable>&, const Glib::RefPtr<Gio::Cancellable>&) (struct SocketClient * const this, const struct RefPtr & connectable, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.103448;
  struct BaseObjectType * D.103449;
  struct GSocketClient * D.103450;
  struct GSocketConnection * D.103451;
  struct GError * gerror.64;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103448 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.103449 = Glib::unwrap<Gio::SocketConnectable> (connectable);
      D.103450 = Gio::SocketClient::gobj (this);
      D.103451 = g_socket_client_connect (D.103450, D.103449, D.103448, &gerror);
      *<retval> = Glib::wrap (D.103451, 0); [return slot optimization]
      try
        {
          gerror.64 = gerror;
          if (gerror.64 != 0B) goto <D.103453>; else goto <D.103454>;
          <D.103453>:
          gerror.64 = gerror;
          Glib::Error::throw_exception (gerror.64);
          <D.103454>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::SocketConnectable; typename T::BaseObjectType = _GSocketConnectable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.103462;
  struct BaseObjectType * iftmp.65;
  bool D.103464;
  struct SocketConnectable * D.103467;

  D.103464 = Glib::RefPtr<Gio::SocketConnectable>::operator bool (ptr);
  if (D.103464 != 0) goto <D.103465>; else goto <D.103466>;
  <D.103465>:
  D.103467 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (ptr);
  iftmp.65 = Gio::SocketConnectable::gobj (D.103467);
  goto <D.103468>;
  <D.103466>:
  iftmp.65 = 0B;
  <D.103468>:
  D.103462 = iftmp.65;
  return D.103462;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::SocketConnectable] (const struct RefPtr * const this)
{
  bool D.103470;
  struct SocketConnectable * D.103471;

  D.103471 = this->pCppObject_;
  D.103470 = D.103471 != 0B;
  return D.103470;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnection] (struct RefPtr * const this)
{
  struct SocketConnection * D.103473;
  int (*__vtbl_ptr_type) () * D.103476;
  int (*__vtbl_ptr_type) () * D.103477;
  long int D.103478;
  sizetype D.103479;
  struct ObjectBase * D.103480;
  int (*__vtbl_ptr_type) () * D.103481;
  int (*__vtbl_ptr_type) () * D.103482;
  int (*__vtbl_ptr_type) () D.103483;

  {
    try
      {
        D.103473 = this->pCppObject_;
        if (D.103473 != 0B) goto <D.103474>; else goto <D.103475>;
        <D.103474>:
        D.103473 = this->pCppObject_;
        D.103473 = this->pCppObject_;
        D.103476 = D.103473->D.98951.D.98812._vptr.Object;
        D.103477 = D.103476 + 18446744073709551592;
        D.103478 = MEM[(long int *)D.103477];
        D.103479 = (sizetype) D.103478;
        D.103480 = D.103473 + D.103479;
        D.103473 = this->pCppObject_;
        D.103473 = this->pCppObject_;
        D.103476 = D.103473->D.98951.D.98812._vptr.Object;
        D.103477 = D.103476 + 18446744073709551592;
        D.103478 = MEM[(long int *)D.103477];
        D.103479 = (sizetype) D.103478;
        D.103480 = D.103473 + D.103479;
        D.103481 = D.103480->_vptr.ObjectBase;
        D.103482 = D.103481 + 24;
        D.103483 = *D.103482;
        D.103473 = this->pCppObject_;
        D.103473 = this->pCppObject_;
        D.103476 = D.103473->D.98951.D.98812._vptr.Object;
        D.103477 = D.103476 + 18446744073709551592;
        D.103478 = MEM[(long int *)D.103477];
        D.103479 = (sizetype) D.103478;
        D.103480 = D.103473 + D.103479;
        OBJ_TYPE_REF(D.103483;(const struct ObjectBase)D.103480->3) (D.103480);
        goto <D.103484>;
        <D.103475>:
        <D.103484>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102392>:
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect(const Glib::RefPtr<Gio::SocketConnectable>&) (struct SocketClient * const this, const struct RefPtr & connectable)
{
  struct BaseObjectType * D.103487;
  struct GSocketClient * D.103488;
  struct GSocketConnection * D.103489;
  struct GError * gerror.66;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103487 = Glib::unwrap<Gio::SocketConnectable> (connectable);
      D.103488 = Gio::SocketClient::gobj (this);
      D.103489 = g_socket_client_connect (D.103488, D.103487, 0B, &gerror);
      *<retval> = Glib::wrap (D.103489, 0); [return slot optimization]
      try
        {
          gerror.66 = gerror;
          if (gerror.66 != 0B) goto <D.103491>; else goto <D.103492>;
          <D.103491>:
          gerror.66 = gerror;
          Glib::Error::throw_exception (gerror.66);
          <D.103492>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_host(const Glib::ustring&, guint16, const Glib::RefPtr<Gio::Cancellable>&) (struct SocketClient * const this, const struct ustring & host_and_port, guint16 default_port, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.103500;
  int D.103501;
  const char * D.103502;
  struct GSocketClient * D.103503;
  struct GSocketConnection * D.103504;
  struct GError * gerror.67;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103500 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.103501 = (int) default_port;
      D.103502 = Glib::ustring::c_str (host_and_port);
      D.103503 = Gio::SocketClient::gobj (this);
      D.103504 = g_socket_client_connect_to_host (D.103503, D.103502, D.103501, D.103500, &gerror);
      *<retval> = Glib::wrap (D.103504, 0); [return slot optimization]
      try
        {
          gerror.67 = gerror;
          if (gerror.67 != 0B) goto <D.103506>; else goto <D.103507>;
          <D.103506>:
          gerror.67 = gerror;
          Glib::Error::throw_exception (gerror.67);
          <D.103507>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_host(const Glib::ustring&, guint16) (struct SocketClient * const this, const struct ustring & host_and_port, guint16 default_port)
{
  int D.103516;
  const char * D.103517;
  struct GSocketClient * D.103518;
  struct GSocketConnection * D.103519;
  struct GError * gerror.68;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103516 = (int) default_port;
      D.103517 = Glib::ustring::c_str (host_and_port);
      D.103518 = Gio::SocketClient::gobj (this);
      D.103519 = g_socket_client_connect_to_host (D.103518, D.103517, D.103516, 0B, &gerror);
      *<retval> = Glib::wrap (D.103519, 0); [return slot optimization]
      try
        {
          gerror.68 = gerror;
          if (gerror.68 != 0B) goto <D.103521>; else goto <D.103522>;
          <D.103521>:
          gerror.68 = gerror;
          Glib::Error::throw_exception (gerror.68);
          <D.103522>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_service(const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&) (struct SocketClient * const this, const struct ustring & domain, const struct ustring & service, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.103530;
  const char * D.103531;
  const char * D.103532;
  struct GSocketClient * D.103533;
  struct GSocketConnection * D.103534;
  struct GError * gerror.69;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103530 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.103531 = Glib::ustring::c_str (service);
      D.103532 = Glib::ustring::c_str (domain);
      D.103533 = Gio::SocketClient::gobj (this);
      D.103534 = g_socket_client_connect_to_service (D.103533, D.103532, D.103531, D.103530, &gerror);
      *<retval> = Glib::wrap (D.103534, 0); [return slot optimization]
      try
        {
          gerror.69 = gerror;
          if (gerror.69 != 0B) goto <D.103536>; else goto <D.103537>;
          <D.103536>:
          gerror.69 = gerror;
          Glib::Error::throw_exception (gerror.69);
          <D.103537>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_service(const Glib::ustring&, const Glib::ustring&) (struct SocketClient * const this, const struct ustring & domain, const struct ustring & service)
{
  const char * D.103547;
  const char * D.103548;
  struct GSocketClient * D.103549;
  struct GSocketConnection * D.103550;
  struct GError * gerror.70;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103547 = Glib::ustring::c_str (service);
      D.103548 = Glib::ustring::c_str (domain);
      D.103549 = Gio::SocketClient::gobj (this);
      D.103550 = g_socket_client_connect_to_service (D.103549, D.103548, D.103547, 0B, &gerror);
      *<retval> = Glib::wrap (D.103550, 0); [return slot optimization]
      try
        {
          gerror.70 = gerror;
          if (gerror.70 != 0B) goto <D.103552>; else goto <D.103553>;
          <D.103552>:
          gerror.70 = gerror;
          Glib::Error::throw_exception (gerror.70);
          <D.103553>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_uri(const Glib::ustring&, guint16, const Glib::RefPtr<Gio::Cancellable>&) (struct SocketClient * const this, const struct ustring & uri, guint16 default_port, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.103562;
  int D.103563;
  const char * D.103564;
  struct GSocketClient * D.103565;
  struct GSocketConnection * D.103566;
  struct GError * gerror.71;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103562 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.103563 = (int) default_port;
      D.103564 = Glib::ustring::c_str (uri);
      D.103565 = Gio::SocketClient::gobj (this);
      D.103566 = g_socket_client_connect_to_uri (D.103565, D.103564, D.103563, D.103562, &gerror);
      *<retval> = Glib::wrap (D.103566, 0); [return slot optimization]
      try
        {
          gerror.71 = gerror;
          if (gerror.71 != 0B) goto <D.103568>; else goto <D.103569>;
          <D.103568>:
          gerror.71 = gerror;
          Glib::Error::throw_exception (gerror.71);
          <D.103569>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_uri(const Glib::ustring&, guint16) (struct SocketClient * const this, const struct ustring & uri, guint16 default_port)
{
  int D.103578;
  const char * D.103579;
  struct GSocketClient * D.103580;
  struct GSocketConnection * D.103581;
  struct GError * gerror.72;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103578 = (int) default_port;
      D.103579 = Glib::ustring::c_str (uri);
      D.103580 = Gio::SocketClient::gobj (this);
      D.103581 = g_socket_client_connect_to_uri (D.103580, D.103579, D.103578, 0B, &gerror);
      *<retval> = Glib::wrap (D.103581, 0); [return slot optimization]
      try
        {
          gerror.72 = gerror;
          if (gerror.72 != 0B) goto <D.103583>; else goto <D.103584>;
          <D.103583>:
          gerror.72 = gerror;
          Glib::Error::throw_exception (gerror.72);
          <D.103584>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct SocketClient * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.103592;
  struct GSocketClient * D.103593;
  struct GSocketConnection * D.103594;
  struct GError * gerror.73;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103592 = Glib::unwrap<Gio::AsyncResult> (result);
      D.103593 = Gio::SocketClient::gobj (this);
      D.103594 = g_socket_client_connect_finish (D.103593, D.103592, &gerror);
      *<retval> = Glib::wrap (D.103594, 0); [return slot optimization]
      try
        {
          gerror.73 = gerror;
          if (gerror.73 != 0B) goto <D.103596>; else goto <D.103597>;
          <D.103596>:
          gerror.73 = gerror;
          Glib::Error::throw_exception (gerror.73);
          <D.103597>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~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.103604;
  struct BaseObjectType * iftmp.74;
  bool D.103606;
  struct AsyncResult * D.103609;

  D.103606 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.103606 != 0) goto <D.103607>; else goto <D.103608>;
  <D.103607>:
  D.103609 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.74 = Gio::AsyncResult::gobj (D.103609);
  goto <D.103610>;
  <D.103608>:
  iftmp.74 = 0B;
  <D.103610>:
  D.103604 = iftmp.74;
  return D.103604;
}


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

  D.103613 = this->pCppObject_;
  D.103612 = D.103613 != 0B;
  return D.103612;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.103617;
  int (*__vtbl_ptr_type) () * D.103618;
  int (*__vtbl_ptr_type) () * D.103619;
  long int D.103620;
  sizetype D.103621;
  struct ObjectBase * D.103622;

  D.103618 = this->D.86030._vptr.Interface;
  D.103619 = D.103618 + 18446744073709551592;
  D.103620 = MEM[(long int *)D.103619];
  D.103621 = (sizetype) D.103620;
  D.103622 = this + D.103621;
  D.103617 = D.103622->gobject_;
  return D.103617;
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_host_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct SocketClient * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.103625;
  struct GSocketClient * D.103626;
  struct GSocketConnection * D.103627;
  struct GError * gerror.75;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103625 = Glib::unwrap<Gio::AsyncResult> (result);
      D.103626 = Gio::SocketClient::gobj (this);
      D.103627 = g_socket_client_connect_to_host_finish (D.103626, D.103625, &gerror);
      *<retval> = Glib::wrap (D.103627, 0); [return slot optimization]
      try
        {
          gerror.75 = gerror;
          if (gerror.75 != 0B) goto <D.103629>; else goto <D.103630>;
          <D.103629>:
          gerror.75 = gerror;
          Glib::Error::throw_exception (gerror.75);
          <D.103630>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_service_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct SocketClient * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.103638;
  struct GSocketClient * D.103639;
  struct GSocketConnection * D.103640;
  struct GError * gerror.76;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103638 = Glib::unwrap<Gio::AsyncResult> (result);
      D.103639 = Gio::SocketClient::gobj (this);
      D.103640 = g_socket_client_connect_to_service_finish (D.103639, D.103638, &gerror);
      *<retval> = Glib::wrap (D.103640, 0); [return slot optimization]
      try
        {
          gerror.76 = gerror;
          if (gerror.76 != 0B) goto <D.103642>; else goto <D.103643>;
          <D.103642>:
          gerror.76 = gerror;
          Glib::Error::throw_exception (gerror.76);
          <D.103643>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketConnection> Gio::SocketClient::connect_to_uri_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct SocketClient * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.103651;
  struct GSocketClient * D.103652;
  struct GSocketConnection * D.103653;
  struct GError * gerror.77;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103651 = Glib::unwrap<Gio::AsyncResult> (result);
      D.103652 = Gio::SocketClient::gobj (this);
      D.103653 = g_socket_client_connect_to_uri_finish (D.103652, D.103651, &gerror);
      *<retval> = Glib::wrap (D.103653, 0); [return slot optimization]
      try
        {
          gerror.77 = gerror;
          if (gerror.77 != 0B) goto <D.103655>; else goto <D.103656>;
          <D.103655>:
          gerror.77 = gerror;
          Glib::Error::throw_exception (gerror.77);
          <D.103656>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::SocketClient::get_enable_proxy() const (const struct SocketClient * const this)
{
  bool D.103663;
  const struct GSocketClient * D.103664;
  int D.103665;

  D.103664 = Gio::SocketClient::gobj (this);
  D.103665 = g_socket_client_get_enable_proxy (D.103664);
  D.103663 = D.103665 != 0;
  return D.103663;
}


void Gio::SocketClient::set_enable_proxy(bool) (struct SocketClient * const this, bool enable)
{
  int D.103668;
  struct GSocketClient * D.103669;

  D.103668 = (int) enable;
  D.103669 = Gio::SocketClient::gobj (this);
  g_socket_client_set_enable_proxy (D.103669, D.103668);
}


bool Gio::SocketClient::get_tls() const (const struct SocketClient * const this)
{
  bool D.103670;
  const struct GSocketClient * D.103671;
  int D.103672;

  D.103671 = Gio::SocketClient::gobj (this);
  D.103672 = g_socket_client_get_tls (D.103671);
  D.103670 = D.103672 != 0;
  return D.103670;
}


void Gio::SocketClient::set_tls(bool) (struct SocketClient * const this, bool tls)
{
  int D.103675;
  struct GSocketClient * D.103676;

  D.103675 = (int) tls;
  D.103676 = Gio::SocketClient::gobj (this);
  g_socket_client_set_tls (D.103676, D.103675);
}


Gio::TlsCertificateFlags Gio::SocketClient::get_tls_validation_flags() const (const struct SocketClient * const this)
{
  TlsCertificateFlags D.103677;
  const struct GSocketClient * D.103678;

  D.103678 = Gio::SocketClient::gobj (this);
  D.103677 = g_socket_client_get_tls_validation_flags (D.103678);
  return D.103677;
}


void Gio::SocketClient::set_tls_validation_flags(Gio::TlsCertificateFlags) (struct SocketClient * const this, TlsCertificateFlags flags)
{
  struct GSocketClient * D.103681;

  D.103681 = Gio::SocketClient::gobj (this);
  g_socket_client_set_tls_validation_flags (D.103681, flags);
}


Glib::RefPtr<Gio::ProxyResolver> Gio::SocketClient::get_proxy_resolver() (struct SocketClient * const this)
{
  struct GSocketClient * D.103683;
  struct GProxyResolver * D.103684;
  bool retval.78;
  struct ProxyResolver * D.103688;
  int (*__vtbl_ptr_type) () * D.103689;
  int (*__vtbl_ptr_type) () * D.103690;
  long int D.103691;
  sizetype D.103692;
  struct ObjectBase * D.103693;
  int (*__vtbl_ptr_type) () * D.103694;
  int (*__vtbl_ptr_type) () * D.103695;
  int (*__vtbl_ptr_type) () D.103696;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.103683 = Gio::SocketClient::gobj (this);
  D.103684 = g_socket_client_get_proxy_resolver (D.103683);
  *<retval> = Glib::wrap (D.103684, 0); [return slot optimization]
  try
    {
      retval.78 = Glib::RefPtr<Gio::ProxyResolver>::operator bool (<retval>);
      if (retval.78 != 0) goto <D.103686>; else goto <D.103687>;
      <D.103686>:
      D.103688 = Glib::RefPtr<Gio::ProxyResolver>::operator-> (<retval>);
      D.103689 = D.103688->D.99087._vptr.Interface;
      D.103690 = D.103689 + 18446744073709551592;
      D.103691 = MEM[(long int *)D.103690];
      D.103692 = (sizetype) D.103691;
      D.103693 = D.103688 + D.103692;
      D.103689 = D.103688->D.99087._vptr.Interface;
      D.103690 = D.103689 + 18446744073709551592;
      D.103691 = MEM[(long int *)D.103690];
      D.103692 = (sizetype) D.103691;
      D.103693 = D.103688 + D.103692;
      D.103694 = D.103693->_vptr.ObjectBase;
      D.103695 = D.103694 + 16;
      D.103696 = *D.103695;
      D.103689 = D.103688->D.99087._vptr.Interface;
      D.103690 = D.103689 + 18446744073709551592;
      D.103691 = MEM[(long int *)D.103690];
      D.103692 = (sizetype) D.103691;
      D.103693 = D.103688 + D.103692;
      OBJ_TYPE_REF(D.103696;(const struct ObjectBase)D.103693->2) (D.103693);
      goto <D.103697>;
      <D.103687>:
      <D.103697>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::ProxyResolver>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::ProxyResolver] (const struct RefPtr * const this)
{
  bool D.103701;
  struct ProxyResolver * D.103702;

  D.103702 = this->pCppObject_;
  D.103701 = D.103702 != 0B;
  return D.103701;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::ProxyResolver] (struct RefPtr * const this)
{
  struct ProxyResolver * D.103706;
  int (*__vtbl_ptr_type) () * D.103709;
  int (*__vtbl_ptr_type) () * D.103710;
  long int D.103711;
  sizetype D.103712;
  struct ObjectBase * D.103713;
  int (*__vtbl_ptr_type) () * D.103714;
  int (*__vtbl_ptr_type) () * D.103715;
  int (*__vtbl_ptr_type) () D.103716;

  {
    try
      {
        D.103706 = this->pCppObject_;
        if (D.103706 != 0B) goto <D.103707>; else goto <D.103708>;
        <D.103707>:
        D.103706 = this->pCppObject_;
        D.103706 = this->pCppObject_;
        D.103709 = D.103706->D.99087._vptr.Interface;
        D.103710 = D.103709 + 18446744073709551592;
        D.103711 = MEM[(long int *)D.103710];
        D.103712 = (sizetype) D.103711;
        D.103713 = D.103706 + D.103712;
        D.103706 = this->pCppObject_;
        D.103706 = this->pCppObject_;
        D.103709 = D.103706->D.99087._vptr.Interface;
        D.103710 = D.103709 + 18446744073709551592;
        D.103711 = MEM[(long int *)D.103710];
        D.103712 = (sizetype) D.103711;
        D.103713 = D.103706 + D.103712;
        D.103714 = D.103713->_vptr.ObjectBase;
        D.103715 = D.103714 + 24;
        D.103716 = *D.103715;
        D.103706 = this->pCppObject_;
        D.103706 = this->pCppObject_;
        D.103709 = D.103706->D.99087._vptr.Interface;
        D.103710 = D.103709 + 18446744073709551592;
        D.103711 = MEM[(long int *)D.103710];
        D.103712 = (sizetype) D.103711;
        D.103713 = D.103706 + D.103712;
        OBJ_TYPE_REF(D.103716;(const struct ObjectBase)D.103713->3) (D.103713);
        goto <D.103717>;
        <D.103708>:
        <D.103717>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102403>:
}


Glib::RefPtr<const Gio::ProxyResolver> Gio::SocketClient::get_proxy_resolver() const (const struct SocketClient * const this)
{
  struct RefPtr D.101205;

  D.101205 = Gio::SocketClient::get_proxy_resolver (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::ProxyResolver>::RefPtr<Gio::ProxyResolver> (<retval>, &D.101205);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::ProxyResolver>::~RefPtr (&D.101205);
      D.101205 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::ProxyResolver; T_CppObject = const Gio::ProxyResolver] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct ProxyResolver * D.103723;
  const struct ProxyResolver * D.103724;
  int (*__vtbl_ptr_type) () * D.103727;
  int (*__vtbl_ptr_type) () * D.103728;
  long int D.103729;
  sizetype D.103730;
  const struct ObjectBase * D.103731;
  int (*__vtbl_ptr_type) () * D.103732;
  int (*__vtbl_ptr_type) () * D.103733;
  int (*__vtbl_ptr_type) () D.103734;

  D.103723 = Glib::RefPtr<Gio::ProxyResolver>::operator-> (src);
  this->pCppObject_ = D.103723;
  D.103724 = this->pCppObject_;
  if (D.103724 != 0B) goto <D.103725>; else goto <D.103726>;
  <D.103725>:
  D.103724 = this->pCppObject_;
  D.103724 = this->pCppObject_;
  D.103727 = D.103724->D.99087._vptr.Interface;
  D.103728 = D.103727 + 18446744073709551592;
  D.103729 = MEM[(long int *)D.103728];
  D.103730 = (sizetype) D.103729;
  D.103731 = D.103724 + D.103730;
  D.103724 = this->pCppObject_;
  D.103724 = this->pCppObject_;
  D.103727 = D.103724->D.99087._vptr.Interface;
  D.103728 = D.103727 + 18446744073709551592;
  D.103729 = MEM[(long int *)D.103728];
  D.103730 = (sizetype) D.103729;
  D.103731 = D.103724 + D.103730;
  D.103732 = D.103731->_vptr.ObjectBase;
  D.103733 = D.103732 + 16;
  D.103734 = *D.103733;
  D.103724 = this->pCppObject_;
  D.103724 = this->pCppObject_;
  D.103727 = D.103724->D.99087._vptr.Interface;
  D.103728 = D.103727 + 18446744073709551592;
  D.103729 = MEM[(long int *)D.103728];
  D.103730 = (sizetype) D.103729;
  D.103731 = D.103724 + D.103730;
  OBJ_TYPE_REF(D.103734;(const struct ObjectBase)D.103731->2) (D.103731);
  goto <D.103735>;
  <D.103726>:
  <D.103735>:
}


void Gio::SocketClient::set_proxy_resolver(const Glib::RefPtr<Gio::ProxyResolver>&) (struct SocketClient * const this, const struct RefPtr & proxy_resolver)
{
  struct BaseObjectType * D.103736;
  struct GSocketClient * D.103737;

  D.103736 = Glib::unwrap<Gio::ProxyResolver> (proxy_resolver);
  D.103737 = Gio::SocketClient::gobj (this);
  g_socket_client_set_proxy_resolver (D.103737, D.103736);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::ProxyResolver; typename T::BaseObjectType = _GProxyResolver] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.103738;
  struct BaseObjectType * iftmp.79;
  bool D.103740;
  struct ProxyResolver * D.103743;

  D.103740 = Glib::RefPtr<Gio::ProxyResolver>::operator bool (ptr);
  if (D.103740 != 0) goto <D.103741>; else goto <D.103742>;
  <D.103741>:
  D.103743 = Glib::RefPtr<Gio::ProxyResolver>::operator-> (ptr);
  iftmp.79 = Gio::ProxyResolver::gobj (D.103743);
  goto <D.103744>;
  <D.103742>:
  iftmp.79 = 0B;
  <D.103744>:
  D.103738 = iftmp.79;
  return D.103738;
}


GProxyResolver* Gio::ProxyResolver::gobj() (struct ProxyResolver * const this)
{
  struct GProxyResolver * D.103746;
  int (*__vtbl_ptr_type) () * D.103747;
  int (*__vtbl_ptr_type) () * D.103748;
  long int D.103749;
  sizetype D.103750;
  struct ObjectBase * D.103751;

  D.103747 = this->D.99087._vptr.Interface;
  D.103748 = D.103747 + 18446744073709551592;
  D.103749 = MEM[(long int *)D.103748];
  D.103750 = (sizetype) D.103749;
  D.103751 = this + D.103750;
  D.103746 = D.103751->gobject_;
  return D.103746;
}


guint Gio::SocketClient::get_timeout() const (const struct SocketClient * const this)
{
  guint D.103753;
  const struct GSocketClient * D.103754;

  D.103754 = Gio::SocketClient::gobj (this);
  D.103753 = g_socket_client_get_timeout (D.103754);
  return D.103753;
}


void Gio::SocketClient::set_timeout(guint) (struct SocketClient * const this, guint timeout)
{
  struct GSocketClient * D.103757;

  D.103757 = Gio::SocketClient::gobj (this);
  g_socket_client_set_timeout (D.103757, timeout);
}


void Gio::SocketClient::add_application_proxy(const Glib::ustring&) (struct SocketClient * const this, const struct ustring & protocol)
{
  const char * D.103758;
  struct GSocketClient * D.103759;

  D.103758 = Glib::ustring::c_str (protocol);
  D.103759 = Gio::SocketClient::gobj (this);
  g_socket_client_add_application_proxy (D.103759, D.103758);
}


Glib::SignalProxy3<void, Gio::SocketClientEvent, const Glib::RefPtr<Gio::SocketConnectable>&, const Glib::RefPtr<Gio::IOStream>&> Gio::SocketClient::signal_event() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103762;
  int (*__vtbl_ptr_type) () * D.103763;
  long int D.103764;
  sizetype D.103765;
  struct ObjectBase * D.103766;

  D.103762 = this->D.99412._vptr.Object;
  D.103763 = D.103762 + 18446744073709551592;
  D.103764 = MEM[(long int *)D.103763];
  D.103765 = (sizetype) D.103764;
  D.103766 = this + D.103765;
  Glib::SignalProxy3<void, Gio::SocketClientEvent, const Glib::RefPtr<Gio::SocketConnectable>&, const Glib::RefPtr<Gio::IOStream>&>::SignalProxy3 (<retval>, D.103766, &SocketClient_signal_event_info);
  return <retval>;
}


void {anonymous}::SocketClient_signal_event_callback(GSocketClient*, GSocketClientEvent, GSocketConnectable*, GIOStream*, void*) (struct GSocketClient * self, GSocketClientEvent p0, struct GSocketConnectable * p1, struct GIOStream * p2, void * data)
{
  struct SocketClient * iftmp.80;
  struct ObjectBase * D.103769;
  struct RefPtr D.100143;
  struct RefPtr D.100018;
  const SocketClientEvent D.100144;
  struct slot3 * D.103777;
  void * D.103779;
  typedef struct SlotType SlotType;
  struct SocketClient * obj;

  D.103769 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.103769 == 0B) goto <D.103770>; else goto <D.103771>;
  <D.103770>:
  iftmp.80 = 0B;
  goto <D.103772>;
  <D.103771>:
  iftmp.80 = __dynamic_cast (D.103769, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio12SocketClientE, -1);
  <D.103772>:
  obj = iftmp.80;
  {
    if (obj != 0B) goto <D.103773>; else goto <D.103774>;
    <D.103773>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.103775>; else goto <D.103776>;
              <D.103775>:
              D.100143 = Glib::wrap (p2, 0); [return slot optimization]
              try
                {
                  D.100018 = Glib::wrap (p1, 0); [return slot optimization]
                  try
                    {
                      D.100144 = p0;
                      try
                        {
                          D.103777 = &MEM[(struct SlotType *)slot].D.100016;
                          sigc::slot3<void, Gio::SocketClientEvent, const Glib::RefPtr<Gio::SocketConnectable>&, const Glib::RefPtr<Gio::IOStream>&>::operator() (D.103777, &D.100144, &D.100018, &D.100143);
                        }
                      finally
                        {
                          D.100144 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (&D.100018);
                      D.100018 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::IOStream>::~RefPtr (&D.100143);
                  D.100143 = {CLOBBER};
                }
              goto <D.103778>;
              <D.103776>:
              <D.103778>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.103779 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.103779);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.103780>;
    <D.103774>:
    <D.103780>:
  }
}


static sigc::slot_base* Glib::SignalProxyBase::data_to_slot(void*) (void * data)
{
  struct slot_base * D.103788;
  struct slot_base * iftmp.81;
  struct slot_base * D.103790;
  bool D.103791;
  bool D.103792;
  struct SignalProxyConnectionNode * const pConnectionNode;

  pConnectionNode = data;
  D.103790 = &pConnectionNode->slot_;
  D.103791 = sigc::slot_base::blocked (D.103790);
  D.103792 = ~D.103791;
  if (D.103792 != 0) goto <D.103793>; else goto <D.103794>;
  <D.103793>:
  iftmp.81 = &pConnectionNode->slot_;
  goto <D.103795>;
  <D.103794>:
  iftmp.81 = 0B;
  <D.103795>:
  D.103788 = iftmp.81;
  return D.103788;
}


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

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


T_return sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::operator()(sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_) const [with T_return = void; T_arg1 = Gio::SocketClientEvent; T_arg2 = const Glib::RefPtr<Gio::SocketConnectable>&; T_arg3 = const Glib::RefPtr<Gio::IOStream>&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_ = const Gio::SocketClientEvent&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_ = const Glib::RefPtr<Gio::SocketConnectable>&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_ = const Glib::RefPtr<Gio::IOStream>&] (const struct slot3 * const this, const SocketClientEvent & _A_a1, const struct RefPtr & _A_a2, const struct RefPtr & _A_a3)
{
  bool retval.82;
  bool iftmp.83;
  const struct slot_base * D.103803;
  bool D.103804;
  bool D.103805;
  bool D.103807;
  bool D.103808;
  struct rep_type * D.103812;
  void * (*<T609>) (void *) D.103813;

  D.103803 = &this->D.99974;
  D.103804 = sigc::slot_base::empty (D.103803);
  D.103805 = ~D.103804;
  if (D.103805 != 0) goto <D.103806>; else goto <D.103801>;
  <D.103806>:
  D.103803 = &this->D.99974;
  D.103807 = sigc::slot_base::blocked (D.103803);
  D.103808 = ~D.103807;
  if (D.103808 != 0) goto <D.103809>; else goto <D.103801>;
  <D.103809>:
  iftmp.83 = 1;
  goto <D.103802>;
  <D.103801>:
  iftmp.83 = 0;
  <D.103802>:
  retval.82 = iftmp.83;
  if (retval.82 != 0) goto <D.103810>; else goto <D.103811>;
  <D.103810>:
  D.103812 = this->D.99974.rep_;
  D.103813 = D.103812->call_;
  D.103812 = this->D.99974.rep_;
  D.103813 (D.103812, _A_a1, _A_a2, _A_a3);
  return;
  <D.103811>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.103815;
  bool iftmp.84;
  struct rep_type * D.103820;
  void * (*<T609>) (void *) D.103822;

  D.103820 = this->rep_;
  if (D.103820 == 0B) goto <D.103817>; else goto <D.103821>;
  <D.103821>:
  D.103820 = this->rep_;
  D.103822 = D.103820->call_;
  if (D.103822 == 0B) goto <D.103817>; else goto <D.103818>;
  <D.103817>:
  iftmp.84 = 1;
  goto <D.103819>;
  <D.103818>:
  iftmp.84 = 0;
  <D.103819>:
  D.103815 = iftmp.84;
  return D.103815;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnectable] (struct RefPtr * const this)
{
  struct SocketConnectable * D.103824;
  int (*__vtbl_ptr_type) () * D.103827;
  int (*__vtbl_ptr_type) () * D.103828;
  long int D.103829;
  sizetype D.103830;
  struct ObjectBase * D.103831;
  int (*__vtbl_ptr_type) () * D.103832;
  int (*__vtbl_ptr_type) () * D.103833;
  int (*__vtbl_ptr_type) () D.103834;

  {
    try
      {
        D.103824 = this->pCppObject_;
        if (D.103824 != 0B) goto <D.103825>; else goto <D.103826>;
        <D.103825>:
        D.103824 = this->pCppObject_;
        D.103824 = this->pCppObject_;
        D.103827 = D.103824->D.86415._vptr.Interface;
        D.103828 = D.103827 + 18446744073709551592;
        D.103829 = MEM[(long int *)D.103828];
        D.103830 = (sizetype) D.103829;
        D.103831 = D.103824 + D.103830;
        D.103824 = this->pCppObject_;
        D.103824 = this->pCppObject_;
        D.103827 = D.103824->D.86415._vptr.Interface;
        D.103828 = D.103827 + 18446744073709551592;
        D.103829 = MEM[(long int *)D.103828];
        D.103830 = (sizetype) D.103829;
        D.103831 = D.103824 + D.103830;
        D.103832 = D.103831->_vptr.ObjectBase;
        D.103833 = D.103832 + 24;
        D.103834 = *D.103833;
        D.103824 = this->pCppObject_;
        D.103824 = this->pCppObject_;
        D.103827 = D.103824->D.86415._vptr.Interface;
        D.103828 = D.103827 + 18446744073709551592;
        D.103829 = MEM[(long int *)D.103828];
        D.103830 = (sizetype) D.103829;
        D.103831 = D.103824 + D.103830;
        OBJ_TYPE_REF(D.103834;(const struct ObjectBase)D.103831->3) (D.103831);
        goto <D.103835>;
        <D.103826>:
        <D.103835>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102332>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::IOStream] (struct RefPtr * const this)
{
  struct IOStream * D.103837;
  int (*__vtbl_ptr_type) () * D.103840;
  int (*__vtbl_ptr_type) () * D.103841;
  long int D.103842;
  sizetype D.103843;
  struct ObjectBase * D.103844;
  int (*__vtbl_ptr_type) () * D.103845;
  int (*__vtbl_ptr_type) () * D.103846;
  int (*__vtbl_ptr_type) () D.103847;

  {
    try
      {
        D.103837 = this->pCppObject_;
        if (D.103837 != 0B) goto <D.103838>; else goto <D.103839>;
        <D.103838>:
        D.103837 = this->pCppObject_;
        D.103837 = this->pCppObject_;
        D.103840 = D.103837->D.98812._vptr.Object;
        D.103841 = D.103840 + 18446744073709551592;
        D.103842 = MEM[(long int *)D.103841];
        D.103843 = (sizetype) D.103842;
        D.103844 = D.103837 + D.103843;
        D.103837 = this->pCppObject_;
        D.103837 = this->pCppObject_;
        D.103840 = D.103837->D.98812._vptr.Object;
        D.103841 = D.103840 + 18446744073709551592;
        D.103842 = MEM[(long int *)D.103841];
        D.103843 = (sizetype) D.103842;
        D.103844 = D.103837 + D.103843;
        D.103845 = D.103844->_vptr.ObjectBase;
        D.103846 = D.103845 + 24;
        D.103847 = *D.103846;
        D.103837 = this->pCppObject_;
        D.103837 = this->pCppObject_;
        D.103840 = D.103837->D.98812._vptr.Object;
        D.103841 = D.103840 + 18446744073709551592;
        D.103842 = MEM[(long int *)D.103841];
        D.103843 = (sizetype) D.103842;
        D.103844 = D.103837 + D.103843;
        OBJ_TYPE_REF(D.103847;(const struct ObjectBase)D.103844->3) (D.103844);
        goto <D.103848>;
        <D.103839>:
        <D.103848>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102339>:
}


Glib::SignalProxy3<R, P1, P2, P3>::SignalProxy3(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void; P1 = Gio::SocketClientEvent; P2 = const Glib::RefPtr<Gio::SocketConnectable>&; P3 = const Glib::RefPtr<Gio::IOStream>&] (struct SignalProxy3 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.103850;

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

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


Glib::PropertyProxy<Gio::SocketFamily> Gio::SocketClient::property_family() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103852;
  int (*__vtbl_ptr_type) () * D.103853;
  long int D.103854;
  sizetype D.103855;
  struct ObjectBase * D.103856;

  D.103852 = this->D.99412._vptr.Object;
  D.103853 = D.103852 + 18446744073709551592;
  D.103854 = MEM[(long int *)D.103853];
  D.103855 = (sizetype) D.103854;
  D.103856 = this + D.103855;
  Glib::PropertyProxy<Gio::SocketFamily>::PropertyProxy (<retval>, D.103856, "family");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Gio::SocketFamily] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103858;

  D.103858 = &this->D.101324;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103858, obj, name);
}


Glib::PropertyProxy_ReadOnly<Gio::SocketFamily> Gio::SocketClient::property_family() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103860;
  int (*__vtbl_ptr_type) () * D.103861;
  long int D.103862;
  sizetype D.103863;
  const struct ObjectBase * D.103864;

  D.103860 = this->D.99412._vptr.Object;
  D.103861 = D.103860 + 18446744073709551592;
  D.103862 = MEM[(long int *)D.103861];
  D.103863 = (sizetype) D.103862;
  D.103864 = this + D.103863;
  Glib::PropertyProxy_ReadOnly<Gio::SocketFamily>::PropertyProxy_ReadOnly (<retval>, D.103864, "family");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Gio::SocketFamily] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103866;

  D.103866 = &this->D.101369;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103866, obj, name);
}


Glib::PropertyProxy<Glib::RefPtr<Gio::SocketAddress> > Gio::SocketClient::property_local_address() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103868;
  int (*__vtbl_ptr_type) () * D.103869;
  long int D.103870;
  sizetype D.103871;
  struct ObjectBase * D.103872;

  D.103868 = this->D.99412._vptr.Object;
  D.103869 = D.103868 + 18446744073709551592;
  D.103870 = MEM[(long int *)D.103869];
  D.103871 = (sizetype) D.103870;
  D.103872 = this + D.103871;
  Glib::PropertyProxy<Glib::RefPtr<Gio::SocketAddress> >::PropertyProxy (<retval>, D.103872, "local-address");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::SocketAddress>] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103874;

  D.103874 = &this->D.101413;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103874, obj, name);
}


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> > Gio::SocketClient::property_local_address() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103876;
  int (*__vtbl_ptr_type) () * D.103877;
  long int D.103878;
  sizetype D.103879;
  const struct ObjectBase * D.103880;

  D.103876 = this->D.99412._vptr.Object;
  D.103877 = D.103876 + 18446744073709551592;
  D.103878 = MEM[(long int *)D.103877];
  D.103879 = (sizetype) D.103878;
  D.103880 = this + D.103879;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> >::PropertyProxy_ReadOnly (<retval>, D.103880, "local-address");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::SocketAddress>] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103882;

  D.103882 = &this->D.101449;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103882, obj, name);
}


Glib::PropertyProxy<Gio::SocketProtocol> Gio::SocketClient::property_protocol() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103884;
  int (*__vtbl_ptr_type) () * D.103885;
  long int D.103886;
  sizetype D.103887;
  struct ObjectBase * D.103888;

  D.103884 = this->D.99412._vptr.Object;
  D.103885 = D.103884 + 18446744073709551592;
  D.103886 = MEM[(long int *)D.103885];
  D.103887 = (sizetype) D.103886;
  D.103888 = this + D.103887;
  Glib::PropertyProxy<Gio::SocketProtocol>::PropertyProxy (<retval>, D.103888, "protocol");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Gio::SocketProtocol] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103890;

  D.103890 = &this->D.101493;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103890, obj, name);
}


Glib::PropertyProxy_ReadOnly<Gio::SocketProtocol> Gio::SocketClient::property_protocol() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103892;
  int (*__vtbl_ptr_type) () * D.103893;
  long int D.103894;
  sizetype D.103895;
  const struct ObjectBase * D.103896;

  D.103892 = this->D.99412._vptr.Object;
  D.103893 = D.103892 + 18446744073709551592;
  D.103894 = MEM[(long int *)D.103893];
  D.103895 = (sizetype) D.103894;
  D.103896 = this + D.103895;
  Glib::PropertyProxy_ReadOnly<Gio::SocketProtocol>::PropertyProxy_ReadOnly (<retval>, D.103896, "protocol");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Gio::SocketProtocol] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103898;

  D.103898 = &this->D.101529;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103898, obj, name);
}


Glib::PropertyProxy<Gio::SocketType> Gio::SocketClient::property_type() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103900;
  int (*__vtbl_ptr_type) () * D.103901;
  long int D.103902;
  sizetype D.103903;
  struct ObjectBase * D.103904;

  D.103900 = this->D.99412._vptr.Object;
  D.103901 = D.103900 + 18446744073709551592;
  D.103902 = MEM[(long int *)D.103901];
  D.103903 = (sizetype) D.103902;
  D.103904 = this + D.103903;
  Glib::PropertyProxy<Gio::SocketType>::PropertyProxy (<retval>, D.103904, "type");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Gio::SocketType] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103906;

  D.103906 = &this->D.101573;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103906, obj, name);
}


Glib::PropertyProxy_ReadOnly<Gio::SocketType> Gio::SocketClient::property_type() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103908;
  int (*__vtbl_ptr_type) () * D.103909;
  long int D.103910;
  sizetype D.103911;
  const struct ObjectBase * D.103912;

  D.103908 = this->D.99412._vptr.Object;
  D.103909 = D.103908 + 18446744073709551592;
  D.103910 = MEM[(long int *)D.103909];
  D.103911 = (sizetype) D.103910;
  D.103912 = this + D.103911;
  Glib::PropertyProxy_ReadOnly<Gio::SocketType>::PropertyProxy_ReadOnly (<retval>, D.103912, "type");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Gio::SocketType] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103914;

  D.103914 = &this->D.101609;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103914, obj, name);
}


Glib::PropertyProxy<unsigned int> Gio::SocketClient::property_timeout() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103916;
  int (*__vtbl_ptr_type) () * D.103917;
  long int D.103918;
  sizetype D.103919;
  struct ObjectBase * D.103920;

  D.103916 = this->D.99412._vptr.Object;
  D.103917 = D.103916 + 18446744073709551592;
  D.103918 = MEM[(long int *)D.103917];
  D.103919 = (sizetype) D.103918;
  D.103920 = this + D.103919;
  Glib::PropertyProxy<unsigned int>::PropertyProxy (<retval>, D.103920, "timeout");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = unsigned int] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103922;

  D.103922 = &this->D.101653;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103922, obj, name);
}


Glib::PropertyProxy_ReadOnly<unsigned int> Gio::SocketClient::property_timeout() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103924;
  int (*__vtbl_ptr_type) () * D.103925;
  long int D.103926;
  sizetype D.103927;
  const struct ObjectBase * D.103928;

  D.103924 = this->D.99412._vptr.Object;
  D.103925 = D.103924 + 18446744073709551592;
  D.103926 = MEM[(long int *)D.103925];
  D.103927 = (sizetype) D.103926;
  D.103928 = this + D.103927;
  Glib::PropertyProxy_ReadOnly<unsigned int>::PropertyProxy_ReadOnly (<retval>, D.103928, "timeout");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = unsigned int] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103930;

  D.103930 = &this->D.101689;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103930, obj, name);
}


Glib::PropertyProxy<bool> Gio::SocketClient::property_enable_proxy() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103932;
  int (*__vtbl_ptr_type) () * D.103933;
  long int D.103934;
  sizetype D.103935;
  struct ObjectBase * D.103936;

  D.103932 = this->D.99412._vptr.Object;
  D.103933 = D.103932 + 18446744073709551592;
  D.103934 = MEM[(long int *)D.103933];
  D.103935 = (sizetype) D.103934;
  D.103936 = this + D.103935;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.103936, "enable-proxy");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = bool] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103938;

  D.103938 = &this->D.101733;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103938, obj, name);
}


Glib::PropertyProxy_ReadOnly<bool> Gio::SocketClient::property_enable_proxy() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103940;
  int (*__vtbl_ptr_type) () * D.103941;
  long int D.103942;
  sizetype D.103943;
  const struct ObjectBase * D.103944;

  D.103940 = this->D.99412._vptr.Object;
  D.103941 = D.103940 + 18446744073709551592;
  D.103942 = MEM[(long int *)D.103941];
  D.103943 = (sizetype) D.103942;
  D.103944 = this + D.103943;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.103944, "enable-proxy");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = bool] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103946;

  D.103946 = &this->D.101769;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103946, obj, name);
}


Glib::PropertyProxy<bool> Gio::SocketClient::property_tls() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103948;
  int (*__vtbl_ptr_type) () * D.103949;
  long int D.103950;
  sizetype D.103951;
  struct ObjectBase * D.103952;

  D.103948 = this->D.99412._vptr.Object;
  D.103949 = D.103948 + 18446744073709551592;
  D.103950 = MEM[(long int *)D.103949];
  D.103951 = (sizetype) D.103950;
  D.103952 = this + D.103951;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.103952, "tls");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<bool> Gio::SocketClient::property_tls() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103955;
  int (*__vtbl_ptr_type) () * D.103956;
  long int D.103957;
  sizetype D.103958;
  const struct ObjectBase * D.103959;

  D.103955 = this->D.99412._vptr.Object;
  D.103956 = D.103955 + 18446744073709551592;
  D.103957 = MEM[(long int *)D.103956];
  D.103958 = (sizetype) D.103957;
  D.103959 = this + D.103958;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.103959, "tls");
  return <retval>;
}


Glib::PropertyProxy<Gio::TlsCertificateFlags> Gio::SocketClient::property_tls_validation_flags() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103962;
  int (*__vtbl_ptr_type) () * D.103963;
  long int D.103964;
  sizetype D.103965;
  struct ObjectBase * D.103966;

  D.103962 = this->D.99412._vptr.Object;
  D.103963 = D.103962 + 18446744073709551592;
  D.103964 = MEM[(long int *)D.103963];
  D.103965 = (sizetype) D.103964;
  D.103966 = this + D.103965;
  Glib::PropertyProxy<Gio::TlsCertificateFlags>::PropertyProxy (<retval>, D.103966, "tls-validation-flags");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Gio::TlsCertificateFlags] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103968;

  D.103968 = &this->D.101821;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103968, obj, name);
}


Glib::PropertyProxy_ReadOnly<Gio::TlsCertificateFlags> Gio::SocketClient::property_tls_validation_flags() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103970;
  int (*__vtbl_ptr_type) () * D.103971;
  long int D.103972;
  sizetype D.103973;
  const struct ObjectBase * D.103974;

  D.103970 = this->D.99412._vptr.Object;
  D.103971 = D.103970 + 18446744073709551592;
  D.103972 = MEM[(long int *)D.103971];
  D.103973 = (sizetype) D.103972;
  D.103974 = this + D.103973;
  Glib::PropertyProxy_ReadOnly<Gio::TlsCertificateFlags>::PropertyProxy_ReadOnly (<retval>, D.103974, "tls-validation-flags");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Gio::TlsCertificateFlags] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103976;

  D.103976 = &this->D.101857;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103976, obj, name);
}


Glib::PropertyProxy<Glib::RefPtr<Gio::ProxyResolver> > Gio::SocketClient::property_proxy_resolver() (struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103978;
  int (*__vtbl_ptr_type) () * D.103979;
  long int D.103980;
  sizetype D.103981;
  struct ObjectBase * D.103982;

  D.103978 = this->D.99412._vptr.Object;
  D.103979 = D.103978 + 18446744073709551592;
  D.103980 = MEM[(long int *)D.103979];
  D.103981 = (sizetype) D.103980;
  D.103982 = this + D.103981;
  Glib::PropertyProxy<Glib::RefPtr<Gio::ProxyResolver> >::PropertyProxy (<retval>, D.103982, "proxy-resolver");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::ProxyResolver>] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103984;

  D.103984 = &this->D.101901;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103984, obj, name);
}


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::ProxyResolver> > Gio::SocketClient::property_proxy_resolver() const (const struct SocketClient * const this)
{
  int (*__vtbl_ptr_type) () * D.103986;
  int (*__vtbl_ptr_type) () * D.103987;
  long int D.103988;
  sizetype D.103989;
  const struct ObjectBase * D.103990;

  D.103986 = this->D.99412._vptr.Object;
  D.103987 = D.103986 + 18446744073709551592;
  D.103988 = MEM[(long int *)D.103987];
  D.103989 = (sizetype) D.103988;
  D.103990 = this + D.103989;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::ProxyResolver> >::PropertyProxy_ReadOnly (<retval>, D.103990, "proxy-resolver");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::ProxyResolver>] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.103992;

  D.103992 = &this->D.101937;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.103992, obj, name);
}