Glib::RefPtr<Gio::SocketService> Glib::wrap(GSocketService*, bool) (struct GSocketService * object, bool take_copy)
{
  struct SocketService * iftmp.0;
  int D.100834;
  struct ObjectBase * D.100835;

  D.100834 = (int) take_copy;
  D.100835 = Glib::wrap_auto (object, D.100834);
  if (D.100835 == 0B) goto <D.100836>; else goto <D.100837>;
  <D.100836>:
  iftmp.0 = 0B;
  goto <D.100838>;
  <D.100837>:
  iftmp.0 = __dynamic_cast (D.100835, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio13SocketServiceE, -1);
  <D.100838>:
  Glib::RefPtr<Gio::SocketService>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::SocketService_Class::init() (struct SocketService_Class * const this)
{
  long unsigned int D.100841;
  long unsigned int D.100844;
  struct Class * D.100845;
  const struct Class & D.100847;

  D.100841 = this->D.99344.gtype_;
  if (D.100841 == 0) goto <D.100842>; else goto <D.100843>;
  <D.100842>:
  this->D.99344.class_init_func_ = class_init_function;
  D.100844 = g_socket_service_get_type ();
  D.100845 = &this->D.99344;
  Glib::Class::register_derived_type (D.100845, D.100844);
  goto <D.100846>;
  <D.100843>:
  <D.100846>:
  D.100847 = &this->D.99344;
  return D.100847;
}


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

  klass = g_class;
  Gio::SocketListener_Class::class_init_function (klass, class_data);
  klass->incoming = incoming_callback;
}


