Gio::Socket::Socket(Gio::SocketFamily, Gio::SocketType, Gio::SocketProtocol, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const void * * __vtt_parm, SocketFamily family, SocketType type, SocketProtocol protocol, const struct RefPtr & cancellable)
{
  struct trackable * D.100893;
  const void * * iftmp.0;
  struct ObjectBase * D.100901;
  struct ConstructParams D.98431;
  int type.1;
  int family.2;
  const struct Class & D.100905;
  const void * * iftmp.3;
  struct Object * D.100910;
  const void * * iftmp.4;
  struct Initable * D.100915;
  int (*__vtbl_ptr_type) () * iftmp.5;
  sizetype iftmp.6;
  int (*__vtbl_ptr_type) () * D.100923;
  int (*__vtbl_ptr_type) () * D.100924;
  long int D.100925;
  struct ObjectBase * D.100927;
  int (*__vtbl_ptr_type) () * iftmp.7;
  int (*__vtbl_ptr_type) () * iftmp.8;
  const void * * iftmp.9;
  const void * * iftmp.10;
  const void * * iftmp.11;

  if (0 != 0) goto <D.100891>; else goto <D.100892>;
  <D.100891>:
  D.100893 = &this->D.98053;
  sigc::trackable::trackable (D.100893);
  goto <D.100894>;
  <D.100892>:
  <D.100894>:
  try
    {
      if (0 != 0) goto <D.100895>; else goto <D.100896>;
      <D.100895>:
      if (0 == 0) goto <D.100898>; else goto <D.100899>;
      <D.100898>:
      iftmp.0 = __vtt_parm + 72;
      goto <D.100900>;
      <D.100899>:
      iftmp.0 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.100900>:
      D.100901 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.100901, iftmp.0, 0B);
      goto <D.100902>;
      <D.100896>:
      <D.100902>:
      try
        {
          type.1 = (int) type;
          family.2 = (int) family;
          D.100905 = Gio::Socket_Class::init (&socket_class_);
          Glib::ConstructParams::ConstructParams (&D.98431, D.100905, "family", family.2, "type", type.1, "protocol", protocol, 0B);
          try
            {
              if (0 == 0) goto <D.100907>; else goto <D.100908>;
              <D.100907>:
              iftmp.3 = __vtt_parm + 8;
              goto <D.100909>;
              <D.100908>:
              iftmp.3 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.100909>:
              D.100910 = &this->D.98048;
              Glib::Object::Object (D.100910, iftmp.3, &D.98431);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98431);
              D.98431 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.100912>; else goto <D.100913>;
              <D.100912>:
              iftmp.4 = __vtt_parm + 24;
              goto <D.100914>;
              <D.100913>:
              iftmp.4 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.100914>:
              D.100915 = &this->D.98049;
              Gio::Initable::Initable (D.100915, iftmp.4);
              try
                {
                  if (0 == 0) goto <D.100917>; else goto <D.100918>;
                  <D.100917>:
                  iftmp.5 = *__vtt_parm;
                  goto <D.100919>;
                  <D.100918>:
                  iftmp.5 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.100919>:
                  this->D.98048._vptr.Object = iftmp.5;
                  if (0 == 0) goto <D.100921>; else goto <D.100922>;
                  <D.100921>:
                  D.100923 = this->D.98048._vptr.Object;
                  D.100924 = D.100923 + 18446744073709551592;
                  D.100925 = MEM[(long int *)D.100924];
                  iftmp.6 = (sizetype) D.100925;
                  goto <D.100926>;
                  <D.100922>:
                  iftmp.6 = 16;
                  <D.100926>:
                  D.100927 = this + iftmp.6;
                  if (0 == 0) goto <D.100929>; else goto <D.100930>;
                  <D.100929>:
                  iftmp.7 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.100931>;
                  <D.100930>:
                  iftmp.7 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.100931>:
                  D.100927->_vptr.ObjectBase = iftmp.7;
                  if (0 == 0) goto <D.100933>; else goto <D.100934>;
                  <D.100933>:
                  iftmp.8 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.100935>;
                  <D.100934>:
                  iftmp.8 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.100935>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.8;
                  D.100915 = &this->D.98049;
                  Gio::Initable::init (D.100915, cancellable);
                }
              catch
                {
                  if (0 == 0) goto <D.100937>; else goto <D.100938>;
                  <D.100937>:
                  iftmp.9 = __vtt_parm + 24;
                  goto <D.100939>;
                  <D.100938>:
                  iftmp.9 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.100939>:
                  D.100915 = &this->D.98049;
                  Gio::Initable::~Initable (D.100915, iftmp.9);
                }
            }
          catch
            {
              if (0 == 0) goto <D.100941>; else goto <D.100942>;
              <D.100941>:
              iftmp.10 = __vtt_parm + 8;
              goto <D.100943>;
              <D.100942>:
              iftmp.10 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.100943>:
              D.100910 = &this->D.98048;
              Glib::Object::~Object (D.100910, iftmp.10);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100944>; else goto <D.100945>;
          <D.100944>:
          if (0 == 0) goto <D.100947>; else goto <D.100948>;
          <D.100947>:
          iftmp.11 = __vtt_parm + 72;
          goto <D.100949>;
          <D.100948>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.100949>:
          D.100901 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.100901, iftmp.11);
          goto <D.100950>;
          <D.100945>:
          <D.100950>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100951>; else goto <D.100952>;
      <D.100951>:
      D.100893 = &this->D.98053;
      sigc::trackable::~trackable (D.100893);
      goto <D.100953>;
      <D.100952>:
      <D.100953>:
    }
}


Gio::Socket::Socket(Gio::SocketFamily, Gio::SocketType, Gio::SocketProtocol, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, SocketFamily family, SocketType type, SocketProtocol protocol, const struct RefPtr & cancellable)
{
  struct trackable * D.100963;
  const void * * iftmp.12;
  struct ObjectBase * D.100971;
  struct ConstructParams D.98433;
  int type.13;
  int family.14;
  const struct Class & D.100975;
  const void * * iftmp.15;
  struct Object * D.100980;
  const void * * iftmp.16;
  struct Initable * D.100985;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.100989;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.100994;
  int (*__vtbl_ptr_type) () * D.100995;
  long int D.100996;
  struct ObjectBase * D.100998;
  int (*__vtbl_ptr_type) () * iftmp.19;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * iftmp.21;
  const void * * iftmp.22;
  const void * * iftmp.23;

  if (1 != 0) goto <D.100961>; else goto <D.100962>;
  <D.100961>:
  D.100963 = &this->D.98053;
  sigc::trackable::trackable (D.100963);
  goto <D.100964>;
  <D.100962>:
  <D.100964>:
  try
    {
      if (1 != 0) goto <D.100965>; else goto <D.100966>;
      <D.100965>:
      if (1 == 0) goto <D.100968>; else goto <D.100969>;
      <D.100968>:
      iftmp.12 = 72B;
      goto <D.100970>;
      <D.100969>:
      iftmp.12 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.100970>:
      D.100971 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.100971, iftmp.12, 0B);
      goto <D.100972>;
      <D.100966>:
      <D.100972>:
      try
        {
          type.13 = (int) type;
          family.14 = (int) family;
          D.100975 = Gio::Socket_Class::init (&socket_class_);
          Glib::ConstructParams::ConstructParams (&D.98433, D.100975, "family", family.14, "type", type.13, "protocol", protocol, 0B);
          try
            {
              if (1 == 0) goto <D.100977>; else goto <D.100978>;
              <D.100977>:
              iftmp.15 = 8B;
              goto <D.100979>;
              <D.100978>:
              iftmp.15 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.100979>:
              D.100980 = &this->D.98048;
              Glib::Object::Object (D.100980, iftmp.15, &D.98433);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98433);
              D.98433 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.100982>; else goto <D.100983>;
              <D.100982>:
              iftmp.16 = 24B;
              goto <D.100984>;
              <D.100983>:
              iftmp.16 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.100984>:
              D.100985 = &this->D.98049;
              Gio::Initable::Initable (D.100985, iftmp.16);
              try
                {
                  if (1 == 0) goto <D.100987>; else goto <D.100988>;
                  <D.100987>:
                  D.100989 = 0B;
                  iftmp.17 = *D.100989;
                  goto <D.100990>;
                  <D.100988>:
                  iftmp.17 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.100990>:
                  this->D.98048._vptr.Object = iftmp.17;
                  if (1 == 0) goto <D.100992>; else goto <D.100993>;
                  <D.100992>:
                  D.100994 = this->D.98048._vptr.Object;
                  D.100995 = D.100994 + 18446744073709551592;
                  D.100996 = MEM[(long int *)D.100995];
                  iftmp.18 = (sizetype) D.100996;
                  goto <D.100997>;
                  <D.100993>:
                  iftmp.18 = 16;
                  <D.100997>:
                  D.100998 = this + iftmp.18;
                  if (1 == 0) goto <D.101000>; else goto <D.101001>;
                  <D.101000>:
                  iftmp.19 = MEM[(const void * *)0B + 56B];
                  goto <D.101002>;
                  <D.101001>:
                  iftmp.19 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101002>:
                  D.100998->_vptr.ObjectBase = iftmp.19;
                  if (1 == 0) goto <D.101004>; else goto <D.101005>;
                  <D.101004>:
                  iftmp.20 = MEM[(const void * *)0B + 64B];
                  goto <D.101006>;
                  <D.101005>:
                  iftmp.20 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101006>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.20;
                  D.100985 = &this->D.98049;
                  Gio::Initable::init (D.100985, cancellable);
                }
              catch
                {
                  if (1 == 0) goto <D.101008>; else goto <D.101009>;
                  <D.101008>:
                  iftmp.21 = 24B;
                  goto <D.101010>;
                  <D.101009>:
                  iftmp.21 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101010>:
                  D.100985 = &this->D.98049;
                  Gio::Initable::~Initable (D.100985, iftmp.21);
                }
            }
          catch
            {
              if (1 == 0) goto <D.101012>; else goto <D.101013>;
              <D.101012>:
              iftmp.22 = 8B;
              goto <D.101014>;
              <D.101013>:
              iftmp.22 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101014>:
              D.100980 = &this->D.98048;
              Glib::Object::~Object (D.100980, iftmp.22);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101015>; else goto <D.101016>;
          <D.101015>:
          if (1 == 0) goto <D.101018>; else goto <D.101019>;
          <D.101018>:
          iftmp.23 = 72B;
          goto <D.101020>;
          <D.101019>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101020>:
          D.100971 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.100971, iftmp.23);
          goto <D.101021>;
          <D.101016>:
          <D.101021>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101022>; else goto <D.101023>;
      <D.101022>:
      D.100963 = &this->D.98053;
      sigc::trackable::~trackable (D.100963);
      goto <D.101024>;
      <D.101023>:
      <D.101024>:
    }
}


Gio::Socket::Socket(int, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const void * * __vtt_parm, int fd, const struct RefPtr & cancellable)
{
  struct trackable * D.101033;
  const void * * iftmp.24;
  struct ObjectBase * D.101041;
  struct ConstructParams D.98443;
  const struct Class & D.101043;
  const void * * iftmp.25;
  struct Object * D.101048;
  const void * * iftmp.26;
  struct Initable * D.101053;
  int (*__vtbl_ptr_type) () * iftmp.27;
  sizetype iftmp.28;
  int (*__vtbl_ptr_type) () * D.101061;
  int (*__vtbl_ptr_type) () * D.101062;
  long int D.101063;
  struct ObjectBase * D.101065;
  int (*__vtbl_ptr_type) () * iftmp.29;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * iftmp.31;
  const void * * iftmp.32;
  const void * * iftmp.33;

  if (0 != 0) goto <D.101031>; else goto <D.101032>;
  <D.101031>:
  D.101033 = &this->D.98053;
  sigc::trackable::trackable (D.101033);
  goto <D.101034>;
  <D.101032>:
  <D.101034>:
  try
    {
      if (0 != 0) goto <D.101035>; else goto <D.101036>;
      <D.101035>:
      if (0 == 0) goto <D.101038>; else goto <D.101039>;
      <D.101038>:
      iftmp.24 = __vtt_parm + 72;
      goto <D.101040>;
      <D.101039>:
      iftmp.24 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101040>:
      D.101041 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101041, iftmp.24, 0B);
      goto <D.101042>;
      <D.101036>:
      <D.101042>:
      try
        {
          D.101043 = Gio::Socket_Class::init (&socket_class_);
          Glib::ConstructParams::ConstructParams (&D.98443, D.101043, "fd", fd, 0B);
          try
            {
              if (0 == 0) goto <D.101045>; else goto <D.101046>;
              <D.101045>:
              iftmp.25 = __vtt_parm + 8;
              goto <D.101047>;
              <D.101046>:
              iftmp.25 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101047>:
              D.101048 = &this->D.98048;
              Glib::Object::Object (D.101048, iftmp.25, &D.98443);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98443);
              D.98443 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.101050>; else goto <D.101051>;
              <D.101050>:
              iftmp.26 = __vtt_parm + 24;
              goto <D.101052>;
              <D.101051>:
              iftmp.26 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101052>:
              D.101053 = &this->D.98049;
              Gio::Initable::Initable (D.101053, iftmp.26);
              try
                {
                  if (0 == 0) goto <D.101055>; else goto <D.101056>;
                  <D.101055>:
                  iftmp.27 = *__vtt_parm;
                  goto <D.101057>;
                  <D.101056>:
                  iftmp.27 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101057>:
                  this->D.98048._vptr.Object = iftmp.27;
                  if (0 == 0) goto <D.101059>; else goto <D.101060>;
                  <D.101059>:
                  D.101061 = this->D.98048._vptr.Object;
                  D.101062 = D.101061 + 18446744073709551592;
                  D.101063 = MEM[(long int *)D.101062];
                  iftmp.28 = (sizetype) D.101063;
                  goto <D.101064>;
                  <D.101060>:
                  iftmp.28 = 16;
                  <D.101064>:
                  D.101065 = this + iftmp.28;
                  if (0 == 0) goto <D.101067>; else goto <D.101068>;
                  <D.101067>:
                  iftmp.29 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.101069>;
                  <D.101068>:
                  iftmp.29 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101069>:
                  D.101065->_vptr.ObjectBase = iftmp.29;
                  if (0 == 0) goto <D.101071>; else goto <D.101072>;
                  <D.101071>:
                  iftmp.30 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.101073>;
                  <D.101072>:
                  iftmp.30 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101073>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.30;
                  D.101053 = &this->D.98049;
                  Gio::Initable::init (D.101053, cancellable);
                }
              catch
                {
                  if (0 == 0) goto <D.101075>; else goto <D.101076>;
                  <D.101075>:
                  iftmp.31 = __vtt_parm + 24;
                  goto <D.101077>;
                  <D.101076>:
                  iftmp.31 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101077>:
                  D.101053 = &this->D.98049;
                  Gio::Initable::~Initable (D.101053, iftmp.31);
                }
            }
          catch
            {
              if (0 == 0) goto <D.101079>; else goto <D.101080>;
              <D.101079>:
              iftmp.32 = __vtt_parm + 8;
              goto <D.101081>;
              <D.101080>:
              iftmp.32 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101081>:
              D.101048 = &this->D.98048;
              Glib::Object::~Object (D.101048, iftmp.32);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101082>; else goto <D.101083>;
          <D.101082>:
          if (0 == 0) goto <D.101085>; else goto <D.101086>;
          <D.101085>:
          iftmp.33 = __vtt_parm + 72;
          goto <D.101087>;
          <D.101086>:
          iftmp.33 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101087>:
          D.101041 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101041, iftmp.33);
          goto <D.101088>;
          <D.101083>:
          <D.101088>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101089>; else goto <D.101090>;
      <D.101089>:
      D.101033 = &this->D.98053;
      sigc::trackable::~trackable (D.101033);
      goto <D.101091>;
      <D.101090>:
      <D.101091>:
    }
}