static gboolean Gio::SocketService_Class::incoming_callback(GSocketService*, GSocketConnection*, GObject*) (struct GSocketService * self, struct GSocketConnection * p0, struct GObject * p1)
{
  bool retval.1;
  bool iftmp.2;
  bool D.100855;
  struct CppObjectType * const iftmp.3;
  gboolean D.100865;
  int (*__vtbl_ptr_type) () * D.100866;
  int (*__vtbl_ptr_type) () * D.100867;
  int (*__vtbl_ptr_type) () D.100868;
  struct RefPtr D.99987;
  struct RefPtr D.99986;
  bool D.100869;
  void * D.100870;
  struct GTypeClass * D.100873;
  gboolean (*<T10fcf>) (struct GSocketService *, struct GSocketConnection *, struct GObject *) D.100876;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.100854>; else goto <D.100852>;
    <D.100854>:
    D.100855 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.100855 != 0) goto <D.100856>; else goto <D.100852>;
    <D.100856>:
    iftmp.2 = 1;
    goto <D.100853>;
    <D.100852>:
    iftmp.2 = 0;
    <D.100853>:
    retval.1 = iftmp.2;
    if (retval.1 != 0) goto <D.100857>; else goto <D.100858>;
    <D.100857>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.100860>; else goto <D.100861>;
      <D.100860>:
      iftmp.3 = 0B;
      goto <D.100862>;
      <D.100861>:
      iftmp.3 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio13SocketServiceE, -1);
      <D.100862>:
      obj = iftmp.3;
      if (obj != 0B) goto <D.100863>; else goto <D.100864>;
      <D.100863>:
      try
        {
          D.100866 = obj->D.99282.D.99157._vptr.Object;
          D.100867 = D.100866 + 16;
          D.100868 = *D.100867;
          D.99987 = Glib::wrap (p1, 1); [return slot optimization]
          try
            {
              D.99986 = Glib::wrap (p0, 1); [return slot optimization]
              try
                {
                  D.100869 = OBJ_TYPE_REF(D.100868;(struct SocketService)obj->2) (obj, &D.99986, &D.99987);
                  D.100865 = (gboolean) D.100869;
                  return D.100865;
                }
              finally
                {
                  Glib::RefPtr<Gio::SocketConnection>::~RefPtr (&D.99986);
                  D.99986 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Glib::Object>::~RefPtr (&D.99987);
              D.99987 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.100870 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.100870);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.100871>;
      <D.100864>:
      <D.100871>:
    }
    goto <D.100872>;
    <D.100858>:
    <D.100872>:
  }
  D.100873 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.100873);
  if (base != 0B) goto <D.100874>; else goto <D.100875>;
  <D.100874>:
  D.100876 = base->incoming;
  if (D.100876 != 0B) goto <D.100877>; else goto <D.100878>;
  <D.100877>:
  D.100876 = base->incoming;
  D.100865 = D.100876 (self, p0, p1);
  return D.100865;
  <D.100878>:
  <D.100875>:
  D.100865 = 0;
  return D.100865;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnection] (struct RefPtr * const this)
{
  struct SocketConnection * D.100893;
  int (*__vtbl_ptr_type) () * D.100896;
  int (*__vtbl_ptr_type) () * D.100897;
  long int D.100898;
  sizetype D.100899;
  struct ObjectBase * D.100900;
  int (*__vtbl_ptr_type) () * D.100901;
  int (*__vtbl_ptr_type) () * D.100902;
  int (*__vtbl_ptr_type) () D.100903;

  {
    try
      {
        D.100893 = this->pCppObject_;
        if (D.100893 != 0B) goto <D.100894>; else goto <D.100895>;
        <D.100894>:
        D.100893 = this->pCppObject_;
        D.100893 = this->pCppObject_;
        D.100896 = D.100893->D.98951.D.98812._vptr.Object;
        D.100897 = D.100896 + 18446744073709551592;
        D.100898 = MEM[(long int *)D.100897];
        D.100899 = (sizetype) D.100898;
        D.100900 = D.100893 + D.100899;
        D.100893 = this->pCppObject_;
        D.100893 = this->pCppObject_;
        D.100896 = D.100893->D.98951.D.98812._vptr.Object;
        D.100897 = D.100896 + 18446744073709551592;
        D.100898 = MEM[(long int *)D.100897];
        D.100899 = (sizetype) D.100898;
        D.100900 = D.100893 + D.100899;
        D.100901 = D.100900->_vptr.ObjectBase;
        D.100902 = D.100901 + 24;
        D.100903 = *D.100902;
        D.100893 = this->pCppObject_;
        D.100893 = this->pCppObject_;
        D.100896 = D.100893->D.98951.D.98812._vptr.Object;
        D.100897 = D.100896 + 18446744073709551592;
        D.100898 = MEM[(long int *)D.100897];
        D.100899 = (sizetype) D.100898;
        D.100900 = D.100893 + D.100899;
        OBJ_TYPE_REF(D.100903;(const struct ObjectBase)D.100900->3) (D.100900);
        goto <D.100904>;
        <D.100895>:
        <D.100904>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100480>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Glib::Object] (struct RefPtr * const this)
{
  struct Object * D.100906;
  int (*__vtbl_ptr_type) () * D.100909;
  int (*__vtbl_ptr_type) () * D.100910;
  long int D.100911;
  sizetype D.100912;
  struct ObjectBase * D.100913;
  int (*__vtbl_ptr_type) () * D.100914;
  int (*__vtbl_ptr_type) () * D.100915;
  int (*__vtbl_ptr_type) () D.100916;

  {
    try
      {
        D.100906 = this->pCppObject_;
        if (D.100906 != 0B) goto <D.100907>; else goto <D.100908>;
        <D.100907>:
        D.100906 = this->pCppObject_;
        D.100906 = this->pCppObject_;
        D.100909 = D.100906->_vptr.Object;
        D.100910 = D.100909 + 18446744073709551592;
        D.100911 = MEM[(long int *)D.100910];
        D.100912 = (sizetype) D.100911;
        D.100913 = D.100906 + D.100912;
        D.100906 = this->pCppObject_;
        D.100906 = this->pCppObject_;
        D.100909 = D.100906->_vptr.Object;
        D.100910 = D.100909 + 18446744073709551592;
        D.100911 = MEM[(long int *)D.100910];
        D.100912 = (sizetype) D.100911;
        D.100913 = D.100906 + D.100912;
        D.100914 = D.100913->_vptr.ObjectBase;
        D.100915 = D.100914 + 24;
        D.100916 = *D.100915;
        D.100906 = this->pCppObject_;
        D.100906 = this->pCppObject_;
        D.100909 = D.100906->_vptr.Object;
        D.100910 = D.100909 + 18446744073709551592;
        D.100911 = MEM[(long int *)D.100910];
        D.100912 = (sizetype) D.100911;
        D.100913 = D.100906 + D.100912;
        OBJ_TYPE_REF(D.100916;(const struct ObjectBase)D.100913->3) (D.100913);
        goto <D.100917>;
        <D.100908>:
        <D.100917>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100487>:
}


static Glib::ObjectBase* Gio::SocketService_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.100919;
  struct ObjectBase * iftmp.4;
  void * D.99994;
  void * D.100921;
  int (*__vtbl_ptr_type) () * D.100924;
  int (*__vtbl_ptr_type) () * D.100925;
  long int D.100926;
  sizetype D.100927;

  D.99994 = operator new (48);
  try
    {
      Gio::SocketService::SocketService (D.99994, object);
    }
  catch
    {
      operator delete (D.99994);
    }
  D.100921 = D.99994;
  if (D.100921 != 0B) goto <D.100922>; else goto <D.100923>;
  <D.100922>:
  D.100924 = MEM[(struct SocketService *)D.100921].D.99282.D.99157._vptr.Object;
  D.100925 = D.100924 + 18446744073709551592;
  D.100926 = MEM[(long int *)D.100925];
  D.100927 = (sizetype) D.100926;
  iftmp.4 = D.100921 + D.100927;
  goto <D.100928>;
  <D.100923>:
  iftmp.4 = 0B;
  <D.100928>:
  D.100919 = iftmp.4;
  return D.100919;
}


GSocketService* Gio::SocketService::gobj_copy() (struct SocketService * const this)
{
  int (*__vtbl_ptr_type) () * D.100932;
  int (*__vtbl_ptr_type) () * D.100933;
  long int D.100934;
  sizetype D.100935;
  struct ObjectBase * D.100936;
  int (*__vtbl_ptr_type) () * D.100937;
  int (*__vtbl_ptr_type) () * D.100938;
  int (*__vtbl_ptr_type) () D.100939;
  struct GSocketService * D.100940;

  D.100932 = this->D.99282.D.99157._vptr.Object;
  D.100933 = D.100932 + 18446744073709551592;
  D.100934 = MEM[(long int *)D.100933];
  D.100935 = (sizetype) D.100934;
  D.100936 = this + D.100935;
  D.100932 = this->D.99282.D.99157._vptr.Object;
  D.100933 = D.100932 + 18446744073709551592;
  D.100934 = MEM[(long int *)D.100933];
  D.100935 = (sizetype) D.100934;
  D.100936 = this + D.100935;
  D.100937 = D.100936->_vptr.ObjectBase;
  D.100938 = D.100937 + 16;
  D.100939 = *D.100938;
  D.100932 = this->D.99282.D.99157._vptr.Object;
  D.100933 = D.100932 + 18446744073709551592;
  D.100934 = MEM[(long int *)D.100933];
  D.100935 = (sizetype) D.100934;
  D.100936 = this + D.100935;
  OBJ_TYPE_REF(D.100939;(const struct ObjectBase)D.100936->2) (D.100936);
  D.100940 = Gio::SocketService::gobj (this);
  return D.100940;
}


GSocketService* Gio::SocketService::gobj() (struct SocketService * const this)
{
  struct GSocketService * D.100942;
  int (*__vtbl_ptr_type) () * D.100943;
  int (*__vtbl_ptr_type) () * D.100944;
  long int D.100945;
  sizetype D.100946;
  struct ObjectBase * D.100947;

  D.100943 = this->D.99282.D.99157._vptr.Object;
  D.100944 = D.100943 + 18446744073709551592;
  D.100945 = MEM[(long int *)D.100944];
  D.100946 = (sizetype) D.100945;
  D.100947 = this + D.100946;
  D.100942 = D.100947->gobject_;
  return D.100942;
}


Gio::SocketService::SocketService(const Glib::ConstructParams&) (struct SocketService * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.100951;
  const void * * iftmp.5;
  struct ObjectBase * D.100959;
  const void * * iftmp.6;
  struct SocketListener * D.100965;
  int (*__vtbl_ptr_type) () * iftmp.7;
  sizetype iftmp.8;
  int (*__vtbl_ptr_type) () * D.100973;
  int (*__vtbl_ptr_type) () * D.100974;
  long int D.100975;
  struct ObjectBase * D.100977;
  int (*__vtbl_ptr_type) () * iftmp.9;
  const void * * iftmp.10;
  const void * * iftmp.11;

  if (0 != 0) goto <D.100949>; else goto <D.100950>;
  <D.100949>:
  D.100951 = &this->D.99285;
  sigc::trackable::trackable (D.100951);
  goto <D.100952>;
  <D.100950>:
  <D.100952>:
  try
    {
      if (0 != 0) goto <D.100953>; else goto <D.100954>;
      <D.100953>:
      if (0 == 0) goto <D.100956>; else goto <D.100957>;
      <D.100956>:
      iftmp.5 = __vtt_parm + 48;
      goto <D.100958>;
      <D.100957>:
      iftmp.5 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.100958>:
      D.100959 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.100959, iftmp.5);
      goto <D.100960>;
      <D.100954>:
      <D.100960>:
      try
        {
          if (0 == 0) goto <D.100962>; else goto <D.100963>;
          <D.100962>:
          iftmp.6 = __vtt_parm + 8;
          goto <D.100964>;
          <D.100963>:
          iftmp.6 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
          <D.100964>:
          D.100965 = &this->D.99282;
          Gio::SocketListener::SocketListener (D.100965, iftmp.6, construct_params);
          try
            {
              if (0 == 0) goto <D.100967>; else goto <D.100968>;
              <D.100967>:
              iftmp.7 = *__vtt_parm;
              goto <D.100969>;
              <D.100968>:
              iftmp.7 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.100969>:
              this->D.99282.D.99157._vptr.Object = iftmp.7;
              if (0 == 0) goto <D.100971>; else goto <D.100972>;
              <D.100971>:
              D.100973 = this->D.99282.D.99157._vptr.Object;
              D.100974 = D.100973 + 18446744073709551592;
              D.100975 = MEM[(long int *)D.100974];
              iftmp.8 = (sizetype) D.100975;
              goto <D.100976>;
              <D.100972>:
              iftmp.8 = 8;
              <D.100976>:
              D.100977 = this + iftmp.8;
              if (0 == 0) goto <D.100979>; else goto <D.100980>;
              <D.100979>:
              iftmp.9 = MEM[(const void * *)__vtt_parm + 40B];
              goto <D.100981>;
              <D.100980>:
              iftmp.9 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.100981>:
              D.100977->_vptr.ObjectBase = iftmp.9;
            }
          catch
            {
              if (0 == 0) goto <D.100983>; else goto <D.100984>;
              <D.100983>:
              iftmp.10 = __vtt_parm + 8;
              goto <D.100985>;
              <D.100984>:
              iftmp.10 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.100985>:
              D.100965 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.100965, iftmp.10);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100986>; else goto <D.100987>;
          <D.100986>:
          if (0 == 0) goto <D.100989>; else goto <D.100990>;
          <D.100989>:
          iftmp.11 = __vtt_parm + 48;
          goto <D.100991>;
          <D.100990>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.100991>:
          D.100959 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.100959, iftmp.11);
          goto <D.100992>;
          <D.100987>:
          <D.100992>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100993>; else goto <D.100994>;
      <D.100993>:
      D.100951 = &this->D.99285;
      sigc::trackable::~trackable (D.100951);
      goto <D.100995>;
      <D.100994>:
      <D.100995>:
    }
}


Gio::SocketService::SocketService(const Glib::ConstructParams&) (struct SocketService * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.101000;
  const void * * iftmp.12;
  struct ObjectBase * D.101008;
  const void * * iftmp.13;
  struct SocketListener * D.101014;
  int (*__vtbl_ptr_type) () * iftmp.14;
  const void * * D.101018;
  sizetype iftmp.15;
  int (*__vtbl_ptr_type) () * D.101023;
  int (*__vtbl_ptr_type) () * D.101024;
  long int D.101025;
  struct ObjectBase * D.101027;
  int (*__vtbl_ptr_type) () * iftmp.16;
  const void * * iftmp.17;
  const void * * iftmp.18;

  if (1 != 0) goto <D.100998>; else goto <D.100999>;
  <D.100998>:
  D.101000 = &this->D.99285;
  sigc::trackable::trackable (D.101000);
  goto <D.101001>;
  <D.100999>:
  <D.101001>:
  try
    {
      if (1 != 0) goto <D.101002>; else goto <D.101003>;
      <D.101002>:
      if (1 == 0) goto <D.101005>; else goto <D.101006>;
      <D.101005>:
      iftmp.12 = 48B;
      goto <D.101007>;
      <D.101006>:
      iftmp.12 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.101007>:
      D.101008 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.101008, iftmp.12);
      goto <D.101009>;
      <D.101003>:
      <D.101009>:
      try
        {
          if (1 == 0) goto <D.101011>; else goto <D.101012>;
          <D.101011>:
          iftmp.13 = 8B;
          goto <D.101013>;
          <D.101012>:
          iftmp.13 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
          <D.101013>:
          D.101014 = &this->D.99282;
          Gio::SocketListener::SocketListener (D.101014, iftmp.13, construct_params);
          try
            {
              if (1 == 0) goto <D.101016>; else goto <D.101017>;
              <D.101016>:
              D.101018 = 0B;
              iftmp.14 = *D.101018;
              goto <D.101019>;
              <D.101017>:
              iftmp.14 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.101019>:
              this->D.99282.D.99157._vptr.Object = iftmp.14;
              if (1 == 0) goto <D.101021>; else goto <D.101022>;
              <D.101021>:
              D.101023 = this->D.99282.D.99157._vptr.Object;
              D.101024 = D.101023 + 18446744073709551592;
              D.101025 = MEM[(long int *)D.101024];
              iftmp.15 = (sizetype) D.101025;
              goto <D.101026>;
              <D.101022>:
              iftmp.15 = 8;
              <D.101026>:
              D.101027 = this + iftmp.15;
              if (1 == 0) goto <D.101029>; else goto <D.101030>;
              <D.101029>:
              iftmp.16 = MEM[(const void * *)0B + 40B];
              goto <D.101031>;
              <D.101030>:
              iftmp.16 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.101031>:
              D.101027->_vptr.ObjectBase = iftmp.16;
            }
          catch
            {
              if (1 == 0) goto <D.101033>; else goto <D.101034>;
              <D.101033>:
              iftmp.17 = 8B;
              goto <D.101035>;
              <D.101034>:
              iftmp.17 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101035>:
              D.101014 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.101014, iftmp.17);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101036>; else goto <D.101037>;
          <D.101036>:
          if (1 == 0) goto <D.101039>; else goto <D.101040>;
          <D.101039>:
          iftmp.18 = 48B;
          goto <D.101041>;
          <D.101040>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.101041>:
          D.101008 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.101008, iftmp.18);
          goto <D.101042>;
          <D.101037>:
          <D.101042>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101043>; else goto <D.101044>;
      <D.101043>:
      D.101000 = &this->D.99285;
      sigc::trackable::~trackable (D.101000);
      goto <D.101045>;
      <D.101044>:
      <D.101045>:
    }
}


Gio::SocketService::SocketService(GSocketService*) (struct SocketService * const this, const void * * __vtt_parm, struct GSocketService * castitem)
{
  struct trackable * D.101050;
  const void * * iftmp.19;
  struct ObjectBase * D.101058;
  const void * * iftmp.20;
  struct SocketListener * D.101064;
  int (*__vtbl_ptr_type) () * iftmp.21;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.101072;
  int (*__vtbl_ptr_type) () * D.101073;
  long int D.101074;
  struct ObjectBase * D.101076;
  int (*__vtbl_ptr_type) () * iftmp.23;
  const void * * iftmp.24;
  const void * * iftmp.25;

  if (0 != 0) goto <D.101048>; else goto <D.101049>;
  <D.101048>:
  D.101050 = &this->D.99285;
  sigc::trackable::trackable (D.101050);
  goto <D.101051>;
  <D.101049>:
  <D.101051>:
  try
    {
      if (0 != 0) goto <D.101052>; else goto <D.101053>;
      <D.101052>:
      if (0 == 0) goto <D.101055>; else goto <D.101056>;
      <D.101055>:
      iftmp.19 = __vtt_parm + 48;
      goto <D.101057>;
      <D.101056>:
      iftmp.19 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.101057>:
      D.101058 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.101058, iftmp.19);
      goto <D.101059>;
      <D.101053>:
      <D.101059>:
      try
        {
          if (0 == 0) goto <D.101061>; else goto <D.101062>;
          <D.101061>:
          iftmp.20 = __vtt_parm + 8;
          goto <D.101063>;
          <D.101062>:
          iftmp.20 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
          <D.101063>:
          D.101064 = &this->D.99282;
          Gio::SocketListener::SocketListener (D.101064, iftmp.20, castitem);
          try
            {
              if (0 == 0) goto <D.101066>; else goto <D.101067>;
              <D.101066>:
              iftmp.21 = *__vtt_parm;
              goto <D.101068>;
              <D.101067>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.101068>:
              this->D.99282.D.99157._vptr.Object = iftmp.21;
              if (0 == 0) goto <D.101070>; else goto <D.101071>;
              <D.101070>:
              D.101072 = this->D.99282.D.99157._vptr.Object;
              D.101073 = D.101072 + 18446744073709551592;
              D.101074 = MEM[(long int *)D.101073];
              iftmp.22 = (sizetype) D.101074;
              goto <D.101075>;
              <D.101071>:
              iftmp.22 = 8;
              <D.101075>:
              D.101076 = this + iftmp.22;
              if (0 == 0) goto <D.101078>; else goto <D.101079>;
              <D.101078>:
              iftmp.23 = MEM[(const void * *)__vtt_parm + 40B];
              goto <D.101080>;
              <D.101079>:
              iftmp.23 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.101080>:
              D.101076->_vptr.ObjectBase = iftmp.23;
            }
          catch
            {
              if (0 == 0) goto <D.101082>; else goto <D.101083>;
              <D.101082>:
              iftmp.24 = __vtt_parm + 8;
              goto <D.101084>;
              <D.101083>:
              iftmp.24 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101084>:
              D.101064 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.101064, iftmp.24);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101085>; else goto <D.101086>;
          <D.101085>:
          if (0 == 0) goto <D.101088>; else goto <D.101089>;
          <D.101088>:
          iftmp.25 = __vtt_parm + 48;
          goto <D.101090>;
          <D.101089>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.101090>:
          D.101058 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.101058, iftmp.25);
          goto <D.101091>;
          <D.101086>:
          <D.101091>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101092>; else goto <D.101093>;
      <D.101092>:
      D.101050 = &this->D.99285;
      sigc::trackable::~trackable (D.101050);
      goto <D.101094>;
      <D.101093>:
      <D.101094>:
    }
}