Gio::Socket::Socket(int, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, int fd, const struct RefPtr & cancellable)
{
  struct trackable * D.101100;
  const void * * iftmp.34;
  struct ObjectBase * D.101108;
  struct ConstructParams D.98445;
  const struct Class & D.101110;
  const void * * iftmp.35;
  struct Object * D.101115;
  const void * * iftmp.36;
  struct Initable * D.101120;
  int (*__vtbl_ptr_type) () * iftmp.37;
  const void * * D.101124;
  sizetype iftmp.38;
  int (*__vtbl_ptr_type) () * D.101129;
  int (*__vtbl_ptr_type) () * D.101130;
  long int D.101131;
  struct ObjectBase * D.101133;
  int (*__vtbl_ptr_type) () * iftmp.39;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  const void * * iftmp.42;
  const void * * iftmp.43;

  if (1 != 0) goto <D.101098>; else goto <D.101099>;
  <D.101098>:
  D.101100 = &this->D.98053;
  sigc::trackable::trackable (D.101100);
  goto <D.101101>;
  <D.101099>:
  <D.101101>:
  try
    {
      if (1 != 0) goto <D.101102>; else goto <D.101103>;
      <D.101102>:
      if (1 == 0) goto <D.101105>; else goto <D.101106>;
      <D.101105>:
      iftmp.34 = 72B;
      goto <D.101107>;
      <D.101106>:
      iftmp.34 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101107>:
      D.101108 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101108, iftmp.34, 0B);
      goto <D.101109>;
      <D.101103>:
      <D.101109>:
      try
        {
          D.101110 = Gio::Socket_Class::init (&socket_class_);
          Glib::ConstructParams::ConstructParams (&D.98445, D.101110, "fd", fd, 0B);
          try
            {
              if (1 == 0) goto <D.101112>; else goto <D.101113>;
              <D.101112>:
              iftmp.35 = 8B;
              goto <D.101114>;
              <D.101113>:
              iftmp.35 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101114>:
              D.101115 = &this->D.98048;
              Glib::Object::Object (D.101115, iftmp.35, &D.98445);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98445);
              D.98445 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.101117>; else goto <D.101118>;
              <D.101117>:
              iftmp.36 = 24B;
              goto <D.101119>;
              <D.101118>:
              iftmp.36 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101119>:
              D.101120 = &this->D.98049;
              Gio::Initable::Initable (D.101120, iftmp.36);
              try
                {
                  if (1 == 0) goto <D.101122>; else goto <D.101123>;
                  <D.101122>:
                  D.101124 = 0B;
                  iftmp.37 = *D.101124;
                  goto <D.101125>;
                  <D.101123>:
                  iftmp.37 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101125>:
                  this->D.98048._vptr.Object = iftmp.37;
                  if (1 == 0) goto <D.101127>; else goto <D.101128>;
                  <D.101127>:
                  D.101129 = this->D.98048._vptr.Object;
                  D.101130 = D.101129 + 18446744073709551592;
                  D.101131 = MEM[(long int *)D.101130];
                  iftmp.38 = (sizetype) D.101131;
                  goto <D.101132>;
                  <D.101128>:
                  iftmp.38 = 16;
                  <D.101132>:
                  D.101133 = this + iftmp.38;
                  if (1 == 0) goto <D.101135>; else goto <D.101136>;
                  <D.101135>:
                  iftmp.39 = MEM[(const void * *)0B + 56B];
                  goto <D.101137>;
                  <D.101136>:
                  iftmp.39 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101137>:
                  D.101133->_vptr.ObjectBase = iftmp.39;
                  if (1 == 0) goto <D.101139>; else goto <D.101140>;
                  <D.101139>:
                  iftmp.40 = MEM[(const void * *)0B + 64B];
                  goto <D.101141>;
                  <D.101140>:
                  iftmp.40 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101141>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.40;
                  D.101120 = &this->D.98049;
                  Gio::Initable::init (D.101120, cancellable);
                }
              catch
                {
                  if (1 == 0) goto <D.101143>; else goto <D.101144>;
                  <D.101143>:
                  iftmp.41 = 24B;
                  goto <D.101145>;
                  <D.101144>:
                  iftmp.41 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101145>:
                  D.101120 = &this->D.98049;
                  Gio::Initable::~Initable (D.101120, iftmp.41);
                }
            }
          catch
            {
              if (1 == 0) goto <D.101147>; else goto <D.101148>;
              <D.101147>:
              iftmp.42 = 8B;
              goto <D.101149>;
              <D.101148>:
              iftmp.42 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101149>:
              D.101115 = &this->D.98048;
              Glib::Object::~Object (D.101115, iftmp.42);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101150>; else goto <D.101151>;
          <D.101150>:
          if (1 == 0) goto <D.101153>; else goto <D.101154>;
          <D.101153>:
          iftmp.43 = 72B;
          goto <D.101155>;
          <D.101154>:
          iftmp.43 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101155>:
          D.101108 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101108, iftmp.43);
          goto <D.101156>;
          <D.101151>:
          <D.101156>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101157>; else goto <D.101158>;
      <D.101157>:
      D.101100 = &this->D.98053;
      sigc::trackable::~trackable (D.101100);
      goto <D.101159>;
      <D.101158>:
      <D.101159>:
    }
}


static Glib::RefPtr<Gio::Socket> Gio::Socket::create(Gio::SocketFamily, Gio::SocketType, Gio::SocketProtocol, const Glib::RefPtr<Gio::Cancellable>&) (SocketFamily family, SocketType type, SocketProtocol protocol, const struct RefPtr & cancellable)
{
  void * D.98577;

  D.98577 = operator new (56);
  try
    {
      Gio::Socket::Socket (D.98577, family, type, protocol, cancellable);
    }
  catch
    {
      operator delete (D.98577);
    }
  Glib::RefPtr<Gio::Socket>::RefPtr (<retval>, D.98577);
  return <retval>;
}


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


static Glib::RefPtr<Gio::Socket> Gio::Socket::create_from_fd(int, const Glib::RefPtr<Gio::Cancellable>&) (int fd, const struct RefPtr & cancellable)
{
  void * D.98593;

  D.98593 = operator new (56);
  try
    {
      Gio::Socket::Socket (D.98593, fd, cancellable);
    }
  catch
    {
      operator delete (D.98593);
    }
  Glib::RefPtr<Gio::Socket>::RefPtr (<retval>, D.98593);
  return <retval>;
}


gssize Gio::Socket::receive_from(Glib::RefPtr<Gio::SocketAddress>&, char*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, struct RefPtr & address, char * buffer, gsize size, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101174;
  struct GSocket * D.101175;
  struct GError * gerror.44;
  struct GSocketAddress * caddr.45;
  struct RefPtr D.98731;
  gssize D.101183;
  struct GError * gerror;
  struct GSocketAddress * caddr;
  gssize retvalue;

  try
    {
      gerror = 0B;
      caddr = 0B;
      D.101174 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101175 = Gio::Socket::gobj (this);
      retvalue = g_socket_receive_from (D.101175, &caddr, buffer, size, D.101174, &gerror);
      gerror.44 = gerror;
      if (gerror.44 != 0B) goto <D.101177>; else goto <D.101178>;
      <D.101177>:
      gerror.44 = gerror;
      Glib::Error::throw_exception (gerror.44);
      <D.101178>:
      caddr.45 = caddr;
      if (caddr.45 != 0B) goto <D.101180>; else goto <D.101181>;
      <D.101180>:
      caddr.45 = caddr;
      D.98731 = Glib::wrap (caddr.45, 0); [return slot optimization]
      try
        {
          Glib::RefPtr<Gio::SocketAddress>::operator= (address, &D.98731);
        }
      finally
        {
          Glib::RefPtr<Gio::SocketAddress>::~RefPtr (&D.98731);
          D.98731 = {CLOBBER};
        }
      goto <D.101182>;
      <D.101181>:
      <D.101182>:
      D.101183 = retvalue;
      return D.101183;
    }
  finally
    {
      gerror = {CLOBBER};
      caddr = {CLOBBER};
    }
}


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.101190;
  struct BaseObjectType * iftmp.46;
  bool D.101192;
  struct Cancellable * D.101195;

  D.101192 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.101192 != 0) goto <D.101193>; else goto <D.101194>;
  <D.101193>:
  D.101195 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.46 = Gio::Cancellable::gobj (D.101195);
  goto <D.101196>;
  <D.101194>:
  iftmp.46 = 0B;
  <D.101196>:
  D.101190 = iftmp.46;
  return D.101190;
}


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

  D.101199 = this->pCppObject_;
  D.101198 = D.101199 != 0B;
  return D.101198;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.101203;
  int (*__vtbl_ptr_type) () * D.101204;
  int (*__vtbl_ptr_type) () * D.101205;
  long int D.101206;
  sizetype D.101207;
  struct ObjectBase * D.101208;

  D.101204 = this->D.86042._vptr.Object;
  D.101205 = D.101204 + 18446744073709551592;
  D.101206 = MEM[(long int *)D.101205];
  D.101207 = (sizetype) D.101206;
  D.101208 = this + D.101207;
  D.101203 = D.101208->gobject_;
  return D.101203;
}


GSocket* Gio::Socket::gobj() (struct Socket * const this)
{
  struct GSocket * D.101210;
  int (*__vtbl_ptr_type) () * D.101211;
  int (*__vtbl_ptr_type) () * D.101212;
  long int D.101213;
  sizetype D.101214;
  struct ObjectBase * D.101215;

  D.101211 = this->D.98048._vptr.Object;
  D.101212 = D.101211 + 18446744073709551592;
  D.101213 = MEM[(long int *)D.101212];
  D.101214 = (sizetype) D.101213;
  D.101215 = this + D.101214;
  D.101210 = D.101215->gobject_;
  return D.101210;
}


Glib::RefPtr<T_CppObject>& Glib::RefPtr<T_CppObject>::operator=(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::SocketAddress] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct RefPtr & D.101217;
  struct RefPtr temp;

  try
    {
      Glib::RefPtr<Gio::SocketAddress>::RefPtr (&temp, src);
      try
        {
          Glib::RefPtr<Gio::SocketAddress>::swap (this, &temp);
          D.101217 = this;
          return D.101217;
        }
      finally
        {
          Glib::RefPtr<Gio::SocketAddress>::~RefPtr (&temp);
        }
    }
  finally
    {
      temp = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::SocketAddress] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct SocketAddress * D.101222;
  struct SocketAddress * D.101223;
  int (*__vtbl_ptr_type) () * D.101226;
  int (*__vtbl_ptr_type) () * D.101227;
  long int D.101228;
  sizetype D.101229;
  struct ObjectBase * D.101230;
  int (*__vtbl_ptr_type) () * D.101231;
  int (*__vtbl_ptr_type) () * D.101232;
  int (*__vtbl_ptr_type) () D.101233;

  D.101222 = src->pCppObject_;
  this->pCppObject_ = D.101222;
  D.101223 = this->pCppObject_;
  if (D.101223 != 0B) goto <D.101224>; else goto <D.101225>;
  <D.101224>:
  D.101223 = this->pCppObject_;
  D.101223 = this->pCppObject_;
  D.101226 = D.101223->D.97373._vptr.Object;
  D.101227 = D.101226 + 18446744073709551592;
  D.101228 = MEM[(long int *)D.101227];
  D.101229 = (sizetype) D.101228;
  D.101230 = D.101223 + D.101229;
  D.101223 = this->pCppObject_;
  D.101223 = this->pCppObject_;
  D.101226 = D.101223->D.97373._vptr.Object;
  D.101227 = D.101226 + 18446744073709551592;
  D.101228 = MEM[(long int *)D.101227];
  D.101229 = (sizetype) D.101228;
  D.101230 = D.101223 + D.101229;
  D.101231 = D.101230->_vptr.ObjectBase;
  D.101232 = D.101231 + 16;
  D.101233 = *D.101232;
  D.101223 = this->pCppObject_;
  D.101223 = this->pCppObject_;
  D.101226 = D.101223->D.97373._vptr.Object;
  D.101227 = D.101226 + 18446744073709551592;
  D.101228 = MEM[(long int *)D.101227];
  D.101229 = (sizetype) D.101228;
  D.101230 = D.101223 + D.101229;
  OBJ_TYPE_REF(D.101233;(const struct ObjectBase)D.101230->2) (D.101230);
  goto <D.101234>;
  <D.101225>:
  <D.101234>:
}