Gio::SocketService::SocketService(GSocketService*) (struct SocketService * const this, struct GSocketService * castitem)
{
  struct trackable * D.101099;
  const void * * iftmp.26;
  struct ObjectBase * D.101107;
  const void * * iftmp.27;
  struct SocketListener * D.101113;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * D.101117;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.101122;
  int (*__vtbl_ptr_type) () * D.101123;
  long int D.101124;
  struct ObjectBase * D.101126;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * iftmp.31;
  const void * * iftmp.32;

  if (1 != 0) goto <D.101097>; else goto <D.101098>;
  <D.101097>:
  D.101099 = &this->D.99285;
  sigc::trackable::trackable (D.101099);
  goto <D.101100>;
  <D.101098>:
  <D.101100>:
  try
    {
      if (1 != 0) goto <D.101101>; else goto <D.101102>;
      <D.101101>:
      if (1 == 0) goto <D.101104>; else goto <D.101105>;
      <D.101104>:
      iftmp.26 = 48B;
      goto <D.101106>;
      <D.101105>:
      iftmp.26 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.101106>:
      D.101107 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.101107, iftmp.26);
      goto <D.101108>;
      <D.101102>:
      <D.101108>:
      try
        {
          if (1 == 0) goto <D.101110>; else goto <D.101111>;
          <D.101110>:
          iftmp.27 = 8B;
          goto <D.101112>;
          <D.101111>:
          iftmp.27 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
          <D.101112>:
          D.101113 = &this->D.99282;
          Gio::SocketListener::SocketListener (D.101113, iftmp.27, castitem);
          try
            {
              if (1 == 0) goto <D.101115>; else goto <D.101116>;
              <D.101115>:
              D.101117 = 0B;
              iftmp.28 = *D.101117;
              goto <D.101118>;
              <D.101116>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.101118>:
              this->D.99282.D.99157._vptr.Object = iftmp.28;
              if (1 == 0) goto <D.101120>; else goto <D.101121>;
              <D.101120>:
              D.101122 = this->D.99282.D.99157._vptr.Object;
              D.101123 = D.101122 + 18446744073709551592;
              D.101124 = MEM[(long int *)D.101123];
              iftmp.29 = (sizetype) D.101124;
              goto <D.101125>;
              <D.101121>:
              iftmp.29 = 8;
              <D.101125>:
              D.101126 = this + iftmp.29;
              if (1 == 0) goto <D.101128>; else goto <D.101129>;
              <D.101128>:
              iftmp.30 = MEM[(const void * *)0B + 40B];
              goto <D.101130>;
              <D.101129>:
              iftmp.30 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.101130>:
              D.101126->_vptr.ObjectBase = iftmp.30;
            }
          catch
            {
              if (1 == 0) goto <D.101132>; else goto <D.101133>;
              <D.101132>:
              iftmp.31 = 8B;
              goto <D.101134>;
              <D.101133>:
              iftmp.31 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101134>:
              D.101113 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.101113, iftmp.31);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101135>; else goto <D.101136>;
          <D.101135>:
          if (1 == 0) goto <D.101138>; else goto <D.101139>;
          <D.101138>:
          iftmp.32 = 48B;
          goto <D.101140>;
          <D.101139>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.101140>:
          D.101107 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.101107, iftmp.32);
          goto <D.101141>;
          <D.101136>:
          <D.101141>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101142>; else goto <D.101143>;
      <D.101142>:
      D.101099 = &this->D.99285;
      sigc::trackable::~trackable (D.101099);
      goto <D.101144>;
      <D.101143>:
      <D.101144>:
    }
}


Gio::SocketService::~SocketService() (struct SocketService * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.101154;
  int (*__vtbl_ptr_type) () * D.101155;
  long int D.101156;
  struct ObjectBase * D.101158;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * iftmp.36;
  struct SocketListener * D.101167;
  int D.101168;
  const void * * iftmp.37;
  struct ObjectBase * D.101175;
  struct trackable * D.101179;
  int D.101181;

  {
    if (0 == 0) goto <D.101148>; else goto <D.101149>;
    <D.101148>:
    iftmp.33 = *__vtt_parm;
    goto <D.101150>;
    <D.101149>:
    iftmp.33 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
    <D.101150>:
    this->D.99282.D.99157._vptr.Object = iftmp.33;
    if (0 == 0) goto <D.101152>; else goto <D.101153>;
    <D.101152>:
    D.101154 = this->D.99282.D.99157._vptr.Object;
    D.101155 = D.101154 + 18446744073709551592;
    D.101156 = MEM[(long int *)D.101155];
    iftmp.34 = (sizetype) D.101156;
    goto <D.101157>;
    <D.101153>:
    iftmp.34 = 8;
    <D.101157>:
    D.101158 = this + iftmp.34;
    if (0 == 0) goto <D.101160>; else goto <D.101161>;
    <D.101160>:
    iftmp.35 = MEM[(const void * *)__vtt_parm + 40B];
    goto <D.101162>;
    <D.101161>:
    iftmp.35 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
    <D.101162>:
    D.101158->_vptr.ObjectBase = iftmp.35;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.101164>; else goto <D.101165>;
                    <D.101164>:
                    iftmp.36 = __vtt_parm + 8;
                    goto <D.101166>;
                    <D.101165>:
                    iftmp.36 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
                    <D.101166>:
                    D.101167 = &this->D.99282;
                    Gio::SocketListener::~SocketListener (D.101167, iftmp.36);
                  }
              }
            finally
              {
                D.101168 = 0;
                if (D.101168 != 0) goto <D.101169>; else goto <D.101170>;
                <D.101169>:
                if (0 == 0) goto <D.101172>; else goto <D.101173>;
                <D.101172>:
                iftmp.37 = __vtt_parm + 48;
                goto <D.101174>;
                <D.101173>:
                iftmp.37 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
                <D.101174>:
                D.101175 = &this->D.99284;
                Glib::ObjectBase::~ObjectBase (D.101175, iftmp.37);
                goto <D.101176>;
                <D.101170>:
                <D.101176>:
              }
          }
        finally
          {
            D.101168 = 0;
            if (D.101168 != 0) goto <D.101177>; else goto <D.101178>;
            <D.101177>:
            D.101179 = &this->D.99285;
            sigc::trackable::~trackable (D.101179);
            goto <D.101180>;
            <D.101178>:
            <D.101180>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100022>:
  D.101181 = 0;
  if (D.101181 != 0) goto <D.101182>; else goto <D.101183>;
  <D.101182>:
  operator delete (this);
  goto <D.101184>;
  <D.101183>:
  <D.101184>:
}