void Glib::RefPtr<T_CppObject>::swap(Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::SocketAddress] (struct RefPtr * const this, struct RefPtr & other)
{
  struct SocketAddress * D.101235;
  struct SocketAddress * const temp;

  temp = this->pCppObject_;
  D.101235 = other->pCppObject_;
  this->pCppObject_ = D.101235;
  other->pCppObject_ = temp;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketAddress] (struct RefPtr * const this)
{
  struct SocketAddress * D.101236;
  int (*__vtbl_ptr_type) () * D.101239;
  int (*__vtbl_ptr_type) () * D.101240;
  long int D.101241;
  sizetype D.101242;
  struct ObjectBase * D.101243;
  int (*__vtbl_ptr_type) () * D.101244;
  int (*__vtbl_ptr_type) () * D.101245;
  int (*__vtbl_ptr_type) () D.101246;

  {
    try
      {
        D.101236 = this->pCppObject_;
        if (D.101236 != 0B) goto <D.101237>; else goto <D.101238>;
        <D.101237>:
        D.101236 = this->pCppObject_;
        D.101236 = this->pCppObject_;
        D.101239 = D.101236->D.97373._vptr.Object;
        D.101240 = D.101239 + 18446744073709551592;
        D.101241 = MEM[(long int *)D.101240];
        D.101242 = (sizetype) D.101241;
        D.101243 = D.101236 + D.101242;
        D.101236 = this->pCppObject_;
        D.101236 = this->pCppObject_;
        D.101239 = D.101236->D.97373._vptr.Object;
        D.101240 = D.101239 + 18446744073709551592;
        D.101241 = MEM[(long int *)D.101240];
        D.101242 = (sizetype) D.101241;
        D.101243 = D.101236 + D.101242;
        D.101244 = D.101243->_vptr.ObjectBase;
        D.101245 = D.101244 + 24;
        D.101246 = *D.101245;
        D.101236 = this->pCppObject_;
        D.101236 = this->pCppObject_;
        D.101239 = D.101236->D.97373._vptr.Object;
        D.101240 = D.101239 + 18446744073709551592;
        D.101241 = MEM[(long int *)D.101240];
        D.101242 = (sizetype) D.101241;
        D.101243 = D.101236 + D.101242;
        OBJ_TYPE_REF(D.101246;(const struct ObjectBase)D.101243->3) (D.101243);
        goto <D.101247>;
        <D.101238>:
        <D.101247>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100491>:
}


gssize Gio::Socket::receive_from(Glib::RefPtr<Gio::SocketAddress>&, char*, gsize) (struct Socket * const this, struct RefPtr & address, char * buffer, gsize size)
{
  struct GSocket * D.101249;
  struct GError * gerror.47;
  struct GSocketAddress * caddr.48;
  struct RefPtr D.98744;
  gssize D.101257;
  struct GError * gerror;
  struct GSocketAddress * caddr;
  gssize retvalue;

  try
    {
      gerror = 0B;
      caddr = 0B;
      D.101249 = Gio::Socket::gobj (this);
      retvalue = g_socket_receive_from (D.101249, &caddr, buffer, size, 0B, &gerror);
      gerror.47 = gerror;
      if (gerror.47 != 0B) goto <D.101251>; else goto <D.101252>;
      <D.101251>:
      gerror.47 = gerror;
      Glib::Error::throw_exception (gerror.47);
      <D.101252>:
      caddr.48 = caddr;
      if (caddr.48 != 0B) goto <D.101254>; else goto <D.101255>;
      <D.101254>:
      caddr.48 = caddr;
      D.98744 = Glib::wrap (caddr.48, 0); [return slot optimization]
      try
        {
          Glib::RefPtr<Gio::SocketAddress>::operator= (address, &D.98744);
        }
      finally
        {
          Glib::RefPtr<Gio::SocketAddress>::~RefPtr (&D.98744);
          D.98744 = {CLOBBER};
        }
      goto <D.101256>;
      <D.101255>:
      <D.101256>:
      D.101257 = retvalue;
      return D.101257;
    }
  finally
    {
      gerror = {CLOBBER};
      caddr = {CLOBBER};
    }
}


gssize Gio::Socket::receive_with_blocking(gchar*, gsize, bool, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, gchar * buffer, gsize size, bool blocking, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101263;
  int D.101264;
  struct GSocket * D.101265;
  struct GError * gerror.49;
  gssize D.101269;
  struct GError * gerror;
  const gssize retvalue;

  try
    {
      gerror = 0B;
      D.101263 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101264 = (int) blocking;
      D.101265 = Gio::Socket::gobj (this);
      retvalue = g_socket_receive_with_blocking (D.101265, buffer, size, D.101264, D.101263, &gerror);
      gerror.49 = gerror;
      if (gerror.49 != 0B) goto <D.101267>; else goto <D.101268>;
      <D.101267>:
      gerror.49 = gerror;
      Glib::Error::throw_exception (gerror.49);
      <D.101268>:
      D.101269 = retvalue;
      return D.101269;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::send_with_blocking(gchar*, gsize, bool, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, gchar * buffer, gsize size, bool blocking, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101275;
  int D.101276;
  struct GSocket * D.101277;
  struct GError * gerror.50;
  gssize D.101281;
  struct GError * gerror;
  const gssize retvalue;

  try
    {
      gerror = 0B;
      D.101275 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101276 = (int) blocking;
      D.101277 = Gio::Socket::gobj (this);
      retvalue = g_socket_send_with_blocking (D.101277, buffer, size, D.101276, D.101275, &gerror);
      gerror.50 = gerror;
      if (gerror.50 != 0B) goto <D.101279>; else goto <D.101280>;
      <D.101279>:
      gerror.50 = gerror;
      Glib::Error::throw_exception (gerror.50);
      <D.101280>:
      D.101281 = retvalue;
      return D.101281;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketSource> Gio::Socket::create_source(Glib::IOCondition, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, IOCondition condition, const struct RefPtr & cancellable)
{
  int (*__vtbl_ptr_type) () * D.101288;
  int (*__vtbl_ptr_type) () * D.101289;
  long int D.101290;
  sizetype D.101291;
  struct ObjectBase * D.101292;
  int (*__vtbl_ptr_type) () * D.101293;
  int (*__vtbl_ptr_type) () * D.101294;
  int (*__vtbl_ptr_type) () D.101295;
  struct RefPtr D.98892;

  D.101288 = this->D.98048._vptr.Object;
  D.101289 = D.101288 + 18446744073709551592;
  D.101290 = MEM[(long int *)D.101289];
  D.101291 = (sizetype) D.101290;
  D.101292 = this + D.101291;
  D.101288 = this->D.98048._vptr.Object;
  D.101289 = D.101288 + 18446744073709551592;
  D.101290 = MEM[(long int *)D.101289];
  D.101291 = (sizetype) D.101290;
  D.101292 = this + D.101291;
  D.101293 = D.101292->_vptr.ObjectBase;
  D.101294 = D.101293 + 16;
  D.101295 = *D.101294;
  D.101288 = this->D.98048._vptr.Object;
  D.101289 = D.101288 + 18446744073709551592;
  D.101290 = MEM[(long int *)D.101289];
  D.101291 = (sizetype) D.101290;
  D.101292 = this + D.101291;
  OBJ_TYPE_REF(D.101295;(const struct ObjectBase)D.101292->2) (D.101292);
  Glib::RefPtr<Gio::Socket>::RefPtr (&D.98892, this);
  try
    {
      *<retval> = Gio::SocketSource::create (&D.98892, condition, cancellable); [return slot optimization]
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Socket>::~RefPtr (&D.98892);
      D.98892 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Socket] (struct RefPtr * const this)
{
  struct Socket * D.101299;
  int (*__vtbl_ptr_type) () * D.101302;
  int (*__vtbl_ptr_type) () * D.101303;
  long int D.101304;
  sizetype D.101305;
  struct ObjectBase * D.101306;
  int (*__vtbl_ptr_type) () * D.101307;
  int (*__vtbl_ptr_type) () * D.101308;
  int (*__vtbl_ptr_type) () D.101309;

  {
    try
      {
        D.101299 = this->pCppObject_;
        if (D.101299 != 0B) goto <D.101300>; else goto <D.101301>;
        <D.101300>:
        D.101299 = this->pCppObject_;
        D.101299 = this->pCppObject_;
        D.101302 = D.101299->D.98048._vptr.Object;
        D.101303 = D.101302 + 18446744073709551592;
        D.101304 = MEM[(long int *)D.101303];
        D.101305 = (sizetype) D.101304;
        D.101306 = D.101299 + D.101305;
        D.101299 = this->pCppObject_;
        D.101299 = this->pCppObject_;
        D.101302 = D.101299->D.98048._vptr.Object;
        D.101303 = D.101302 + 18446744073709551592;
        D.101304 = MEM[(long int *)D.101303];
        D.101305 = (sizetype) D.101304;
        D.101306 = D.101299 + D.101305;
        D.101307 = D.101306->_vptr.ObjectBase;
        D.101308 = D.101307 + 24;
        D.101309 = *D.101308;
        D.101299 = this->pCppObject_;
        D.101299 = this->pCppObject_;
        D.101302 = D.101299->D.98048._vptr.Object;
        D.101303 = D.101302 + 18446744073709551592;
        D.101304 = MEM[(long int *)D.101303];
        D.101305 = (sizetype) D.101304;
        D.101306 = D.101299 + D.101305;
        OBJ_TYPE_REF(D.101309;(const struct ObjectBase)D.101306->3) (D.101306);
        goto <D.101310>;
        <D.101301>:
        <D.101310>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100480>:
}


static GType Glib::Value<Gio::SocketType>::value_type() ()
{
  GType D.101312;

  D.101312 = g_socket_type_get_type ();
  return D.101312;
}


static GType Glib::Value<Gio::SocketProtocol>::value_type() ()
{
  GType D.101315;

  D.101315 = g_socket_protocol_get_type ();
  return D.101315;
}


static GType Glib::Value<Gio::SocketMsgFlags>::value_type() ()
{
  GType D.101318;

  D.101318 = g_socket_msg_flags_get_type ();
  return D.101318;
}


Glib::RefPtr<Gio::Socket> Glib::wrap(GSocket*, bool) (struct GSocket * object, bool take_copy)
{
  struct Socket * iftmp.51;
  int D.101323;
  struct ObjectBase * D.101324;

  D.101323 = (int) take_copy;
  D.101324 = Glib::wrap_auto (object, D.101323);
  if (D.101324 == 0B) goto <D.101325>; else goto <D.101326>;
  <D.101325>:
  iftmp.51 = 0B;
  goto <D.101327>;
  <D.101326>:
  iftmp.51 = __dynamic_cast (D.101324, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6SocketE, -1);
  <D.101327>:
  Glib::RefPtr<Gio::Socket>::RefPtr (<retval>, iftmp.51);
  return <retval>;
}


const Glib::Class& Gio::Socket_Class::init() (struct Socket_Class * const this)
{
  long unsigned int D.101330;
  long unsigned int D.101333;
  struct Class * D.101334;
  long unsigned int D.101335;
  const struct Class & D.101337;

  D.101330 = this->D.98225.gtype_;
  if (D.101330 == 0) goto <D.101331>; else goto <D.101332>;
  <D.101331>:
  this->D.98225.class_init_func_ = class_init_function;
  D.101333 = g_socket_get_type ();
  D.101334 = &this->D.98225;
  Glib::Class::register_derived_type (D.101334, D.101333);
  D.101334 = &this->D.98225;
  D.101335 = Glib::Class::get_type (D.101334);
  Gio::Initable::add_interface (D.101335);
  goto <D.101336>;
  <D.101332>:
  <D.101336>:
  D.101337 = &this->D.98225;
  return D.101337;
}


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

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


static void Gio::Socket_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::Socket_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.101342;
  struct ObjectBase * iftmp.52;
  void * D.98932;
  void * D.101344;
  int (*__vtbl_ptr_type) () * D.101347;
  int (*__vtbl_ptr_type) () * D.101348;
  long int D.101349;
  sizetype D.101350;

  D.98932 = operator new (56);
  try
    {
      Gio::Socket::Socket (D.98932, object);
    }
  catch
    {
      operator delete (D.98932);
    }
  D.101344 = D.98932;
  if (D.101344 != 0B) goto <D.101345>; else goto <D.101346>;
  <D.101345>:
  D.101347 = MEM[(struct Socket *)D.101344].D.98048._vptr.Object;
  D.101348 = D.101347 + 18446744073709551592;
  D.101349 = MEM[(long int *)D.101348];
  D.101350 = (sizetype) D.101349;
  iftmp.52 = D.101344 + D.101350;
  goto <D.101351>;
  <D.101346>:
  iftmp.52 = 0B;
  <D.101351>:
  D.101342 = iftmp.52;
  return D.101342;
}


GSocket* Gio::Socket::gobj_copy() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.101355;
  int (*__vtbl_ptr_type) () * D.101356;
  long int D.101357;
  sizetype D.101358;
  struct ObjectBase * D.101359;
  int (*__vtbl_ptr_type) () * D.101360;
  int (*__vtbl_ptr_type) () * D.101361;
  int (*__vtbl_ptr_type) () D.101362;
  struct GSocket * D.101363;

  D.101355 = this->D.98048._vptr.Object;
  D.101356 = D.101355 + 18446744073709551592;
  D.101357 = MEM[(long int *)D.101356];
  D.101358 = (sizetype) D.101357;
  D.101359 = this + D.101358;
  D.101355 = this->D.98048._vptr.Object;
  D.101356 = D.101355 + 18446744073709551592;
  D.101357 = MEM[(long int *)D.101356];
  D.101358 = (sizetype) D.101357;
  D.101359 = this + D.101358;
  D.101360 = D.101359->_vptr.ObjectBase;
  D.101361 = D.101360 + 16;
  D.101362 = *D.101361;
  D.101355 = this->D.98048._vptr.Object;
  D.101356 = D.101355 + 18446744073709551592;
  D.101357 = MEM[(long int *)D.101356];
  D.101358 = (sizetype) D.101357;
  D.101359 = this + D.101358;
  OBJ_TYPE_REF(D.101362;(const struct ObjectBase)D.101359->2) (D.101359);
  D.101363 = Gio::Socket::gobj (this);
  return D.101363;
}


Gio::Socket::Socket(const Glib::ConstructParams&) (struct Socket * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.101367;
  const void * * iftmp.53;
  struct ObjectBase * D.101375;
  const void * * iftmp.54;
  struct Object * D.101381;
  const void * * iftmp.55;
  struct Initable * D.101386;
  int (*__vtbl_ptr_type) () * iftmp.56;
  sizetype iftmp.57;
  int (*__vtbl_ptr_type) () * D.101394;
  int (*__vtbl_ptr_type) () * D.101395;
  long int D.101396;
  struct ObjectBase * D.101398;
  int (*__vtbl_ptr_type) () * iftmp.58;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * iftmp.60;
  const void * * iftmp.61;
  const void * * iftmp.62;

  if (0 != 0) goto <D.101365>; else goto <D.101366>;
  <D.101365>:
  D.101367 = &this->D.98053;
  sigc::trackable::trackable (D.101367);
  goto <D.101368>;
  <D.101366>:
  <D.101368>:
  try
    {
      if (0 != 0) goto <D.101369>; else goto <D.101370>;
      <D.101369>:
      if (0 == 0) goto <D.101372>; else goto <D.101373>;
      <D.101372>:
      iftmp.53 = __vtt_parm + 72;
      goto <D.101374>;
      <D.101373>:
      iftmp.53 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101374>:
      D.101375 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101375, iftmp.53);
      goto <D.101376>;
      <D.101370>:
      <D.101376>:
      try
        {
          if (0 == 0) goto <D.101378>; else goto <D.101379>;
          <D.101378>:
          iftmp.54 = __vtt_parm + 8;
          goto <D.101380>;
          <D.101379>:
          iftmp.54 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
          <D.101380>:
          D.101381 = &this->D.98048;
          Glib::Object::Object (D.101381, iftmp.54, construct_params);
          try
            {
              if (0 == 0) goto <D.101383>; else goto <D.101384>;
              <D.101383>:
              iftmp.55 = __vtt_parm + 24;
              goto <D.101385>;
              <D.101384>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101385>:
              D.101386 = &this->D.98049;
              Gio::Initable::Initable (D.101386, iftmp.55);
              try
                {
                  if (0 == 0) goto <D.101388>; else goto <D.101389>;
                  <D.101388>:
                  iftmp.56 = *__vtt_parm;
                  goto <D.101390>;
                  <D.101389>:
                  iftmp.56 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101390>:
                  this->D.98048._vptr.Object = iftmp.56;
                  if (0 == 0) goto <D.101392>; else goto <D.101393>;
                  <D.101392>:
                  D.101394 = this->D.98048._vptr.Object;
                  D.101395 = D.101394 + 18446744073709551592;
                  D.101396 = MEM[(long int *)D.101395];
                  iftmp.57 = (sizetype) D.101396;
                  goto <D.101397>;
                  <D.101393>:
                  iftmp.57 = 16;
                  <D.101397>:
                  D.101398 = this + iftmp.57;
                  if (0 == 0) goto <D.101400>; else goto <D.101401>;
                  <D.101400>:
                  iftmp.58 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.101402>;
                  <D.101401>:
                  iftmp.58 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101402>:
                  D.101398->_vptr.ObjectBase = iftmp.58;
                  if (0 == 0) goto <D.101404>; else goto <D.101405>;
                  <D.101404>:
                  iftmp.59 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.101406>;
                  <D.101405>:
                  iftmp.59 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101406>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.59;
                }
              catch
                {
                  if (0 == 0) goto <D.101408>; else goto <D.101409>;
                  <D.101408>:
                  iftmp.60 = __vtt_parm + 24;
                  goto <D.101410>;
                  <D.101409>:
                  iftmp.60 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101410>:
                  D.101386 = &this->D.98049;
                  Gio::Initable::~Initable (D.101386, iftmp.60);
                }
            }
          catch
            {
              if (0 == 0) goto <D.101412>; else goto <D.101413>;
              <D.101412>:
              iftmp.61 = __vtt_parm + 8;
              goto <D.101414>;
              <D.101413>:
              iftmp.61 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101414>:
              D.101381 = &this->D.98048;
              Glib::Object::~Object (D.101381, iftmp.61);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101415>; else goto <D.101416>;
          <D.101415>:
          if (0 == 0) goto <D.101418>; else goto <D.101419>;
          <D.101418>:
          iftmp.62 = __vtt_parm + 72;
          goto <D.101420>;
          <D.101419>:
          iftmp.62 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101420>:
          D.101375 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101375, iftmp.62);
          goto <D.101421>;
          <D.101416>:
          <D.101421>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101422>; else goto <D.101423>;
      <D.101422>:
      D.101367 = &this->D.98053;
      sigc::trackable::~trackable (D.101367);
      goto <D.101424>;
      <D.101423>:
      <D.101424>:
    }
}


Gio::Socket::Socket(const Glib::ConstructParams&) (struct Socket * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.101430;
  const void * * iftmp.63;
  struct ObjectBase * D.101438;
  const void * * iftmp.64;
  struct Object * D.101444;
  const void * * iftmp.65;
  struct Initable * D.101449;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * D.101453;
  sizetype iftmp.67;
  int (*__vtbl_ptr_type) () * D.101458;
  int (*__vtbl_ptr_type) () * D.101459;
  long int D.101460;
  struct ObjectBase * D.101462;
  int (*__vtbl_ptr_type) () * iftmp.68;
  int (*__vtbl_ptr_type) () * iftmp.69;
  const void * * iftmp.70;
  const void * * iftmp.71;
  const void * * iftmp.72;

  if (1 != 0) goto <D.101428>; else goto <D.101429>;
  <D.101428>:
  D.101430 = &this->D.98053;
  sigc::trackable::trackable (D.101430);
  goto <D.101431>;
  <D.101429>:
  <D.101431>:
  try
    {
      if (1 != 0) goto <D.101432>; else goto <D.101433>;
      <D.101432>:
      if (1 == 0) goto <D.101435>; else goto <D.101436>;
      <D.101435>:
      iftmp.63 = 72B;
      goto <D.101437>;
      <D.101436>:
      iftmp.63 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101437>:
      D.101438 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101438, iftmp.63);
      goto <D.101439>;
      <D.101433>:
      <D.101439>:
      try
        {
          if (1 == 0) goto <D.101441>; else goto <D.101442>;
          <D.101441>:
          iftmp.64 = 8B;
          goto <D.101443>;
          <D.101442>:
          iftmp.64 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
          <D.101443>:
          D.101444 = &this->D.98048;
          Glib::Object::Object (D.101444, iftmp.64, construct_params);
          try
            {
              if (1 == 0) goto <D.101446>; else goto <D.101447>;
              <D.101446>:
              iftmp.65 = 24B;
              goto <D.101448>;
              <D.101447>:
              iftmp.65 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101448>:
              D.101449 = &this->D.98049;
              Gio::Initable::Initable (D.101449, iftmp.65);
              try
                {
                  if (1 == 0) goto <D.101451>; else goto <D.101452>;
                  <D.101451>:
                  D.101453 = 0B;
                  iftmp.66 = *D.101453;
                  goto <D.101454>;
                  <D.101452>:
                  iftmp.66 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101454>:
                  this->D.98048._vptr.Object = iftmp.66;
                  if (1 == 0) goto <D.101456>; else goto <D.101457>;
                  <D.101456>:
                  D.101458 = this->D.98048._vptr.Object;
                  D.101459 = D.101458 + 18446744073709551592;
                  D.101460 = MEM[(long int *)D.101459];
                  iftmp.67 = (sizetype) D.101460;
                  goto <D.101461>;
                  <D.101457>:
                  iftmp.67 = 16;
                  <D.101461>:
                  D.101462 = this + iftmp.67;
                  if (1 == 0) goto <D.101464>; else goto <D.101465>;
                  <D.101464>:
                  iftmp.68 = MEM[(const void * *)0B + 56B];
                  goto <D.101466>;
                  <D.101465>:
                  iftmp.68 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101466>:
                  D.101462->_vptr.ObjectBase = iftmp.68;
                  if (1 == 0) goto <D.101468>; else goto <D.101469>;
                  <D.101468>:
                  iftmp.69 = MEM[(const void * *)0B + 64B];
                  goto <D.101470>;
                  <D.101469>:
                  iftmp.69 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101470>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.69;
                }
              catch
                {
                  if (1 == 0) goto <D.101472>; else goto <D.101473>;
                  <D.101472>:
                  iftmp.70 = 24B;
                  goto <D.101474>;
                  <D.101473>:
                  iftmp.70 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101474>:
                  D.101449 = &this->D.98049;
                  Gio::Initable::~Initable (D.101449, iftmp.70);
                }
            }
          catch
            {
              if (1 == 0) goto <D.101476>; else goto <D.101477>;
              <D.101476>:
              iftmp.71 = 8B;
              goto <D.101478>;
              <D.101477>:
              iftmp.71 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101478>:
              D.101444 = &this->D.98048;
              Glib::Object::~Object (D.101444, iftmp.71);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101479>; else goto <D.101480>;
          <D.101479>:
          if (1 == 0) goto <D.101482>; else goto <D.101483>;
          <D.101482>:
          iftmp.72 = 72B;
          goto <D.101484>;
          <D.101483>:
          iftmp.72 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101484>:
          D.101438 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101438, iftmp.72);
          goto <D.101485>;
          <D.101480>:
          <D.101485>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101486>; else goto <D.101487>;
      <D.101486>:
      D.101430 = &this->D.98053;
      sigc::trackable::~trackable (D.101430);
      goto <D.101488>;
      <D.101487>:
      <D.101488>:
    }
}


Gio::Socket::Socket(GSocket*) (struct Socket * const this, const void * * __vtt_parm, struct GSocket * castitem)
{
  struct trackable * D.101494;
  const void * * iftmp.73;
  struct ObjectBase * D.101502;
  const void * * iftmp.74;
  struct Object * D.101508;
  const void * * iftmp.75;
  struct Initable * D.101513;
  int (*__vtbl_ptr_type) () * iftmp.76;
  sizetype iftmp.77;
  int (*__vtbl_ptr_type) () * D.101521;
  int (*__vtbl_ptr_type) () * D.101522;
  long int D.101523;
  struct ObjectBase * D.101525;
  int (*__vtbl_ptr_type) () * iftmp.78;
  int (*__vtbl_ptr_type) () * iftmp.79;
  const void * * iftmp.80;
  const void * * iftmp.81;
  const void * * iftmp.82;

  if (0 != 0) goto <D.101492>; else goto <D.101493>;
  <D.101492>:
  D.101494 = &this->D.98053;
  sigc::trackable::trackable (D.101494);
  goto <D.101495>;
  <D.101493>:
  <D.101495>:
  try
    {
      if (0 != 0) goto <D.101496>; else goto <D.101497>;
      <D.101496>:
      if (0 == 0) goto <D.101499>; else goto <D.101500>;
      <D.101499>:
      iftmp.73 = __vtt_parm + 72;
      goto <D.101501>;
      <D.101500>:
      iftmp.73 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101501>:
      D.101502 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101502, iftmp.73);
      goto <D.101503>;
      <D.101497>:
      <D.101503>:
      try
        {
          if (0 == 0) goto <D.101505>; else goto <D.101506>;
          <D.101505>:
          iftmp.74 = __vtt_parm + 8;
          goto <D.101507>;
          <D.101506>:
          iftmp.74 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
          <D.101507>:
          D.101508 = &this->D.98048;
          Glib::Object::Object (D.101508, iftmp.74, castitem);
          try
            {
              if (0 == 0) goto <D.101510>; else goto <D.101511>;
              <D.101510>:
              iftmp.75 = __vtt_parm + 24;
              goto <D.101512>;
              <D.101511>:
              iftmp.75 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101512>:
              D.101513 = &this->D.98049;
              Gio::Initable::Initable (D.101513, iftmp.75);
              try
                {
                  if (0 == 0) goto <D.101515>; else goto <D.101516>;
                  <D.101515>:
                  iftmp.76 = *__vtt_parm;
                  goto <D.101517>;
                  <D.101516>:
                  iftmp.76 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101517>:
                  this->D.98048._vptr.Object = iftmp.76;
                  if (0 == 0) goto <D.101519>; else goto <D.101520>;
                  <D.101519>:
                  D.101521 = this->D.98048._vptr.Object;
                  D.101522 = D.101521 + 18446744073709551592;
                  D.101523 = MEM[(long int *)D.101522];
                  iftmp.77 = (sizetype) D.101523;
                  goto <D.101524>;
                  <D.101520>:
                  iftmp.77 = 16;
                  <D.101524>:
                  D.101525 = this + iftmp.77;
                  if (0 == 0) goto <D.101527>; else goto <D.101528>;
                  <D.101527>:
                  iftmp.78 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.101529>;
                  <D.101528>:
                  iftmp.78 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101529>:
                  D.101525->_vptr.ObjectBase = iftmp.78;
                  if (0 == 0) goto <D.101531>; else goto <D.101532>;
                  <D.101531>:
                  iftmp.79 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.101533>;
                  <D.101532>:
                  iftmp.79 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101533>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.79;
                }
              catch
                {
                  if (0 == 0) goto <D.101535>; else goto <D.101536>;
                  <D.101535>:
                  iftmp.80 = __vtt_parm + 24;
                  goto <D.101537>;
                  <D.101536>:
                  iftmp.80 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101537>:
                  D.101513 = &this->D.98049;
                  Gio::Initable::~Initable (D.101513, iftmp.80);
                }
            }
          catch
            {
              if (0 == 0) goto <D.101539>; else goto <D.101540>;
              <D.101539>:
              iftmp.81 = __vtt_parm + 8;
              goto <D.101541>;
              <D.101540>:
              iftmp.81 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101541>:
              D.101508 = &this->D.98048;
              Glib::Object::~Object (D.101508, iftmp.81);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101542>; else goto <D.101543>;
          <D.101542>:
          if (0 == 0) goto <D.101545>; else goto <D.101546>;
          <D.101545>:
          iftmp.82 = __vtt_parm + 72;
          goto <D.101547>;
          <D.101546>:
          iftmp.82 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101547>:
          D.101502 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101502, iftmp.82);
          goto <D.101548>;
          <D.101543>:
          <D.101548>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101549>; else goto <D.101550>;
      <D.101549>:
      D.101494 = &this->D.98053;
      sigc::trackable::~trackable (D.101494);
      goto <D.101551>;
      <D.101550>:
      <D.101551>:
    }
}


Gio::Socket::Socket(GSocket*) (struct Socket * const this, struct GSocket * castitem)
{
  struct trackable * D.101557;
  const void * * iftmp.83;
  struct ObjectBase * D.101565;
  const void * * iftmp.84;
  struct Object * D.101571;
  const void * * iftmp.85;
  struct Initable * D.101576;
  int (*__vtbl_ptr_type) () * iftmp.86;
  const void * * D.101580;
  sizetype iftmp.87;
  int (*__vtbl_ptr_type) () * D.101585;
  int (*__vtbl_ptr_type) () * D.101586;
  long int D.101587;
  struct ObjectBase * D.101589;
  int (*__vtbl_ptr_type) () * iftmp.88;
  int (*__vtbl_ptr_type) () * iftmp.89;
  const void * * iftmp.90;
  const void * * iftmp.91;
  const void * * iftmp.92;

  if (1 != 0) goto <D.101555>; else goto <D.101556>;
  <D.101555>:
  D.101557 = &this->D.98053;
  sigc::trackable::trackable (D.101557);
  goto <D.101558>;
  <D.101556>:
  <D.101558>:
  try
    {
      if (1 != 0) goto <D.101559>; else goto <D.101560>;
      <D.101559>:
      if (1 == 0) goto <D.101562>; else goto <D.101563>;
      <D.101562>:
      iftmp.83 = 72B;
      goto <D.101564>;
      <D.101563>:
      iftmp.83 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
      <D.101564>:
      D.101565 = &this->D.98052;
      Glib::ObjectBase::ObjectBase (D.101565, iftmp.83);
      goto <D.101566>;
      <D.101560>:
      <D.101566>:
      try
        {
          if (1 == 0) goto <D.101568>; else goto <D.101569>;
          <D.101568>:
          iftmp.84 = 8B;
          goto <D.101570>;
          <D.101569>:
          iftmp.84 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
          <D.101570>:
          D.101571 = &this->D.98048;
          Glib::Object::Object (D.101571, iftmp.84, castitem);
          try
            {
              if (1 == 0) goto <D.101573>; else goto <D.101574>;
              <D.101573>:
              iftmp.85 = 24B;
              goto <D.101575>;
              <D.101574>:
              iftmp.85 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
              <D.101575>:
              D.101576 = &this->D.98049;
              Gio::Initable::Initable (D.101576, iftmp.85);
              try
                {
                  if (1 == 0) goto <D.101578>; else goto <D.101579>;
                  <D.101578>:
                  D.101580 = 0B;
                  iftmp.86 = *D.101580;
                  goto <D.101581>;
                  <D.101579>:
                  iftmp.86 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
                  <D.101581>:
                  this->D.98048._vptr.Object = iftmp.86;
                  if (1 == 0) goto <D.101583>; else goto <D.101584>;
                  <D.101583>:
                  D.101585 = this->D.98048._vptr.Object;
                  D.101586 = D.101585 + 18446744073709551592;
                  D.101587 = MEM[(long int *)D.101586];
                  iftmp.87 = (sizetype) D.101587;
                  goto <D.101588>;
                  <D.101584>:
                  iftmp.87 = 16;
                  <D.101588>:
                  D.101589 = this + iftmp.87;
                  if (1 == 0) goto <D.101591>; else goto <D.101592>;
                  <D.101591>:
                  iftmp.88 = MEM[(const void * *)0B + 56B];
                  goto <D.101593>;
                  <D.101592>:
                  iftmp.88 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
                  <D.101593>:
                  D.101589->_vptr.ObjectBase = iftmp.88;
                  if (1 == 0) goto <D.101595>; else goto <D.101596>;
                  <D.101595>:
                  iftmp.89 = MEM[(const void * *)0B + 64B];
                  goto <D.101597>;
                  <D.101596>:
                  iftmp.89 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
                  <D.101597>:
                  this->D.98049.D.86165._vptr.Interface = iftmp.89;
                }
              catch
                {
                  if (1 == 0) goto <D.101599>; else goto <D.101600>;
                  <D.101599>:
                  iftmp.90 = 24B;
                  goto <D.101601>;
                  <D.101600>:
                  iftmp.90 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                  <D.101601>:
                  D.101576 = &this->D.98049;
                  Gio::Initable::~Initable (D.101576, iftmp.90);
                }
            }
          catch
            {
              if (1 == 0) goto <D.101603>; else goto <D.101604>;
              <D.101603>:
              iftmp.91 = 8B;
              goto <D.101605>;
              <D.101604>:
              iftmp.91 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
              <D.101605>:
              D.101571 = &this->D.98048;
              Glib::Object::~Object (D.101571, iftmp.91);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101606>; else goto <D.101607>;
          <D.101606>:
          if (1 == 0) goto <D.101609>; else goto <D.101610>;
          <D.101609>:
          iftmp.92 = 72B;
          goto <D.101611>;
          <D.101610>:
          iftmp.92 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
          <D.101611>:
          D.101565 = &this->D.98052;
          Glib::ObjectBase::~ObjectBase (D.101565, iftmp.92);
          goto <D.101612>;
          <D.101607>:
          <D.101612>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101613>; else goto <D.101614>;
      <D.101613>:
      D.101557 = &this->D.98053;
      sigc::trackable::~trackable (D.101557);
      goto <D.101615>;
      <D.101614>:
      <D.101615>:
    }
}


Gio::Socket::~Socket() (struct Socket * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.93;
  sizetype iftmp.94;
  int (*__vtbl_ptr_type) () * D.101626;
  int (*__vtbl_ptr_type) () * D.101627;
  long int D.101628;
  struct ObjectBase * D.101630;
  int (*__vtbl_ptr_type) () * iftmp.95;
  int (*__vtbl_ptr_type) () * iftmp.96;
  const void * * iftmp.97;
  struct Initable * D.101643;
  const void * * iftmp.98;
  struct Object * D.101648;
  int D.101649;
  const void * * iftmp.99;
  struct ObjectBase * D.101656;
  struct trackable * D.101660;
  int D.101662;

  {
    if (0 == 0) goto <D.101620>; else goto <D.101621>;
    <D.101620>:
    iftmp.93 = *__vtt_parm;
    goto <D.101622>;
    <D.101621>:
    iftmp.93 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
    <D.101622>:
    this->D.98048._vptr.Object = iftmp.93;
    if (0 == 0) goto <D.101624>; else goto <D.101625>;
    <D.101624>:
    D.101626 = this->D.98048._vptr.Object;
    D.101627 = D.101626 + 18446744073709551592;
    D.101628 = MEM[(long int *)D.101627];
    iftmp.94 = (sizetype) D.101628;
    goto <D.101629>;
    <D.101625>:
    iftmp.94 = 16;
    <D.101629>:
    D.101630 = this + iftmp.94;
    if (0 == 0) goto <D.101632>; else goto <D.101633>;
    <D.101632>:
    iftmp.95 = MEM[(const void * *)__vtt_parm + 56B];
    goto <D.101634>;
    <D.101633>:
    iftmp.95 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
    <D.101634>:
    D.101630->_vptr.ObjectBase = iftmp.95;
    if (0 == 0) goto <D.101636>; else goto <D.101637>;
    <D.101636>:
    iftmp.96 = MEM[(const void * *)__vtt_parm + 64B];
    goto <D.101638>;
    <D.101637>:
    iftmp.96 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
    <D.101638>:
    this->D.98049.D.86165._vptr.Interface = iftmp.96;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (0 == 0) goto <D.101640>; else goto <D.101641>;
                        <D.101640>:
                        iftmp.97 = __vtt_parm + 24;
                        goto <D.101642>;
                        <D.101641>:
                        iftmp.97 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                        <D.101642>:
                        D.101643 = &this->D.98049;
                        Gio::Initable::~Initable (D.101643, iftmp.97);
                      }
                  }
                finally
                  {
                    if (0 == 0) goto <D.101645>; else goto <D.101646>;
                    <D.101645>:
                    iftmp.98 = __vtt_parm + 8;
                    goto <D.101647>;
                    <D.101646>:
                    iftmp.98 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
                    <D.101647>:
                    D.101648 = &this->D.98048;
                    Glib::Object::~Object (D.101648, iftmp.98);
                  }
              }
            finally
              {
                D.101649 = 0;
                if (D.101649 != 0) goto <D.101650>; else goto <D.101651>;
                <D.101650>:
                if (0 == 0) goto <D.101653>; else goto <D.101654>;
                <D.101653>:
                iftmp.99 = __vtt_parm + 72;
                goto <D.101655>;
                <D.101654>:
                iftmp.99 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
                <D.101655>:
                D.101656 = &this->D.98052;
                Glib::ObjectBase::~ObjectBase (D.101656, iftmp.99);
                goto <D.101657>;
                <D.101651>:
                <D.101657>:
              }
          }
        finally
          {
            D.101649 = 0;
            if (D.101649 != 0) goto <D.101658>; else goto <D.101659>;
            <D.101658>:
            D.101660 = &this->D.98053;
            sigc::trackable::~trackable (D.101660);
            goto <D.101661>;
            <D.101659>:
            <D.101661>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98960>:
  D.101662 = 0;
  if (D.101662 != 0) goto <D.101663>; else goto <D.101664>;
  <D.101663>:
  operator delete (this);
  goto <D.101665>;
  <D.101664>:
  <D.101665>:
}


virtual Gio::Socket::~Socket() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.100;
  const void * * D.101685;
  sizetype iftmp.101;
  int (*__vtbl_ptr_type) () * D.101690;
  int (*__vtbl_ptr_type) () * D.101691;
  long int D.101692;
  struct ObjectBase * D.101694;
  int (*__vtbl_ptr_type) () * iftmp.102;
  int (*__vtbl_ptr_type) () * iftmp.103;
  const void * * iftmp.104;
  struct Initable * D.101707;
  const void * * iftmp.105;
  struct Object * D.101712;
  int D.101713;
  const void * * iftmp.106;
  struct ObjectBase * D.101720;
  struct trackable * D.101724;
  int D.101726;

  {
    if (2 == 0) goto <D.101683>; else goto <D.101684>;
    <D.101683>:
    D.101685 = 0B;
    iftmp.100 = *D.101685;
    goto <D.101686>;
    <D.101684>:
    iftmp.100 = &MEM[(void *)&_ZTVN3Gio6SocketE + 32B];
    <D.101686>:
    this->D.98048._vptr.Object = iftmp.100;
    if (2 == 0) goto <D.101688>; else goto <D.101689>;
    <D.101688>:
    D.101690 = this->D.98048._vptr.Object;
    D.101691 = D.101690 + 18446744073709551592;
    D.101692 = MEM[(long int *)D.101691];
    iftmp.101 = (sizetype) D.101692;
    goto <D.101693>;
    <D.101689>:
    iftmp.101 = 16;
    <D.101693>:
    D.101694 = this + iftmp.101;
    if (2 == 0) goto <D.101696>; else goto <D.101697>;
    <D.101696>:
    iftmp.102 = MEM[(const void * *)0B + 56B];
    goto <D.101698>;
    <D.101697>:
    iftmp.102 = &MEM[(void *)&_ZTVN3Gio6SocketE + 168B];
    <D.101698>:
    D.101694->_vptr.ObjectBase = iftmp.102;
    if (2 == 0) goto <D.101700>; else goto <D.101701>;
    <D.101700>:
    iftmp.103 = MEM[(const void * *)0B + 64B];
    goto <D.101702>;
    <D.101701>:
    iftmp.103 = &MEM[(void *)&_ZTVN3Gio6SocketE + 80B];
    <D.101702>:
    this->D.98049.D.86165._vptr.Interface = iftmp.103;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (2 == 0) goto <D.101704>; else goto <D.101705>;
                        <D.101704>:
                        iftmp.104 = 24B;
                        goto <D.101706>;
                        <D.101705>:
                        iftmp.104 = &MEM[(void *)&_ZTTN3Gio6SocketE + 24B];
                        <D.101706>:
                        D.101707 = &this->D.98049;
                        Gio::Initable::~Initable (D.101707, iftmp.104);
                      }
                  }
                finally
                  {
                    if (2 == 0) goto <D.101709>; else goto <D.101710>;
                    <D.101709>:
                    iftmp.105 = 8B;
                    goto <D.101711>;
                    <D.101710>:
                    iftmp.105 = &MEM[(void *)&_ZTTN3Gio6SocketE + 8B];
                    <D.101711>:
                    D.101712 = &this->D.98048;
                    Glib::Object::~Object (D.101712, iftmp.105);
                  }
              }
            finally
              {
                D.101713 = 2;
                if (D.101713 != 0) goto <D.101714>; else goto <D.101715>;
                <D.101714>:
                if (2 == 0) goto <D.101717>; else goto <D.101718>;
                <D.101717>:
                iftmp.106 = 72B;
                goto <D.101719>;
                <D.101718>:
                iftmp.106 = &MEM[(void *)&_ZTTN3Gio6SocketE + 72B];
                <D.101719>:
                D.101720 = &this->D.98052;
                Glib::ObjectBase::~ObjectBase (D.101720, iftmp.106);
                goto <D.101721>;
                <D.101715>:
                <D.101721>:
              }
          }
        finally
          {
            D.101713 = 2;
            if (D.101713 != 0) goto <D.101722>; else goto <D.101723>;
            <D.101722>:
            D.101724 = &this->D.98053;
            sigc::trackable::~trackable (D.101724);
            goto <D.101725>;
            <D.101723>:
            <D.101725>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98963>:
  D.101726 = 0;
  if (D.101726 != 0) goto <D.101727>; else goto <D.101728>;
  <D.101727>:
  operator delete (this);
  goto <D.101729>;
  <D.101728>:
  <D.101729>:
}


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


static GType Gio::Socket::get_type() ()
{
  GType D.101746;
  const struct Class & D.101747;

  D.101747 = Gio::Socket_Class::init (&socket_class_);
  D.101746 = Glib::Class::get_type (D.101747);
  return D.101746;
}


static GType Gio::Socket::get_base_type() ()
{
  GType D.101750;

  D.101750 = g_socket_get_type ();
  return D.101750;
}


void Gio::Socket::bind(const Glib::RefPtr<Gio::SocketAddress>&, bool) (struct Socket * const this, const struct RefPtr & address, bool allow_reuse)
{
  int D.101753;
  struct BaseObjectType * D.101754;
  struct GSocket * D.101755;
  struct GError * gerror.107;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101753 = (int) allow_reuse;
      D.101754 = Glib::unwrap<Gio::SocketAddress> (address);
      D.101755 = Gio::Socket::gobj (this);
      g_socket_bind (D.101755, D.101754, D.101753, &gerror);
      gerror.107 = gerror;
      if (gerror.107 != 0B) goto <D.101757>; else goto <D.101758>;
      <D.101757>:
      gerror.107 = gerror;
      Glib::Error::throw_exception (gerror.107);
      <D.101758>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


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.101761;
  struct BaseObjectType * iftmp.108;
  bool D.101763;
  struct SocketAddress * D.101766;

  D.101763 = Glib::RefPtr<Gio::SocketAddress>::operator bool (ptr);
  if (D.101763 != 0) goto <D.101764>; else goto <D.101765>;
  <D.101764>:
  D.101766 = Glib::RefPtr<Gio::SocketAddress>::operator-> (ptr);
  iftmp.108 = Gio::SocketAddress::gobj (D.101766);
  goto <D.101767>;
  <D.101765>:
  iftmp.108 = 0B;
  <D.101767>:
  D.101761 = iftmp.108;
  return D.101761;
}


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

  D.101770 = this->pCppObject_;
  D.101769 = D.101770 != 0B;
  return D.101769;
}


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

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


GSocketAddress* Gio::SocketAddress::gobj() (struct SocketAddress * const this)
{
  struct GSocketAddress * D.101774;
  int (*__vtbl_ptr_type) () * D.101775;
  int (*__vtbl_ptr_type) () * D.101776;
  long int D.101777;
  sizetype D.101778;
  struct ObjectBase * D.101779;

  D.101775 = this->D.97373._vptr.Object;
  D.101776 = D.101775 + 18446744073709551592;
  D.101777 = MEM[(long int *)D.101776];
  D.101778 = (sizetype) D.101777;
  D.101779 = this + D.101778;
  D.101774 = D.101779->gobject_;
  return D.101774;
}


void Gio::Socket::listen() (struct Socket * const this)
{
  struct GSocket * D.101781;
  struct GError * gerror.109;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101781 = Gio::Socket::gobj (this);
      g_socket_listen (D.101781, &gerror);
      gerror.109 = gerror;
      if (gerror.109 != 0B) goto <D.101783>; else goto <D.101784>;
      <D.101783>:
      gerror.109 = gerror;
      Glib::Error::throw_exception (gerror.109);
      <D.101784>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Socket> Gio::Socket::accept(const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101787;
  struct GSocket * D.101788;
  struct GSocket * D.101789;
  struct GError * gerror.110;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101787 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101788 = Gio::Socket::gobj (this);
      D.101789 = g_socket_accept (D.101788, D.101787, &gerror);
      *<retval> = Glib::wrap (D.101789, 0); [return slot optimization]
      try
        {
          gerror.110 = gerror;
          if (gerror.110 != 0B) goto <D.101791>; else goto <D.101792>;
          <D.101791>:
          gerror.110 = gerror;
          Glib::Error::throw_exception (gerror.110);
          <D.101792>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Socket>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::Socket> Gio::Socket::accept() (struct Socket * const this)
{
  struct GSocket * D.101800;
  struct GSocket * D.101801;
  struct GError * gerror.111;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101800 = Gio::Socket::gobj (this);
      D.101801 = g_socket_accept (D.101800, 0B, &gerror);
      *<retval> = Glib::wrap (D.101801, 0); [return slot optimization]
      try
        {
          gerror.111 = gerror;
          if (gerror.111 != 0B) goto <D.101803>; else goto <D.101804>;
          <D.101803>:
          gerror.111 = gerror;
          Glib::Error::throw_exception (gerror.111);
          <D.101804>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Socket>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::connect(const Glib::RefPtr<Gio::SocketAddress>&, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const struct RefPtr & address, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101810;
  struct BaseObjectType * D.101811;
  struct GSocket * D.101812;
  struct GError * gerror.112;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101810 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101811 = Glib::unwrap<Gio::SocketAddress> (address);
      D.101812 = Gio::Socket::gobj (this);
      g_socket_connect (D.101812, D.101811, D.101810, &gerror);
      gerror.112 = gerror;
      if (gerror.112 != 0B) goto <D.101814>; else goto <D.101815>;
      <D.101814>:
      gerror.112 = gerror;
      Glib::Error::throw_exception (gerror.112);
      <D.101815>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::connect(const Glib::RefPtr<Gio::SocketAddress>&) (struct Socket * const this, const struct RefPtr & address)
{
  struct BaseObjectType * D.101819;
  struct GSocket * D.101820;
  struct GError * gerror.113;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101819 = Glib::unwrap<Gio::SocketAddress> (address);
      D.101820 = Gio::Socket::gobj (this);
      g_socket_connect (D.101820, D.101819, 0B, &gerror);
      gerror.113 = gerror;
      if (gerror.113 != 0B) goto <D.101822>; else goto <D.101823>;
      <D.101822>:
      gerror.113 = gerror;
      Glib::Error::throw_exception (gerror.113);
      <D.101823>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::check_connect_result() (struct Socket * const this)
{
  struct GSocket * D.101826;
  struct GError * gerror.114;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101826 = Gio::Socket::gobj (this);
      g_socket_check_connect_result (D.101826, &gerror);
      gerror.114 = gerror;
      if (gerror.114 != 0B) goto <D.101828>; else goto <D.101829>;
      <D.101828>:
      gerror.114 = gerror;
      Glib::Error::throw_exception (gerror.114);
      <D.101829>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::receive(char*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, char * buffer, gsize size, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101831;
  struct GSocket * D.101832;
  struct GError * gerror.115;
  gssize D.101836;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101831 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101832 = Gio::Socket::gobj (this);
      retvalue = g_socket_receive (D.101832, buffer, size, D.101831, &gerror);
      gerror.115 = gerror;
      if (gerror.115 != 0B) goto <D.101834>; else goto <D.101835>;
      <D.101834>:
      gerror.115 = gerror;
      Glib::Error::throw_exception (gerror.115);
      <D.101835>:
      D.101836 = retvalue;
      return D.101836;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::receive(char*, gsize) (struct Socket * const this, char * buffer, gsize size)
{
  struct GSocket * D.101842;
  struct GError * gerror.116;
  gssize D.101846;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101842 = Gio::Socket::gobj (this);
      retvalue = g_socket_receive (D.101842, buffer, size, 0B, &gerror);
      gerror.116 = gerror;
      if (gerror.116 != 0B) goto <D.101844>; else goto <D.101845>;
      <D.101844>:
      gerror.116 = gerror;
      Glib::Error::throw_exception (gerror.116);
      <D.101845>:
      D.101846 = retvalue;
      return D.101846;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::send(const gchar*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const gchar * buffer, gsize size, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101851;
  struct GSocket * D.101852;
  struct GError * gerror.117;
  gssize D.101856;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101851 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101852 = Gio::Socket::gobj (this);
      retvalue = g_socket_send (D.101852, buffer, size, D.101851, &gerror);
      gerror.117 = gerror;
      if (gerror.117 != 0B) goto <D.101854>; else goto <D.101855>;
      <D.101854>:
      gerror.117 = gerror;
      Glib::Error::throw_exception (gerror.117);
      <D.101855>:
      D.101856 = retvalue;
      return D.101856;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::send(const gchar*, gsize) (struct Socket * const this, const gchar * buffer, gsize size)
{
  struct GSocket * D.101862;
  struct GError * gerror.118;
  gssize D.101866;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101862 = Gio::Socket::gobj (this);
      retvalue = g_socket_send (D.101862, buffer, size, 0B, &gerror);
      gerror.118 = gerror;
      if (gerror.118 != 0B) goto <D.101864>; else goto <D.101865>;
      <D.101864>:
      gerror.118 = gerror;
      Glib::Error::throw_exception (gerror.118);
      <D.101865>:
      D.101866 = retvalue;
      return D.101866;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::send_to(const Glib::RefPtr<Gio::SocketAddress>&, const char*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, const struct RefPtr & address, const char * buffer, gsize size, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101871;
  struct BaseObjectType * D.101872;
  struct GSocket * D.101873;
  struct GError * gerror.119;
  gssize D.101877;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101871 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101872 = Glib::unwrap<Gio::SocketAddress> (address);
      D.101873 = Gio::Socket::gobj (this);
      retvalue = g_socket_send_to (D.101873, D.101872, buffer, size, D.101871, &gerror);
      gerror.119 = gerror;
      if (gerror.119 != 0B) goto <D.101875>; else goto <D.101876>;
      <D.101875>:
      gerror.119 = gerror;
      Glib::Error::throw_exception (gerror.119);
      <D.101876>:
      D.101877 = retvalue;
      return D.101877;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::Socket::send_to(const Glib::RefPtr<Gio::SocketAddress>&, const char*, gsize) (struct Socket * const this, const struct RefPtr & address, const char * buffer, gsize size)
{
  struct BaseObjectType * D.101884;
  struct GSocket * D.101885;
  struct GError * gerror.120;
  gssize D.101889;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.101884 = Glib::unwrap<Gio::SocketAddress> (address);
      D.101885 = Gio::Socket::gobj (this);
      retvalue = g_socket_send_to (D.101885, D.101884, buffer, size, 0B, &gerror);
      gerror.120 = gerror;
      if (gerror.120 != 0B) goto <D.101887>; else goto <D.101888>;
      <D.101887>:
      gerror.120 = gerror;
      Glib::Error::throw_exception (gerror.120);
      <D.101888>:
      D.101889 = retvalue;
      return D.101889;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::close() (struct Socket * const this)
{
  struct GSocket * D.101895;
  struct GError * gerror.121;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101895 = Gio::Socket::gobj (this);
      g_socket_close (D.101895, &gerror);
      gerror.121 = gerror;
      if (gerror.121 != 0B) goto <D.101897>; else goto <D.101898>;
      <D.101897>:
      gerror.121 = gerror;
      Glib::Error::throw_exception (gerror.121);
      <D.101898>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::Socket::is_closed() (struct Socket * const this)
{
  bool D.101900;
  struct GSocket * D.101901;
  int D.101902;

  D.101901 = Gio::Socket::gobj (this);
  D.101902 = g_socket_is_closed (D.101901);
  D.101900 = D.101902 != 0;
  return D.101900;
}


void Gio::Socket::shutdown(bool, bool) (struct Socket * const this, bool shutdown_read, bool shutdown_write)
{
  int D.101905;
  int D.101906;
  struct GSocket * D.101907;
  struct GError * gerror.122;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101905 = (int) shutdown_write;
      D.101906 = (int) shutdown_read;
      D.101907 = Gio::Socket::gobj (this);
      g_socket_shutdown (D.101907, D.101906, D.101905, &gerror);
      gerror.122 = gerror;
      if (gerror.122 != 0B) goto <D.101909>; else goto <D.101910>;
      <D.101909>:
      gerror.122 = gerror;
      Glib::Error::throw_exception (gerror.122);
      <D.101910>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::Socket::is_connected() (struct Socket * const this)
{
  bool D.101912;
  struct GSocket * D.101913;
  int D.101914;

  D.101913 = Gio::Socket::gobj (this);
  D.101914 = g_socket_is_connected (D.101913);
  D.101912 = D.101914 != 0;
  return D.101912;
}


gssize Gio::Socket::get_available_bytes() const (const struct Socket * const this)
{
  gssize D.101917;
  const struct GSocket * D.101918;

  D.101918 = Gio::Socket::gobj (this);
  D.101917 = g_socket_get_available_bytes (D.101918);
  return D.101917;
}


const GSocket* Gio::Socket::gobj() const (const struct Socket * const this)
{
  const struct GSocket * D.101921;
  int (*__vtbl_ptr_type) () * D.101922;
  int (*__vtbl_ptr_type) () * D.101923;
  long int D.101924;
  sizetype D.101925;
  const struct ObjectBase * D.101926;

  D.101922 = this->D.98048._vptr.Object;
  D.101923 = D.101922 + 18446744073709551592;
  D.101924 = MEM[(long int *)D.101923];
  D.101925 = (sizetype) D.101924;
  D.101926 = this + D.101925;
  D.101921 = D.101926->gobject_;
  return D.101921;
}


Glib::IOCondition Gio::Socket::condition_check(Glib::IOCondition) (struct Socket * const this, IOCondition condition)
{
  IOCondition D.101928;
  struct GSocket * D.101929;

  D.101929 = Gio::Socket::gobj (this);
  D.101928 = g_socket_condition_check (D.101929, condition);
  return D.101928;
}


void Gio::Socket::condition_wait(Glib::IOCondition, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, IOCondition condition, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101932;
  struct GSocket * D.101933;
  struct GError * gerror.123;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101932 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101933 = Gio::Socket::gobj (this);
      g_socket_condition_wait (D.101933, condition, D.101932, &gerror);
      gerror.123 = gerror;
      if (gerror.123 != 0B) goto <D.101935>; else goto <D.101936>;
      <D.101935>:
      gerror.123 = gerror;
      Glib::Error::throw_exception (gerror.123);
      <D.101936>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::condition_wait(Glib::IOCondition) (struct Socket * const this, IOCondition condition)
{
  struct GSocket * D.101939;
  struct GError * gerror.124;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101939 = Gio::Socket::gobj (this);
      g_socket_condition_wait (D.101939, condition, 0B, &gerror);
      gerror.124 = gerror;
      if (gerror.124 != 0B) goto <D.101941>; else goto <D.101942>;
      <D.101941>:
      gerror.124 = gerror;
      Glib::Error::throw_exception (gerror.124);
      <D.101942>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::condition_timed_wait(Glib::IOCondition, gint64, const Glib::RefPtr<Gio::Cancellable>&) (struct Socket * const this, IOCondition condition, gint64 timeout, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.101944;
  struct GSocket * D.101945;
  struct GError * gerror.125;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101944 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.101945 = Gio::Socket::gobj (this);
      g_socket_condition_timed_wait (D.101945, condition, timeout, D.101944, &gerror);
      gerror.125 = gerror;
      if (gerror.125 != 0B) goto <D.101947>; else goto <D.101948>;
      <D.101947>:
      gerror.125 = gerror;
      Glib::Error::throw_exception (gerror.125);
      <D.101948>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::condition_timed_wait(Glib::IOCondition, gint64) (struct Socket * const this, IOCondition condition, gint64 timeout)
{
  struct GSocket * D.101951;
  struct GError * gerror.126;
  struct GError * gerror;

  try
    {
      gerror = 0B;
      D.101951 = Gio::Socket::gobj (this);
      g_socket_condition_timed_wait (D.101951, condition, timeout, 0B, &gerror);
      gerror.126 = gerror;
      if (gerror.126 != 0B) goto <D.101953>; else goto <D.101954>;
      <D.101953>:
      gerror.126 = gerror;
      Glib::Error::throw_exception (gerror.126);
      <D.101954>:
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Socket::set_listen_backlog(int) (struct Socket * const this, int backlog)
{
  struct GSocket * D.101956;

  D.101956 = Gio::Socket::gobj (this);
  g_socket_set_listen_backlog (D.101956, backlog);
}


int Gio::Socket::get_listen_backlog() const (const struct Socket * const this)
{
  int D.101957;
  const struct GSocket * D.101958;

  D.101958 = Gio::Socket::gobj (this);
  D.101957 = g_socket_get_listen_backlog (D.101958);
  return D.101957;
}


void Gio::Socket::set_blocking(bool) (struct Socket * const this, bool blocking)
{
  int D.101961;
  struct GSocket * D.101962;

  D.101961 = (int) blocking;
  D.101962 = Gio::Socket::gobj (this);
  g_socket_set_blocking (D.101962, D.101961);
}


bool Gio::Socket::get_blocking() const (const struct Socket * const this)
{
  bool D.101963;
  const struct GSocket * D.101964;
  int D.101965;

  D.101964 = Gio::Socket::gobj (this);
  D.101965 = g_socket_get_blocking (D.101964);
  D.101963 = D.101965 != 0;
  return D.101963;
}


void Gio::Socket::set_keepalive(bool) (struct Socket * const this, bool keepalive)
{
  int D.101968;
  struct GSocket * D.101969;

  D.101968 = (int) keepalive;
  D.101969 = Gio::Socket::gobj (this);
  g_socket_set_keepalive (D.101969, D.101968);
}


bool Gio::Socket::get_keepalive() const (const struct Socket * const this)
{
  bool D.101970;
  const struct GSocket * D.101971;
  int D.101972;

  D.101971 = Gio::Socket::gobj (this);
  D.101972 = g_socket_get_keepalive (D.101971);
  D.101970 = D.101972 != 0;
  return D.101970;
}


Gio::SocketFamily Gio::Socket::get_family() const (const struct Socket * const this)
{
  SocketFamily D.101975;
  const struct GSocket * D.101976;

  D.101976 = Gio::Socket::gobj (this);
  D.101975 = g_socket_get_family (D.101976);
  return D.101975;
}


int Gio::Socket::get_fd() const (const struct Socket * const this)
{
  int D.101979;
  const struct GSocket * D.101980;

  D.101980 = Gio::Socket::gobj (this);
  D.101979 = g_socket_get_fd (D.101980);
  return D.101979;
}


Glib::RefPtr<Gio::SocketAddress> Gio::Socket::get_local_address() const (const struct Socket * const this)
{
  const struct GSocket * D.101984;
  struct GSocketAddress * D.101985;
  struct GError * gerror.127;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101984 = Gio::Socket::gobj (this);
      D.101985 = g_socket_get_local_address (D.101984, &gerror);
      *<retval> = Glib::wrap (D.101985, 0); [return slot optimization]
      try
        {
          gerror.127 = gerror;
          if (gerror.127 != 0B) goto <D.101987>; else goto <D.101988>;
          <D.101987>:
          gerror.127 = gerror;
          Glib::Error::throw_exception (gerror.127);
          <D.101988>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketAddress>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::SocketAddress> Gio::Socket::get_remote_address() const (const struct Socket * const this)
{
  const struct GSocket * D.101995;
  struct GSocketAddress * D.101996;
  struct GError * gerror.128;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101995 = Gio::Socket::gobj (this);
      D.101996 = g_socket_get_remote_address (D.101995, &gerror);
      *<retval> = Glib::wrap (D.101996, 0); [return slot optimization]
      try
        {
          gerror.128 = gerror;
          if (gerror.128 != 0B) goto <D.101998>; else goto <D.101999>;
          <D.101998>:
          gerror.128 = gerror;
          Glib::Error::throw_exception (gerror.128);
          <D.101999>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::SocketAddress>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::SocketProtocol Gio::Socket::get_protocol() const (const struct Socket * const this)
{
  SocketProtocol D.102005;
  const struct GSocket * D.102006;

  D.102006 = Gio::Socket::gobj (this);
  D.102005 = g_socket_get_protocol (D.102006);
  return D.102005;
}


Gio::SocketType Gio::Socket::get_socket_type() const (const struct Socket * const this)
{
  SocketType D.102009;
  const struct GSocket * D.102010;

  D.102010 = Gio::Socket::gobj (this);
  D.102009 = g_socket_get_socket_type (D.102010);
  return D.102009;
}


bool Gio::Socket::speaks_ipv4() const (const struct Socket * const this)
{
  bool D.102013;
  const struct GSocket * D.102014;
  int D.102015;

  D.102014 = Gio::Socket::gobj (this);
  D.102015 = g_socket_speaks_ipv4 (D.102014);
  D.102013 = D.102015 != 0;
  return D.102013;
}


Glib::RefPtr<Gio::Credentials> Gio::Socket::get_credentials() (struct Socket * const this)
{
  struct GSocket * D.102019;
  struct GCredentials * D.102020;
  struct GError * gerror.129;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.102019 = Gio::Socket::gobj (this);
      D.102020 = g_socket_get_credentials (D.102019, &gerror);
      *<retval> = Glib::wrap (D.102020, 0); [return slot optimization]
      try
        {
          gerror.129 = gerror;
          if (gerror.129 != 0B) goto <D.102022>; else goto <D.102023>;
          <D.102022>:
          gerror.129 = gerror;
          Glib::Error::throw_exception (gerror.129);
          <D.102023>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::Credentials>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Credentials] (struct RefPtr * const this)
{
  struct Credentials * D.102029;
  int (*__vtbl_ptr_type) () * D.102032;
  int (*__vtbl_ptr_type) () * D.102033;
  long int D.102034;
  sizetype D.102035;
  struct ObjectBase * D.102036;
  int (*__vtbl_ptr_type) () * D.102037;
  int (*__vtbl_ptr_type) () * D.102038;
  int (*__vtbl_ptr_type) () D.102039;

  {
    try
      {
        D.102029 = this->pCppObject_;
        if (D.102029 != 0B) goto <D.102030>; else goto <D.102031>;
        <D.102030>:
        D.102029 = this->pCppObject_;
        D.102029 = this->pCppObject_;
        D.102032 = D.102029->D.86307._vptr.Object;
        D.102033 = D.102032 + 18446744073709551592;
        D.102034 = MEM[(long int *)D.102033];
        D.102035 = (sizetype) D.102034;
        D.102036 = D.102029 + D.102035;
        D.102029 = this->pCppObject_;
        D.102029 = this->pCppObject_;
        D.102032 = D.102029->D.86307._vptr.Object;
        D.102033 = D.102032 + 18446744073709551592;
        D.102034 = MEM[(long int *)D.102033];
        D.102035 = (sizetype) D.102034;
        D.102036 = D.102029 + D.102035;
        D.102037 = D.102036->_vptr.ObjectBase;
        D.102038 = D.102037 + 24;
        D.102039 = *D.102038;
        D.102029 = this->pCppObject_;
        D.102029 = this->pCppObject_;
        D.102032 = D.102029->D.86307._vptr.Object;
        D.102033 = D.102032 + 18446744073709551592;
        D.102034 = MEM[(long int *)D.102033];
        D.102035 = (sizetype) D.102034;
        D.102036 = D.102029 + D.102035;
        OBJ_TYPE_REF(D.102039;(const struct ObjectBase)D.102036->3) (D.102036);
        goto <D.102040>;
        <D.102031>:
        <D.102040>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100514>:
}


Glib::RefPtr<const Gio::Credentials> Gio::Socket::get_credentials() const (const struct Socket * const this)
{
  struct RefPtr D.99449;
  const struct GSocket * D.102043;
  struct GCredentials * D.102044;
  struct GError * gerror.130;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.102043 = Gio::Socket::gobj (this);
      D.102044 = g_socket_get_credentials (D.102043, &gerror);
      D.99449 = Glib::wrap (D.102044, 0); [return slot optimization]
      try
        {
          Glib::RefPtr<const Gio::Credentials>::RefPtr<Gio::Credentials> (<retval>, &D.99449);
        }
      finally
        {
          try
            {
              Glib::RefPtr<Gio::Credentials>::~RefPtr (&D.99449);
            }
          catch
            {
              Glib::RefPtr<const Gio::Credentials>::~RefPtr (<retval>);
            }
          D.99449 = {CLOBBER};
        }
      try
        {
          gerror.130 = gerror;
          if (gerror.130 != 0B) goto <D.102046>; else goto <D.102047>;
          <D.102046>:
          gerror.130 = gerror;
          Glib::Error::throw_exception (gerror.130);
          <D.102047>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<const Gio::Credentials>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Credentials; T_CppObject = const Gio::Credentials] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Credentials * D.102055;
  const struct Credentials * D.102056;
  int (*__vtbl_ptr_type) () * D.102059;
  int (*__vtbl_ptr_type) () * D.102060;
  long int D.102061;
  sizetype D.102062;
  const struct ObjectBase * D.102063;
  int (*__vtbl_ptr_type) () * D.102064;
  int (*__vtbl_ptr_type) () * D.102065;
  int (*__vtbl_ptr_type) () D.102066;

  D.102055 = Glib::RefPtr<Gio::Credentials>::operator-> (src);
  this->pCppObject_ = D.102055;
  D.102056 = this->pCppObject_;
  if (D.102056 != 0B) goto <D.102057>; else goto <D.102058>;
  <D.102057>:
  D.102056 = this->pCppObject_;
  D.102056 = this->pCppObject_;
  D.102059 = D.102056->D.86307._vptr.Object;
  D.102060 = D.102059 + 18446744073709551592;
  D.102061 = MEM[(long int *)D.102060];
  D.102062 = (sizetype) D.102061;
  D.102063 = D.102056 + D.102062;
  D.102056 = this->pCppObject_;
  D.102056 = this->pCppObject_;
  D.102059 = D.102056->D.86307._vptr.Object;
  D.102060 = D.102059 + 18446744073709551592;
  D.102061 = MEM[(long int *)D.102060];
  D.102062 = (sizetype) D.102061;
  D.102063 = D.102056 + D.102062;
  D.102064 = D.102063->_vptr.ObjectBase;
  D.102065 = D.102064 + 16;
  D.102066 = *D.102065;
  D.102056 = this->pCppObject_;
  D.102056 = this->pCppObject_;
  D.102059 = D.102056->D.86307._vptr.Object;
  D.102060 = D.102059 + 18446744073709551592;
  D.102061 = MEM[(long int *)D.102060];
  D.102062 = (sizetype) D.102061;
  D.102063 = D.102056 + D.102062;
  OBJ_TYPE_REF(D.102066;(const struct ObjectBase)D.102063->2) (D.102063);
  goto <D.102067>;
  <D.102058>:
  <D.102067>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Gio::Credentials] (struct RefPtr * const this)
{
  const struct Credentials * D.102070;
  int (*__vtbl_ptr_type) () * D.102073;
  int (*__vtbl_ptr_type) () * D.102074;
  long int D.102075;
  sizetype D.102076;
  const struct ObjectBase * D.102077;
  int (*__vtbl_ptr_type) () * D.102078;
  int (*__vtbl_ptr_type) () * D.102079;
  int (*__vtbl_ptr_type) () D.102080;

  {
    try
      {
        D.102070 = this->pCppObject_;
        if (D.102070 != 0B) goto <D.102071>; else goto <D.102072>;
        <D.102071>:
        D.102070 = this->pCppObject_;
        D.102070 = this->pCppObject_;
        D.102073 = D.102070->D.86307._vptr.Object;
        D.102074 = D.102073 + 18446744073709551592;
        D.102075 = MEM[(long int *)D.102074];
        D.102076 = (sizetype) D.102075;
        D.102077 = D.102070 + D.102076;
        D.102070 = this->pCppObject_;
        D.102070 = this->pCppObject_;
        D.102073 = D.102070->D.86307._vptr.Object;
        D.102074 = D.102073 + 18446744073709551592;
        D.102075 = MEM[(long int *)D.102074];
        D.102076 = (sizetype) D.102075;
        D.102077 = D.102070 + D.102076;
        D.102078 = D.102077->_vptr.ObjectBase;
        D.102079 = D.102078 + 24;
        D.102080 = *D.102079;
        D.102070 = this->pCppObject_;
        D.102070 = this->pCppObject_;
        D.102073 = D.102070->D.86307._vptr.Object;
        D.102074 = D.102073 + 18446744073709551592;
        D.102075 = MEM[(long int *)D.102074];
        D.102076 = (sizetype) D.102075;
        D.102077 = D.102070 + D.102076;
        OBJ_TYPE_REF(D.102080;(const struct ObjectBase)D.102077->3) (D.102077);
        goto <D.102081>;
        <D.102072>:
        <D.102081>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100534>:
}


guint Gio::Socket::get_timeout() const (const struct Socket * const this)
{
  guint D.102083;
  const struct GSocket * D.102084;

  D.102084 = Gio::Socket::gobj (this);
  D.102083 = g_socket_get_timeout (D.102084);
  return D.102083;
}


void Gio::Socket::set_timeout(guint) (struct Socket * const this, guint timeout)
{
  struct GSocket * D.102087;

  D.102087 = Gio::Socket::gobj (this);
  g_socket_set_timeout (D.102087, timeout);
}


bool Gio::Socket::get_option(int, int, int&) const (const struct Socket * const this, int level, int optname, int & value)
{
  const struct GSocket * D.102088;
  int D.102089;
  struct GError * gerror.131;
  bool D.102093;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102088 = Gio::Socket::gobj (this);
      D.102089 = g_socket_get_option (D.102088, level, optname, value, &gerror);
      retvalue = D.102089 != 0;
      gerror.131 = gerror;
      if (gerror.131 != 0B) goto <D.102091>; else goto <D.102092>;
      <D.102091>:
      gerror.131 = gerror;
      Glib::Error::throw_exception (gerror.131);
      <D.102092>:
      D.102093 = retvalue;
      return D.102093;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::Socket::set_option(int, int, int) (struct Socket * const this, int level, int optname, int value)
{
  struct GSocket * D.102098;
  int D.102099;
  struct GError * gerror.132;
  bool D.102103;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102098 = Gio::Socket::gobj (this);
      D.102099 = g_socket_set_option (D.102098, level, optname, value, &gerror);
      retvalue = D.102099 != 0;
      gerror.132 = gerror;
      if (gerror.132 != 0B) goto <D.102101>; else goto <D.102102>;
      <D.102101>:
      gerror.132 = gerror;
      Glib::Error::throw_exception (gerror.132);
      <D.102102>:
      D.102103 = retvalue;
      return D.102103;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


guint Gio::Socket::get_ttl() const (const struct Socket * const this)
{
  guint D.102108;
  const struct GSocket * D.102109;

  D.102109 = Gio::Socket::gobj (this);
  D.102108 = g_socket_get_ttl (D.102109);
  return D.102108;
}


void Gio::Socket::set_ttl(guint) (struct Socket * const this, guint ttl)
{
  struct GSocket * D.102112;

  D.102112 = Gio::Socket::gobj (this);
  g_socket_set_ttl (D.102112, ttl);
}


bool Gio::Socket::get_broadcast() const (const struct Socket * const this)
{
  bool D.102113;
  const struct GSocket * D.102114;
  int D.102115;

  D.102114 = Gio::Socket::gobj (this);
  D.102115 = g_socket_get_broadcast (D.102114);
  D.102113 = D.102115 != 0;
  return D.102113;
}


void Gio::Socket::set_broadcast(bool) (struct Socket * const this, bool broadcast)
{
  int D.102118;
  struct GSocket * D.102119;

  D.102118 = (int) broadcast;
  D.102119 = Gio::Socket::gobj (this);
  g_socket_set_broadcast (D.102119, D.102118);
}


bool Gio::Socket::get_multicast_loopback() const (const struct Socket * const this)
{
  bool D.102120;
  const struct GSocket * D.102121;
  int D.102122;

  D.102121 = Gio::Socket::gobj (this);
  D.102122 = g_socket_get_multicast_loopback (D.102121);
  D.102120 = D.102122 != 0;
  return D.102120;
}


void Gio::Socket::set_multicast_loopback(bool) (struct Socket * const this, bool loopback)
{
  int D.102125;
  struct GSocket * D.102126;

  D.102125 = (int) loopback;
  D.102126 = Gio::Socket::gobj (this);
  g_socket_set_multicast_loopback (D.102126, D.102125);
}


guint Gio::Socket::get_multicast_ttl() const (const struct Socket * const this)
{
  guint D.102127;
  const struct GSocket * D.102128;

  D.102128 = Gio::Socket::gobj (this);
  D.102127 = g_socket_get_multicast_ttl (D.102128);
  return D.102127;
}


void Gio::Socket::set_multicast_ttl(guint) (struct Socket * const this, guint ttl)
{
  struct GSocket * D.102131;

  D.102131 = Gio::Socket::gobj (this);
  g_socket_set_multicast_ttl (D.102131, ttl);
}


bool Gio::Socket::join_multicast_group(const Glib::RefPtr<Gio::InetAddress>&, bool, const string&) (struct Socket * const this, const struct RefPtr & group, bool source_specific, const struct string & iface)
{
  const char * iftmp.133;
  bool D.102133;
  int D.102137;
  struct BaseObjectType * D.102138;
  struct GSocket * D.102139;
  int D.102140;
  struct GError * gerror.134;
  bool D.102144;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102133 = std::basic_string<char>::empty (iface);
      if (D.102133 != 0) goto <D.102134>; else goto <D.102135>;
      <D.102134>:
      iftmp.133 = 0B;
      goto <D.102136>;
      <D.102135>:
      iftmp.133 = std::basic_string<char>::c_str (iface);
      <D.102136>:
      D.102137 = (int) source_specific;
      D.102138 = Glib::unwrap<Gio::InetAddress> (group);
      D.102139 = Gio::Socket::gobj (this);
      D.102140 = g_socket_join_multicast_group (D.102139, D.102138, D.102137, iftmp.133, &gerror);
      retvalue = D.102140 != 0;
      gerror.134 = gerror;
      if (gerror.134 != 0B) goto <D.102142>; else goto <D.102143>;
      <D.102142>:
      gerror.134 = gerror;
      Glib::Error::throw_exception (gerror.134);
      <D.102143>:
      D.102144 = retvalue;
      return D.102144;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool std::basic_string<_CharT, _Traits, _Alloc>::empty() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  bool D.102152;
  long unsigned int D.102153;

  D.102153 = std::basic_string<char>::size (this);
  D.102152 = D.102153 == 0;
  return D.102152;
}


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.102156;
  struct _Rep * D.102157;

  D.102157 = std::basic_string<char>::_M_rep (this);
  D.102156 = D.102157->D.18966._M_length;
  return D.102156;
}


std::basic_string<_CharT, _Traits, _Alloc>::_Rep* std::basic_string<_CharT, _Traits, _Alloc>::_M_rep() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Rep * D.102160;
  char * D.102161;

  D.102161 = std::basic_string<char>::_M_data (this);
  D.102160 = D.102161 + 18446744073709551592;
  return D.102160;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_M_data() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  char * D.102164;

  D.102164 = this->_M_dataplus._M_p;
  return D.102164;
}


const _CharT* std::basic_string<_CharT, _Traits, _Alloc>::c_str() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  const char * D.102166;

  D.102166 = std::basic_string<char>::_M_data (this);
  return D.102166;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::InetAddress; typename T::BaseObjectType = _GInetAddress] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.102169;
  struct BaseObjectType * iftmp.135;
  bool D.102171;
  struct InetAddress * D.102174;

  D.102171 = Glib::RefPtr<Gio::InetAddress>::operator bool (ptr);
  if (D.102171 != 0) goto <D.102172>; else goto <D.102173>;
  <D.102172>:
  D.102174 = Glib::RefPtr<Gio::InetAddress>::operator-> (ptr);
  iftmp.135 = Gio::InetAddress::gobj (D.102174);
  goto <D.102175>;
  <D.102173>:
  iftmp.135 = 0B;
  <D.102175>:
  D.102169 = iftmp.135;
  return D.102169;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::InetAddress] (const struct RefPtr * const this)
{
  bool D.102177;
  struct InetAddress * D.102178;

  D.102178 = this->pCppObject_;
  D.102177 = D.102178 != 0B;
  return D.102177;
}


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

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


GInetAddress* Gio::InetAddress::gobj() (struct InetAddress * const this)
{
  struct GInetAddress * D.102182;
  int (*__vtbl_ptr_type) () * D.102183;
  int (*__vtbl_ptr_type) () * D.102184;
  long int D.102185;
  sizetype D.102186;
  struct ObjectBase * D.102187;

  D.102183 = this->D.97564._vptr.Object;
  D.102184 = D.102183 + 18446744073709551592;
  D.102185 = MEM[(long int *)D.102184];
  D.102186 = (sizetype) D.102185;
  D.102187 = this + D.102186;
  D.102182 = D.102187->gobject_;
  return D.102182;
}


bool Gio::Socket::join_multicast_group(const Glib::RefPtr<Gio::InetAddress>&, bool) (struct Socket * const this, const struct RefPtr & group, bool source_specific)
{
  int D.102189;
  struct BaseObjectType * D.102190;
  struct GSocket * D.102191;
  int D.102192;
  struct GError * gerror.136;
  bool D.102196;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102189 = (int) source_specific;
      D.102190 = Glib::unwrap<Gio::InetAddress> (group);
      D.102191 = Gio::Socket::gobj (this);
      D.102192 = g_socket_join_multicast_group (D.102191, D.102190, D.102189, 0B, &gerror);
      retvalue = D.102192 != 0;
      gerror.136 = gerror;
      if (gerror.136 != 0B) goto <D.102194>; else goto <D.102195>;
      <D.102194>:
      gerror.136 = gerror;
      Glib::Error::throw_exception (gerror.136);
      <D.102195>:
      D.102196 = retvalue;
      return D.102196;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::Socket::leave_multicast_group(const Glib::RefPtr<Gio::InetAddress>&, bool, const string&) (struct Socket * const this, const struct RefPtr & group, bool source_specific, const struct string & iface)
{
  const char * iftmp.137;
  bool D.102203;
  int D.102207;
  struct BaseObjectType * D.102208;
  struct GSocket * D.102209;
  int D.102210;
  struct GError * gerror.138;
  bool D.102214;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102203 = std::basic_string<char>::empty (iface);
      if (D.102203 != 0) goto <D.102204>; else goto <D.102205>;
      <D.102204>:
      iftmp.137 = 0B;
      goto <D.102206>;
      <D.102205>:
      iftmp.137 = std::basic_string<char>::c_str (iface);
      <D.102206>:
      D.102207 = (int) source_specific;
      D.102208 = Glib::unwrap<Gio::InetAddress> (group);
      D.102209 = Gio::Socket::gobj (this);
      D.102210 = g_socket_leave_multicast_group (D.102209, D.102208, D.102207, iftmp.137, &gerror);
      retvalue = D.102210 != 0;
      gerror.138 = gerror;
      if (gerror.138 != 0B) goto <D.102212>; else goto <D.102213>;
      <D.102212>:
      gerror.138 = gerror;
      Glib::Error::throw_exception (gerror.138);
      <D.102213>:
      D.102214 = retvalue;
      return D.102214;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::Socket::leave_multicast_group(const Glib::RefPtr<Gio::InetAddress>&, bool) (struct Socket * const this, const struct RefPtr & group, bool source_specific)
{
  int D.102222;
  struct BaseObjectType * D.102223;
  struct GSocket * D.102224;
  int D.102225;
  struct GError * gerror.139;
  bool D.102229;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.102222 = (int) source_specific;
      D.102223 = Glib::unwrap<Gio::InetAddress> (group);
      D.102224 = Gio::Socket::gobj (this);
      D.102225 = g_socket_leave_multicast_group (D.102224, D.102223, D.102222, 0B, &gerror);
      retvalue = D.102225 != 0;
      gerror.139 = gerror;
      if (gerror.139 != 0B) goto <D.102227>; else goto <D.102228>;
      <D.102227>:
      gerror.139 = gerror;
      Glib::Error::throw_exception (gerror.139);
      <D.102228>:
      D.102229 = retvalue;
      return D.102229;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::PropertyProxy<bool> Gio::Socket::property_blocking() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102236;
  int (*__vtbl_ptr_type) () * D.102237;
  long int D.102238;
  sizetype D.102239;
  struct ObjectBase * D.102240;

  D.102236 = this->D.98048._vptr.Object;
  D.102237 = D.102236 + 18446744073709551592;
  D.102238 = MEM[(long int *)D.102237];
  D.102239 = (sizetype) D.102238;
  D.102240 = this + D.102239;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.102240, "blocking");
  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.102242;

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


Glib::PropertyProxy_ReadOnly<bool> Gio::Socket::property_blocking() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102244;
  int (*__vtbl_ptr_type) () * D.102245;
  long int D.102246;
  sizetype D.102247;
  const struct ObjectBase * D.102248;

  D.102244 = this->D.98048._vptr.Object;
  D.102245 = D.102244 + 18446744073709551592;
  D.102246 = MEM[(long int *)D.102245];
  D.102247 = (sizetype) D.102246;
  D.102248 = this + D.102247;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102248, "blocking");
  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.102250;

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


Glib::PropertyProxy_ReadOnly<Gio::SocketFamily> Gio::Socket::property_family() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102252;
  int (*__vtbl_ptr_type) () * D.102253;
  long int D.102254;
  sizetype D.102255;
  const struct ObjectBase * D.102256;

  D.102252 = this->D.98048._vptr.Object;
  D.102253 = D.102252 + 18446744073709551592;
  D.102254 = MEM[(long int *)D.102253];
  D.102255 = (sizetype) D.102254;
  D.102256 = this + D.102255;
  Glib::PropertyProxy_ReadOnly<Gio::SocketFamily>::PropertyProxy_ReadOnly (<retval>, D.102256, "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.102258;

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


Glib::PropertyProxy_ReadOnly<int> Gio::Socket::property_fd() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102260;
  int (*__vtbl_ptr_type) () * D.102261;
  long int D.102262;
  sizetype D.102263;
  const struct ObjectBase * D.102264;

  D.102260 = this->D.98048._vptr.Object;
  D.102261 = D.102260 + 18446744073709551592;
  D.102262 = MEM[(long int *)D.102261];
  D.102263 = (sizetype) D.102262;
  D.102264 = this + D.102263;
  Glib::PropertyProxy_ReadOnly<int>::PropertyProxy_ReadOnly (<retval>, D.102264, "fd");
  return <retval>;
}


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

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


Glib::PropertyProxy<bool> Gio::Socket::property_keepalive() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102268;
  int (*__vtbl_ptr_type) () * D.102269;
  long int D.102270;
  sizetype D.102271;
  struct ObjectBase * D.102272;

  D.102268 = this->D.98048._vptr.Object;
  D.102269 = D.102268 + 18446744073709551592;
  D.102270 = MEM[(long int *)D.102269];
  D.102271 = (sizetype) D.102270;
  D.102272 = this + D.102271;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.102272, "keepalive");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Socket::property_keepalive() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102275;
  int (*__vtbl_ptr_type) () * D.102276;
  long int D.102277;
  sizetype D.102278;
  const struct ObjectBase * D.102279;

  D.102275 = this->D.98048._vptr.Object;
  D.102276 = D.102275 + 18446744073709551592;
  D.102277 = MEM[(long int *)D.102276];
  D.102278 = (sizetype) D.102277;
  D.102279 = this + D.102278;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102279, "keepalive");
  return <retval>;
}


Glib::PropertyProxy<int> Gio::Socket::property_listen_backlog() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102282;
  int (*__vtbl_ptr_type) () * D.102283;
  long int D.102284;
  sizetype D.102285;
  struct ObjectBase * D.102286;

  D.102282 = this->D.98048._vptr.Object;
  D.102283 = D.102282 + 18446744073709551592;
  D.102284 = MEM[(long int *)D.102283];
  D.102285 = (sizetype) D.102284;
  D.102286 = this + D.102285;
  Glib::PropertyProxy<int>::PropertyProxy (<retval>, D.102286, "listen-backlog");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<int> Gio::Socket::property_listen_backlog() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102290;
  int (*__vtbl_ptr_type) () * D.102291;
  long int D.102292;
  sizetype D.102293;
  const struct ObjectBase * D.102294;

  D.102290 = this->D.98048._vptr.Object;
  D.102291 = D.102290 + 18446744073709551592;
  D.102292 = MEM[(long int *)D.102291];
  D.102293 = (sizetype) D.102292;
  D.102294 = this + D.102293;
  Glib::PropertyProxy_ReadOnly<int>::PropertyProxy_ReadOnly (<retval>, D.102294, "listen-backlog");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> > Gio::Socket::property_local_address() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102297;
  int (*__vtbl_ptr_type) () * D.102298;
  long int D.102299;
  sizetype D.102300;
  const struct ObjectBase * D.102301;

  D.102297 = this->D.98048._vptr.Object;
  D.102298 = D.102297 + 18446744073709551592;
  D.102299 = MEM[(long int *)D.102298];
  D.102300 = (sizetype) D.102299;
  D.102301 = this + D.102300;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> >::PropertyProxy_ReadOnly (<retval>, D.102301, "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.102303;

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


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> > Gio::Socket::property_remote_address() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102305;
  int (*__vtbl_ptr_type) () * D.102306;
  long int D.102307;
  sizetype D.102308;
  const struct ObjectBase * D.102309;

  D.102305 = this->D.98048._vptr.Object;
  D.102306 = D.102305 + 18446744073709551592;
  D.102307 = MEM[(long int *)D.102306];
  D.102308 = (sizetype) D.102307;
  D.102309 = this + D.102308;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketAddress> >::PropertyProxy_ReadOnly (<retval>, D.102309, "remote-address");
  return <retval>;
}


Glib::PropertyProxy<unsigned int> Gio::Socket::property_timeout() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102312;
  int (*__vtbl_ptr_type) () * D.102313;
  long int D.102314;
  sizetype D.102315;
  struct ObjectBase * D.102316;

  D.102312 = this->D.98048._vptr.Object;
  D.102313 = D.102312 + 18446744073709551592;
  D.102314 = MEM[(long int *)D.102313];
  D.102315 = (sizetype) D.102314;
  D.102316 = this + D.102315;
  Glib::PropertyProxy<unsigned int>::PropertyProxy (<retval>, D.102316, "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.102318;

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


Glib::PropertyProxy_ReadOnly<unsigned int> Gio::Socket::property_timeout() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102320;
  int (*__vtbl_ptr_type) () * D.102321;
  long int D.102322;
  sizetype D.102323;
  const struct ObjectBase * D.102324;

  D.102320 = this->D.98048._vptr.Object;
  D.102321 = D.102320 + 18446744073709551592;
  D.102322 = MEM[(long int *)D.102321];
  D.102323 = (sizetype) D.102322;
  D.102324 = this + D.102323;
  Glib::PropertyProxy_ReadOnly<unsigned int>::PropertyProxy_ReadOnly (<retval>, D.102324, "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.102326;

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


Glib::PropertyProxy_ReadOnly<Gio::SocketProtocol> Gio::Socket::property_protocol() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102328;
  int (*__vtbl_ptr_type) () * D.102329;
  long int D.102330;
  sizetype D.102331;
  const struct ObjectBase * D.102332;

  D.102328 = this->D.98048._vptr.Object;
  D.102329 = D.102328 + 18446744073709551592;
  D.102330 = MEM[(long int *)D.102329];
  D.102331 = (sizetype) D.102330;
  D.102332 = this + D.102331;
  Glib::PropertyProxy_ReadOnly<Gio::SocketProtocol>::PropertyProxy_ReadOnly (<retval>, D.102332, "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.102334;

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


Glib::PropertyProxy<bool> Gio::Socket::property_broadcast() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102336;
  int (*__vtbl_ptr_type) () * D.102337;
  long int D.102338;
  sizetype D.102339;
  struct ObjectBase * D.102340;

  D.102336 = this->D.98048._vptr.Object;
  D.102337 = D.102336 + 18446744073709551592;
  D.102338 = MEM[(long int *)D.102337];
  D.102339 = (sizetype) D.102338;
  D.102340 = this + D.102339;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.102340, "broadcast");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Socket::property_broadcast() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102343;
  int (*__vtbl_ptr_type) () * D.102344;
  long int D.102345;
  sizetype D.102346;
  const struct ObjectBase * D.102347;

  D.102343 = this->D.98048._vptr.Object;
  D.102344 = D.102343 + 18446744073709551592;
  D.102345 = MEM[(long int *)D.102344];
  D.102346 = (sizetype) D.102345;
  D.102347 = this + D.102346;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102347, "broadcast");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<Gio::SocketType> Gio::Socket::property_type() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102350;
  int (*__vtbl_ptr_type) () * D.102351;
  long int D.102352;
  sizetype D.102353;
  const struct ObjectBase * D.102354;

  D.102350 = this->D.98048._vptr.Object;
  D.102351 = D.102350 + 18446744073709551592;
  D.102352 = MEM[(long int *)D.102351];
  D.102353 = (sizetype) D.102352;
  D.102354 = this + D.102353;
  Glib::PropertyProxy_ReadOnly<Gio::SocketType>::PropertyProxy_ReadOnly (<retval>, D.102354, "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.102356;

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


Glib::PropertyProxy<unsigned int> Gio::Socket::property_ttl() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102358;
  int (*__vtbl_ptr_type) () * D.102359;
  long int D.102360;
  sizetype D.102361;
  struct ObjectBase * D.102362;

  D.102358 = this->D.98048._vptr.Object;
  D.102359 = D.102358 + 18446744073709551592;
  D.102360 = MEM[(long int *)D.102359];
  D.102361 = (sizetype) D.102360;
  D.102362 = this + D.102361;
  Glib::PropertyProxy<unsigned int>::PropertyProxy (<retval>, D.102362, "ttl");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<unsigned int> Gio::Socket::property_ttl() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102365;
  int (*__vtbl_ptr_type) () * D.102366;
  long int D.102367;
  sizetype D.102368;
  const struct ObjectBase * D.102369;

  D.102365 = this->D.98048._vptr.Object;
  D.102366 = D.102365 + 18446744073709551592;
  D.102367 = MEM[(long int *)D.102366];
  D.102368 = (sizetype) D.102367;
  D.102369 = this + D.102368;
  Glib::PropertyProxy_ReadOnly<unsigned int>::PropertyProxy_ReadOnly (<retval>, D.102369, "ttl");
  return <retval>;
}


Glib::PropertyProxy<bool> Gio::Socket::property_multicast_loopback() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102372;
  int (*__vtbl_ptr_type) () * D.102373;
  long int D.102374;
  sizetype D.102375;
  struct ObjectBase * D.102376;

  D.102372 = this->D.98048._vptr.Object;
  D.102373 = D.102372 + 18446744073709551592;
  D.102374 = MEM[(long int *)D.102373];
  D.102375 = (sizetype) D.102374;
  D.102376 = this + D.102375;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.102376, "multicast-loopback");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Socket::property_multicast_loopback() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102379;
  int (*__vtbl_ptr_type) () * D.102380;
  long int D.102381;
  sizetype D.102382;
  const struct ObjectBase * D.102383;

  D.102379 = this->D.98048._vptr.Object;
  D.102380 = D.102379 + 18446744073709551592;
  D.102381 = MEM[(long int *)D.102380];
  D.102382 = (sizetype) D.102381;
  D.102383 = this + D.102382;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102383, "multicast-loopback");
  return <retval>;
}


Glib::PropertyProxy<unsigned int> Gio::Socket::property_multicast_ttl() (struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102386;
  int (*__vtbl_ptr_type) () * D.102387;
  long int D.102388;
  sizetype D.102389;
  struct ObjectBase * D.102390;

  D.102386 = this->D.98048._vptr.Object;
  D.102387 = D.102386 + 18446744073709551592;
  D.102388 = MEM[(long int *)D.102387];
  D.102389 = (sizetype) D.102388;
  D.102390 = this + D.102389;
  Glib::PropertyProxy<unsigned int>::PropertyProxy (<retval>, D.102390, "multicast-ttl");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<unsigned int> Gio::Socket::property_multicast_ttl() const (const struct Socket * const this)
{
  int (*__vtbl_ptr_type) () * D.102393;
  int (*__vtbl_ptr_type) () * D.102394;
  long int D.102395;
  sizetype D.102396;
  const struct ObjectBase * D.102397;

  D.102393 = this->D.98048._vptr.Object;
  D.102394 = D.102393 + 18446744073709551592;
  D.102395 = MEM[(long int *)D.102394];
  D.102396 = (sizetype) D.102395;
  D.102397 = this + D.102396;
  Glib::PropertyProxy_ReadOnly<unsigned int>::PropertyProxy_ReadOnly (<retval>, D.102397, "multicast-ttl");
  return <retval>;
}