virtual Gio::SocketService::~SocketService() (struct SocketService * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * D.101200;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.101205;
  int (*__vtbl_ptr_type) () * D.101206;
  long int D.101207;
  struct ObjectBase * D.101209;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  struct SocketListener * D.101218;
  int D.101219;
  const void * * iftmp.42;
  struct ObjectBase * D.101226;
  struct trackable * D.101230;
  int D.101232;

  {
    if (2 == 0) goto <D.101198>; else goto <D.101199>;
    <D.101198>:
    D.101200 = 0B;
    iftmp.38 = *D.101200;
    goto <D.101201>;
    <D.101199>:
    iftmp.38 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
    <D.101201>:
    this->D.99282.D.99157._vptr.Object = iftmp.38;
    if (2 == 0) goto <D.101203>; else goto <D.101204>;
    <D.101203>:
    D.101205 = this->D.99282.D.99157._vptr.Object;
    D.101206 = D.101205 + 18446744073709551592;
    D.101207 = MEM[(long int *)D.101206];
    iftmp.39 = (sizetype) D.101207;
    goto <D.101208>;
    <D.101204>:
    iftmp.39 = 8;
    <D.101208>:
    D.101209 = this + iftmp.39;
    if (2 == 0) goto <D.101211>; else goto <D.101212>;
    <D.101211>:
    iftmp.40 = MEM[(const void * *)0B + 40B];
    goto <D.101213>;
    <D.101212>:
    iftmp.40 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
    <D.101213>:
    D.101209->_vptr.ObjectBase = iftmp.40;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.101215>; else goto <D.101216>;
                    <D.101215>:
                    iftmp.41 = 8B;
                    goto <D.101217>;
                    <D.101216>:
                    iftmp.41 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
                    <D.101217>:
                    D.101218 = &this->D.99282;
                    Gio::SocketListener::~SocketListener (D.101218, iftmp.41);
                  }
              }
            finally
              {
                D.101219 = 2;
                if (D.101219 != 0) goto <D.101220>; else goto <D.101221>;
                <D.101220>:
                if (2 == 0) goto <D.101223>; else goto <D.101224>;
                <D.101223>:
                iftmp.42 = 48B;
                goto <D.101225>;
                <D.101224>:
                iftmp.42 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
                <D.101225>:
                D.101226 = &this->D.99284;
                Glib::ObjectBase::~ObjectBase (D.101226, iftmp.42);
                goto <D.101227>;
                <D.101221>:
                <D.101227>:
              }
          }
        finally
          {
            D.101219 = 2;
            if (D.101219 != 0) goto <D.101228>; else goto <D.101229>;
            <D.101228>:
            D.101230 = &this->D.99285;
            sigc::trackable::~trackable (D.101230);
            goto <D.101231>;
            <D.101229>:
            <D.101231>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100025>:
  D.101232 = 0;
  if (D.101232 != 0) goto <D.101233>; else goto <D.101234>;
  <D.101233>:
  operator delete (this);
  goto <D.101235>;
  <D.101234>:
  <D.101235>:
}


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


static GType Gio::SocketService::get_type() ()
{
  GType D.101248;
  const struct Class & D.101249;

  D.101249 = Gio::SocketService_Class::init (&socketservice_class_);
  D.101248 = Glib::Class::get_type (D.101249);
  return D.101248;
}


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

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


static GType Gio::SocketService::get_base_type() ()
{
  GType D.101254;

  D.101254 = g_socket_service_get_type ();
  return D.101254;
}


Gio::SocketService::SocketService() (struct SocketService * const this, const void * * __vtt_parm)
{
  struct trackable * D.101259;
  const void * * iftmp.43;
  struct ObjectBase * D.101267;
  struct ConstructParams D.100048;
  const struct Class & D.101269;
  const void * * iftmp.44;
  struct SocketListener * D.101274;
  int (*__vtbl_ptr_type) () * iftmp.45;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.101282;
  int (*__vtbl_ptr_type) () * D.101283;
  long int D.101284;
  struct ObjectBase * D.101286;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  const void * * iftmp.49;

  if (0 != 0) goto <D.101257>; else goto <D.101258>;
  <D.101257>:
  D.101259 = &this->D.99285;
  sigc::trackable::trackable (D.101259);
  goto <D.101260>;
  <D.101258>:
  <D.101260>:
  try
    {
      if (0 != 0) goto <D.101261>; else goto <D.101262>;
      <D.101261>:
      if (0 == 0) goto <D.101264>; else goto <D.101265>;
      <D.101264>:
      iftmp.43 = __vtt_parm + 48;
      goto <D.101266>;
      <D.101265>:
      iftmp.43 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.101266>:
      D.101267 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.101267, iftmp.43, 0B);
      goto <D.101268>;
      <D.101262>:
      <D.101268>:
      try
        {
          D.101269 = Gio::SocketService_Class::init (&socketservice_class_);
          Glib::ConstructParams::ConstructParams (&D.100048, D.101269);
          try
            {
              if (0 == 0) goto <D.101271>; else goto <D.101272>;
              <D.101271>:
              iftmp.44 = __vtt_parm + 8;
              goto <D.101273>;
              <D.101272>:
              iftmp.44 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101273>:
              D.101274 = &this->D.99282;
              Gio::SocketListener::SocketListener (D.101274, iftmp.44, &D.100048);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.100048);
              D.100048 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.101276>; else goto <D.101277>;
              <D.101276>:
              iftmp.45 = *__vtt_parm;
              goto <D.101278>;
              <D.101277>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.101278>:
              this->D.99282.D.99157._vptr.Object = iftmp.45;
              if (0 == 0) goto <D.101280>; else goto <D.101281>;
              <D.101280>:
              D.101282 = this->D.99282.D.99157._vptr.Object;
              D.101283 = D.101282 + 18446744073709551592;
              D.101284 = MEM[(long int *)D.101283];
              iftmp.46 = (sizetype) D.101284;
              goto <D.101285>;
              <D.101281>:
              iftmp.46 = 8;
              <D.101285>:
              D.101286 = this + iftmp.46;
              if (0 == 0) goto <D.101288>; else goto <D.101289>;
              <D.101288>:
              iftmp.47 = MEM[(const void * *)__vtt_parm + 40B];
              goto <D.101290>;
              <D.101289>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.101290>:
              D.101286->_vptr.ObjectBase = iftmp.47;
            }
          catch
            {
              if (0 == 0) goto <D.101292>; else goto <D.101293>;
              <D.101292>:
              iftmp.48 = __vtt_parm + 8;
              goto <D.101294>;
              <D.101293>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101294>:
              D.101274 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.101274, iftmp.48);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101295>; else goto <D.101296>;
          <D.101295>:
          if (0 == 0) goto <D.101298>; else goto <D.101299>;
          <D.101298>:
          iftmp.49 = __vtt_parm + 48;
          goto <D.101300>;
          <D.101299>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.101300>:
          D.101267 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.101267, iftmp.49);
          goto <D.101301>;
          <D.101296>:
          <D.101301>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101302>; else goto <D.101303>;
      <D.101302>:
      D.101259 = &this->D.99285;
      sigc::trackable::~trackable (D.101259);
      goto <D.101304>;
      <D.101303>:
      <D.101304>:
    }
}


Gio::SocketService::SocketService() (struct SocketService * const this)
{
  struct trackable * D.101311;
  const void * * iftmp.50;
  struct ObjectBase * D.101319;
  struct ConstructParams D.100050;
  const struct Class & D.101321;
  const void * * iftmp.51;
  struct SocketListener * D.101326;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * D.101330;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.101335;
  int (*__vtbl_ptr_type) () * D.101336;
  long int D.101337;
  struct ObjectBase * D.101339;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;

  if (1 != 0) goto <D.101309>; else goto <D.101310>;
  <D.101309>:
  D.101311 = &this->D.99285;
  sigc::trackable::trackable (D.101311);
  goto <D.101312>;
  <D.101310>:
  <D.101312>:
  try
    {
      if (1 != 0) goto <D.101313>; else goto <D.101314>;
      <D.101313>:
      if (1 == 0) goto <D.101316>; else goto <D.101317>;
      <D.101316>:
      iftmp.50 = 48B;
      goto <D.101318>;
      <D.101317>:
      iftmp.50 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
      <D.101318>:
      D.101319 = &this->D.99284;
      Glib::ObjectBase::ObjectBase (D.101319, iftmp.50, 0B);
      goto <D.101320>;
      <D.101314>:
      <D.101320>:
      try
        {
          D.101321 = Gio::SocketService_Class::init (&socketservice_class_);
          Glib::ConstructParams::ConstructParams (&D.100050, D.101321);
          try
            {
              if (1 == 0) goto <D.101323>; else goto <D.101324>;
              <D.101323>:
              iftmp.51 = 8B;
              goto <D.101325>;
              <D.101324>:
              iftmp.51 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101325>:
              D.101326 = &this->D.99282;
              Gio::SocketListener::SocketListener (D.101326, iftmp.51, &D.100050);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.100050);
              D.100050 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.101328>; else goto <D.101329>;
              <D.101328>:
              D.101330 = 0B;
              iftmp.52 = *D.101330;
              goto <D.101331>;
              <D.101329>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 32B];
              <D.101331>:
              this->D.99282.D.99157._vptr.Object = iftmp.52;
              if (1 == 0) goto <D.101333>; else goto <D.101334>;
              <D.101333>:
              D.101335 = this->D.99282.D.99157._vptr.Object;
              D.101336 = D.101335 + 18446744073709551592;
              D.101337 = MEM[(long int *)D.101336];
              iftmp.53 = (sizetype) D.101337;
              goto <D.101338>;
              <D.101334>:
              iftmp.53 = 8;
              <D.101338>:
              D.101339 = this + iftmp.53;
              if (1 == 0) goto <D.101341>; else goto <D.101342>;
              <D.101341>:
              iftmp.54 = MEM[(const void * *)0B + 40B];
              goto <D.101343>;
              <D.101342>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio13SocketServiceE + 120B];
              <D.101343>:
              D.101339->_vptr.ObjectBase = iftmp.54;
            }
          catch
            {
              if (1 == 0) goto <D.101345>; else goto <D.101346>;
              <D.101345>:
              iftmp.55 = 8B;
              goto <D.101347>;
              <D.101346>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 8B];
              <D.101347>:
              D.101326 = &this->D.99282;
              Gio::SocketListener::~SocketListener (D.101326, iftmp.55);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101348>; else goto <D.101349>;
          <D.101348>:
          if (1 == 0) goto <D.101351>; else goto <D.101352>;
          <D.101351>:
          iftmp.56 = 48B;
          goto <D.101353>;
          <D.101352>:
          iftmp.56 = &MEM[(void *)&_ZTTN3Gio13SocketServiceE + 48B];
          <D.101353>:
          D.101319 = &this->D.99284;
          Glib::ObjectBase::~ObjectBase (D.101319, iftmp.56);
          goto <D.101354>;
          <D.101349>:
          <D.101354>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101355>; else goto <D.101356>;
      <D.101355>:
      D.101311 = &this->D.99285;
      sigc::trackable::~trackable (D.101311);
      goto <D.101357>;
      <D.101356>:
      <D.101357>:
    }
}


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

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


void Gio::SocketService::start() (struct SocketService * const this)
{
  struct GSocketService * D.101366;

  D.101366 = Gio::SocketService::gobj (this);
  g_socket_service_start (D.101366);
}


void Gio::SocketService::stop() (struct SocketService * const this)
{
  struct GSocketService * D.101367;

  D.101367 = Gio::SocketService::gobj (this);
  g_socket_service_stop (D.101367);
}


bool Gio::SocketService::is_active() (struct SocketService * const this)
{
  bool D.101368;
  struct GSocketService * D.101369;
  int D.101370;

  D.101369 = Gio::SocketService::gobj (this);
  D.101370 = g_socket_service_is_active (D.101369);
  D.101368 = D.101370 != 0;
  return D.101368;
}


Glib::SignalProxy2<bool, const Glib::RefPtr<Gio::SocketConnection>&, const Glib::RefPtr<Glib::Object>&> Gio::SocketService::signal_incoming() (struct SocketService * const this)
{
  int (*__vtbl_ptr_type) () * D.101374;
  int (*__vtbl_ptr_type) () * D.101375;
  long int D.101376;
  sizetype D.101377;
  struct ObjectBase * D.101378;

  D.101374 = this->D.99282.D.99157._vptr.Object;
  D.101375 = D.101374 + 18446744073709551592;
  D.101376 = MEM[(long int *)D.101375];
  D.101377 = (sizetype) D.101376;
  D.101378 = this + D.101377;
  Glib::SignalProxy2<bool, const Glib::RefPtr<Gio::SocketConnection>&, const Glib::RefPtr<Glib::Object>&>::SignalProxy2 (<retval>, D.101378, &SocketService_signal_incoming_info);
  return <retval>;
}


gboolean {anonymous}::SocketService_signal_incoming_notify_callback(GSocketService*, GSocketConnection*, GObject*, void*) (struct GSocketService * self, struct GSocketConnection * p0, struct GObject * p1, void * data)
{
  struct SocketService * iftmp.57;
  struct ObjectBase * D.101381;
  struct RefPtr D.99827;
  struct RefPtr D.99826;
  struct slot2 * D.101389;
  void * D.101391;
  gboolean D.101393;
  typedef struct SlotType SlotType;
  struct SocketService * obj;
  typedef RType RType;

  D.101381 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.101381 == 0B) goto <D.101382>; else goto <D.101383>;
  <D.101382>:
  iftmp.57 = 0B;
  goto <D.101384>;
  <D.101383>:
  iftmp.57 = __dynamic_cast (D.101381, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio13SocketServiceE, -1);
  <D.101384>:
  obj = iftmp.57;
  {
    if (obj != 0B) goto <D.101385>; else goto <D.101386>;
    <D.101385>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.101387>; else goto <D.101388>;
              <D.101387>:
              D.99827 = Glib::wrap (p1, 1); [return slot optimization]
              try
                {
                  D.99826 = Glib::wrap (p0, 1); [return slot optimization]
                  try
                    {
                      D.101389 = &MEM[(struct SlotType *)slot].D.99824;
                      sigc::slot2<void, const Glib::RefPtr<Gio::SocketConnection>&, const Glib::RefPtr<Glib::Object>&>::operator() (D.101389, &D.99826, &D.99827);
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnection>::~RefPtr (&D.99826);
                      D.99826 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Glib::Object>::~RefPtr (&D.99827);
                  D.99827 = {CLOBBER};
                }
              goto <D.101390>;
              <D.101388>:
              <D.101390>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101391 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101391);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.101392>;
    <D.101386>:
    <D.101392>:
  }
  D.101393 = 0;
  return D.101393;
}


static sigc::slot_base* Glib::SignalProxyBase::data_to_slot(void*) (void * data)
{
  struct slot_base * D.101401;
  struct slot_base * iftmp.58;
  struct slot_base * D.101403;
  bool D.101404;
  bool D.101405;
  struct SignalProxyConnectionNode * const pConnectionNode;

  pConnectionNode = data;
  D.101403 = &pConnectionNode->slot_;
  D.101404 = sigc::slot_base::blocked (D.101403);
  D.101405 = ~D.101404;
  if (D.101405 != 0) goto <D.101406>; else goto <D.101407>;
  <D.101406>:
  iftmp.58 = &pConnectionNode->slot_;
  goto <D.101408>;
  <D.101407>:
  iftmp.58 = 0B;
  <D.101408>:
  D.101401 = iftmp.58;
  return D.101401;
}


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

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


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = void; T_arg1 = const Glib::RefPtr<Gio::SocketConnection>&; T_arg2 = const Glib::RefPtr<Glib::Object>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const Glib::RefPtr<Gio::SocketConnection>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const Glib::RefPtr<Glib::Object>&] (const struct slot2 * const this, const struct RefPtr & _A_a1, const struct RefPtr & _A_a2)
{
  bool retval.59;
  bool iftmp.60;
  const struct slot_base * D.101416;
  bool D.101417;
  bool D.101418;
  bool D.101420;
  bool D.101421;
  struct rep_type * D.101425;
  void * (*<T609>) (void *) D.101426;

  D.101416 = &this->D.99782;
  D.101417 = sigc::slot_base::empty (D.101416);
  D.101418 = ~D.101417;
  if (D.101418 != 0) goto <D.101419>; else goto <D.101414>;
  <D.101419>:
  D.101416 = &this->D.99782;
  D.101420 = sigc::slot_base::blocked (D.101416);
  D.101421 = ~D.101420;
  if (D.101421 != 0) goto <D.101422>; else goto <D.101414>;
  <D.101422>:
  iftmp.60 = 1;
  goto <D.101415>;
  <D.101414>:
  iftmp.60 = 0;
  <D.101415>:
  retval.59 = iftmp.60;
  if (retval.59 != 0) goto <D.101423>; else goto <D.101424>;
  <D.101423>:
  D.101425 = this->D.99782.rep_;
  D.101426 = D.101425->call_;
  D.101425 = this->D.99782.rep_;
  D.101426 (D.101425, _A_a1, _A_a2);
  return;
  <D.101424>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.101428;
  bool iftmp.61;
  struct rep_type * D.101433;
  void * (*<T609>) (void *) D.101435;

  D.101433 = this->rep_;
  if (D.101433 == 0B) goto <D.101430>; else goto <D.101434>;
  <D.101434>:
  D.101433 = this->rep_;
  D.101435 = D.101433->call_;
  if (D.101435 == 0B) goto <D.101430>; else goto <D.101431>;
  <D.101430>:
  iftmp.61 = 1;
  goto <D.101432>;
  <D.101431>:
  iftmp.61 = 0;
  <D.101432>:
  D.101428 = iftmp.61;
  return D.101428;
}


gboolean {anonymous}::SocketService_signal_incoming_callback(GSocketService*, GSocketConnection*, GObject*, void*) (struct GSocketService * self, struct GSocketConnection * p0, struct GObject * p1, void * data)
{
  struct SocketService * iftmp.62;
  struct ObjectBase * D.101438;
  gboolean D.101446;
  struct RefPtr D.99717;
  struct RefPtr D.99592;
  struct slot2 * D.101447;
  bool D.101448;
  void * D.101449;
  typedef struct SlotType SlotType;
  struct SocketService * obj;
  typedef RType RType;

  D.101438 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.101438 == 0B) goto <D.101439>; else goto <D.101440>;
  <D.101439>:
  iftmp.62 = 0B;
  goto <D.101441>;
  <D.101440>:
  iftmp.62 = __dynamic_cast (D.101438, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio13SocketServiceE, -1);
  <D.101441>:
  obj = iftmp.62;
  {
    if (obj != 0B) goto <D.101442>; else goto <D.101443>;
    <D.101442>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.101444>; else goto <D.101445>;
              <D.101444>:
              D.99717 = Glib::wrap (p1, 1); [return slot optimization]
              try
                {
                  D.99592 = Glib::wrap (p0, 1); [return slot optimization]
                  try
                    {
                      D.101447 = &MEM[(struct SlotType *)slot].D.99466;
                      D.101448 = sigc::slot2<bool, const Glib::RefPtr<Gio::SocketConnection>&, const Glib::RefPtr<Glib::Object>&>::operator() (D.101447, &D.99592, &D.99717);
                      D.101446 = (gboolean) D.101448;
                      return D.101446;
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnection>::~RefPtr (&D.99592);
                      D.99592 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Glib::Object>::~RefPtr (&D.99717);
                  D.99717 = {CLOBBER};
                }
              <D.101445>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101449 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101449);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.101450>;
    <D.101443>:
    <D.101450>:
  }
  D.101446 = 0;
  return D.101446;
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = bool; T_arg1 = const Glib::RefPtr<Gio::SocketConnection>&; T_arg2 = const Glib::RefPtr<Glib::Object>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const Glib::RefPtr<Gio::SocketConnection>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const Glib::RefPtr<Glib::Object>&] (const struct slot2 * const this, const struct RefPtr & _A_a1, const struct RefPtr & _A_a2)
{
  bool retval.63;
  bool iftmp.64;
  const struct slot_base * D.101465;
  bool D.101466;
  bool D.101467;
  bool D.101469;
  bool D.101470;
  bool D.101474;
  struct rep_type * D.101475;
  void * (*<T609>) (void *) D.101476;

  D.101465 = &this->D.99424;
  D.101466 = sigc::slot_base::empty (D.101465);
  D.101467 = ~D.101466;
  if (D.101467 != 0) goto <D.101468>; else goto <D.101463>;
  <D.101468>:
  D.101465 = &this->D.99424;
  D.101469 = sigc::slot_base::blocked (D.101465);
  D.101470 = ~D.101469;
  if (D.101470 != 0) goto <D.101471>; else goto <D.101463>;
  <D.101471>:
  iftmp.64 = 1;
  goto <D.101464>;
  <D.101463>:
  iftmp.64 = 0;
  <D.101464>:
  retval.63 = iftmp.64;
  if (retval.63 != 0) goto <D.101472>; else goto <D.101473>;
  <D.101472>:
  D.101475 = this->D.99424.rep_;
  D.101476 = D.101475->call_;
  D.101475 = this->D.99424.rep_;
  D.101474 = D.101476 (D.101475, _A_a1, _A_a2);
  return D.101474;
  <D.101473>:
  D.101474 = 0;
  return D.101474;
}


Glib::SignalProxy2<R, P1, P2>::SignalProxy2(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = bool; P1 = const Glib::RefPtr<Gio::SocketConnection>&; P2 = const Glib::RefPtr<Glib::Object>&] (struct SignalProxy2 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.101479;

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

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


virtual bool Gio::SocketService::on_incoming(const Glib::RefPtr<Gio::SocketConnection>&, const Glib::RefPtr<Glib::Object>&) (struct SocketService * const this, const struct RefPtr & connection, const struct RefPtr & source_object)
{
  int (*__vtbl_ptr_type) () * D.101480;
  int (*__vtbl_ptr_type) () * D.101481;
  long int D.101482;
  sizetype D.101483;
  struct ObjectBase * D.101484;
  struct GObject * D.101485;
  struct GTypeClass * D.101486;
  gboolean (*<T10fcf>) (struct GSocketService *, struct GSocketConnection *, struct GObject *) D.101489;
  bool D.101492;
  struct BaseObjectType * D.101493;
  struct BaseObjectType * D.101494;
  struct GSocketService * D.101495;
  int D.101496;
  struct BaseClassType * const base;
  typedef RType RType;

  D.101480 = this->D.99282.D.99157._vptr.Object;
  D.101481 = D.101480 + 18446744073709551592;
  D.101482 = MEM[(long int *)D.101481];
  D.101483 = (sizetype) D.101482;
  D.101484 = this + D.101483;
  D.101485 = D.101484->gobject_;
  D.101486 = MEM[(struct GTypeInstance *)D.101485].g_class;
  base = g_type_class_peek_parent (D.101486);
  if (base != 0B) goto <D.101487>; else goto <D.101488>;
  <D.101487>:
  D.101489 = base->incoming;
  if (D.101489 != 0B) goto <D.101490>; else goto <D.101491>;
  <D.101490>:
  D.101489 = base->incoming;
  D.101493 = Glib::unwrap<Glib::Object> (source_object);
  D.101494 = Glib::unwrap<Gio::SocketConnection> (connection);
  D.101495 = Gio::SocketService::gobj (this);
  D.101496 = D.101489 (D.101495, D.101494, D.101493);
  D.101492 = D.101496 != 0;
  return D.101492;
  <D.101491>:
  <D.101488>:
  D.101492 = 0;
  return D.101492;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Glib::Object; typename T::BaseObjectType = _GObject] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.101502;
  struct BaseObjectType * iftmp.65;
  bool D.101504;
  struct Object * D.101507;
  int (*__vtbl_ptr_type) () * D.101508;
  int (*__vtbl_ptr_type) () * D.101509;
  long int D.101510;
  sizetype D.101511;
  struct ObjectBase * D.101512;

  D.101504 = Glib::RefPtr<Glib::Object>::operator bool (ptr);
  if (D.101504 != 0) goto <D.101505>; else goto <D.101506>;
  <D.101505>:
  D.101507 = Glib::RefPtr<Glib::Object>::operator-> (ptr);
  D.101508 = D.101507->_vptr.Object;
  D.101509 = D.101508 + 18446744073709551592;
  D.101510 = MEM[(long int *)D.101509];
  D.101511 = (sizetype) D.101510;
  D.101512 = D.101507 + D.101511;
  iftmp.65 = Glib::ObjectBase::gobj (D.101512);
  goto <D.101513>;
  <D.101506>:
  iftmp.65 = 0B;
  <D.101513>:
  D.101502 = iftmp.65;
  return D.101502;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Glib::Object] (const struct RefPtr * const this)
{
  bool D.101515;
  struct Object * D.101516;

  D.101516 = this->pCppObject_;
  D.101515 = D.101516 != 0B;
  return D.101515;
}


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

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


GObject* Glib::ObjectBase::gobj() (struct ObjectBase * const this)
{
  struct GObject * D.101520;

  D.101520 = this->gobject_;
  return D.101520;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::SocketConnection; typename T::BaseObjectType = _GSocketConnection] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.101522;
  struct BaseObjectType * iftmp.66;
  bool D.101524;
  struct SocketConnection * D.101527;

  D.101524 = Glib::RefPtr<Gio::SocketConnection>::operator bool (ptr);
  if (D.101524 != 0) goto <D.101525>; else goto <D.101526>;
  <D.101525>:
  D.101527 = Glib::RefPtr<Gio::SocketConnection>::operator-> (ptr);
  iftmp.66 = Gio::SocketConnection::gobj (D.101527);
  goto <D.101528>;
  <D.101526>:
  iftmp.66 = 0B;
  <D.101528>:
  D.101522 = iftmp.66;
  return D.101522;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::SocketConnection] (const struct RefPtr * const this)
{
  bool D.101530;
  struct SocketConnection * D.101531;

  D.101531 = this->pCppObject_;
  D.101530 = D.101531 != 0B;
  return D.101530;
}


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

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


GSocketConnection* Gio::SocketConnection::gobj() (struct SocketConnection * const this)
{
  struct GSocketConnection * D.101535;
  int (*__vtbl_ptr_type) () * D.101536;
  int (*__vtbl_ptr_type) () * D.101537;
  long int D.101538;
  sizetype D.101539;
  struct ObjectBase * D.101540;

  D.101536 = this->D.98951.D.98812._vptr.Object;
  D.101537 = D.101536 + 18446744073709551592;
  D.101538 = MEM[(long int *)D.101537];
  D.101539 = (sizetype) D.101538;
  D.101540 = this + D.101539;
  D.101535 = D.101540->gobject_;
  return D.101535;
}