Gio::TlsClientConnection::TlsClientConnection(GTlsClientConnection*) (struct TlsClientConnection * const this, const void * * __vtt_parm, struct GTlsClientConnection * castitem)
{
  struct trackable * D.102998;
  const void * * iftmp.0;
  struct ObjectBase * D.103006;
  const void * * iftmp.1;
  struct Interface * D.103012;
  long unsigned int D.103013;
  struct GTypeInstance * D.103014;
  const void * * iftmp.2;
  struct TlsConnection * D.103019;
  int (*__vtbl_ptr_type) () * iftmp.3;
  sizetype iftmp.4;
  int (*__vtbl_ptr_type) () * D.103027;
  int (*__vtbl_ptr_type) () * D.103028;
  long int D.103029;
  struct ObjectBase * D.103031;
  int (*__vtbl_ptr_type) () * iftmp.5;
  int (*__vtbl_ptr_type) () * iftmp.6;
  const void * * iftmp.7;
  const void * * iftmp.8;
  const void * * iftmp.9;

  if (0 != 0) goto <D.102996>; else goto <D.102997>;
  <D.102996>:
  D.102998 = &this->D.97997;
  sigc::trackable::trackable (D.102998);
  goto <D.102999>;
  <D.102997>:
  <D.102999>:
  try
    {
      if (0 != 0) goto <D.103000>; else goto <D.103001>;
      <D.103000>:
      if (0 == 0) goto <D.103003>; else goto <D.103004>;
      <D.103003>:
      iftmp.0 = __vtt_parm + 88;
      goto <D.103005>;
      <D.103004>:
      iftmp.0 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103005>:
      D.103006 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103006, iftmp.0);
      goto <D.103007>;
      <D.103001>:
      <D.103007>:
      try
        {
          if (0 == 0) goto <D.103009>; else goto <D.103010>;
          <D.103009>:
          iftmp.1 = __vtt_parm + 8;
          goto <D.103011>;
          <D.103010>:
          iftmp.1 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103011>:
          D.103012 = &this->D.97992;
          Glib::Interface::Interface (D.103012, iftmp.1);
          try
            {
              D.103013 = g_tls_connection_get_type ();
              D.103014 = g_type_check_instance_cast (castitem, D.103013);
              if (0 == 0) goto <D.103016>; else goto <D.103017>;
              <D.103016>:
              iftmp.2 = __vtt_parm + 24;
              goto <D.103018>;
              <D.103017>:
              iftmp.2 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103018>:
              D.103019 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103019, iftmp.2, D.103014);
              try
                {
                  if (0 == 0) goto <D.103021>; else goto <D.103022>;
                  <D.103021>:
                  iftmp.3 = *__vtt_parm;
                  goto <D.103023>;
                  <D.103022>:
                  iftmp.3 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103023>:
                  this->D.97992._vptr.Interface = iftmp.3;
                  if (0 == 0) goto <D.103025>; else goto <D.103026>;
                  <D.103025>:
                  D.103027 = this->D.97992._vptr.Interface;
                  D.103028 = D.103027 + 18446744073709551592;
                  D.103029 = MEM[(long int *)D.103028];
                  iftmp.4 = (sizetype) D.103029;
                  goto <D.103030>;
                  <D.103026>:
                  iftmp.4 = 16;
                  <D.103030>:
                  D.103031 = this + iftmp.4;
                  if (0 == 0) goto <D.103033>; else goto <D.103034>;
                  <D.103033>:
                  iftmp.5 = MEM[(const void * *)__vtt_parm + 72B];
                  goto <D.103035>;
                  <D.103034>:
                  iftmp.5 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103035>:
                  D.103031->_vptr.ObjectBase = iftmp.5;
                  if (0 == 0) goto <D.103037>; else goto <D.103038>;
                  <D.103037>:
                  iftmp.6 = MEM[(const void * *)__vtt_parm + 80B];
                  goto <D.103039>;
                  <D.103038>:
                  iftmp.6 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103039>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.6;
                }
              catch
                {
                  if (0 == 0) goto <D.103041>; else goto <D.103042>;
                  <D.103041>:
                  iftmp.7 = __vtt_parm + 24;
                  goto <D.103043>;
                  <D.103042>:
                  iftmp.7 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103043>:
                  D.103019 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103019, iftmp.7);
                }
            }
          catch
            {
              if (0 == 0) goto <D.103045>; else goto <D.103046>;
              <D.103045>:
              iftmp.8 = __vtt_parm + 8;
              goto <D.103047>;
              <D.103046>:
              iftmp.8 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103047>:
              D.103012 = &this->D.97992;
              Glib::Interface::~Interface (D.103012, iftmp.8);
            }
        }
      catch
        {
          if (0 != 0) goto <D.103048>; else goto <D.103049>;
          <D.103048>:
          if (0 == 0) goto <D.103051>; else goto <D.103052>;
          <D.103051>:
          iftmp.9 = __vtt_parm + 88;
          goto <D.103053>;
          <D.103052>:
          iftmp.9 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103053>:
          D.103006 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103006, iftmp.9);
          goto <D.103054>;
          <D.103049>:
          <D.103054>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.103055>; else goto <D.103056>;
      <D.103055>:
      D.102998 = &this->D.97997;
      sigc::trackable::~trackable (D.102998);
      goto <D.103057>;
      <D.103056>:
      <D.103057>:
    }
}


Gio::TlsClientConnection::TlsClientConnection(GTlsClientConnection*) (struct TlsClientConnection * const this, struct GTlsClientConnection * castitem)
{
  struct trackable * D.103066;
  const void * * iftmp.10;
  struct ObjectBase * D.103074;
  const void * * iftmp.11;
  struct Interface * D.103080;
  long unsigned int D.103081;
  struct GTypeInstance * D.103082;
  const void * * iftmp.12;
  struct TlsConnection * D.103087;
  int (*__vtbl_ptr_type) () * iftmp.13;
  const void * * D.103091;
  sizetype iftmp.14;
  int (*__vtbl_ptr_type) () * D.103096;
  int (*__vtbl_ptr_type) () * D.103097;
  long int D.103098;
  struct ObjectBase * D.103100;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int (*__vtbl_ptr_type) () * iftmp.16;
  const void * * iftmp.17;
  const void * * iftmp.18;
  const void * * iftmp.19;

  if (1 != 0) goto <D.103064>; else goto <D.103065>;
  <D.103064>:
  D.103066 = &this->D.97997;
  sigc::trackable::trackable (D.103066);
  goto <D.103067>;
  <D.103065>:
  <D.103067>:
  try
    {
      if (1 != 0) goto <D.103068>; else goto <D.103069>;
      <D.103068>:
      if (1 == 0) goto <D.103071>; else goto <D.103072>;
      <D.103071>:
      iftmp.10 = 88B;
      goto <D.103073>;
      <D.103072>:
      iftmp.10 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103073>:
      D.103074 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103074, iftmp.10);
      goto <D.103075>;
      <D.103069>:
      <D.103075>:
      try
        {
          if (1 == 0) goto <D.103077>; else goto <D.103078>;
          <D.103077>:
          iftmp.11 = 8B;
          goto <D.103079>;
          <D.103078>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103079>:
          D.103080 = &this->D.97992;
          Glib::Interface::Interface (D.103080, iftmp.11);
          try
            {
              D.103081 = g_tls_connection_get_type ();
              D.103082 = g_type_check_instance_cast (castitem, D.103081);
              if (1 == 0) goto <D.103084>; else goto <D.103085>;
              <D.103084>:
              iftmp.12 = 24B;
              goto <D.103086>;
              <D.103085>:
              iftmp.12 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103086>:
              D.103087 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103087, iftmp.12, D.103082);
              try
                {
                  if (1 == 0) goto <D.103089>; else goto <D.103090>;
                  <D.103089>:
                  D.103091 = 0B;
                  iftmp.13 = *D.103091;
                  goto <D.103092>;
                  <D.103090>:
                  iftmp.13 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103092>:
                  this->D.97992._vptr.Interface = iftmp.13;
                  if (1 == 0) goto <D.103094>; else goto <D.103095>;
                  <D.103094>:
                  D.103096 = this->D.97992._vptr.Interface;
                  D.103097 = D.103096 + 18446744073709551592;
                  D.103098 = MEM[(long int *)D.103097];
                  iftmp.14 = (sizetype) D.103098;
                  goto <D.103099>;
                  <D.103095>:
                  iftmp.14 = 16;
                  <D.103099>:
                  D.103100 = this + iftmp.14;
                  if (1 == 0) goto <D.103102>; else goto <D.103103>;
                  <D.103102>:
                  iftmp.15 = MEM[(const void * *)0B + 72B];
                  goto <D.103104>;
                  <D.103103>:
                  iftmp.15 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103104>:
                  D.103100->_vptr.ObjectBase = iftmp.15;
                  if (1 == 0) goto <D.103106>; else goto <D.103107>;
                  <D.103106>:
                  iftmp.16 = MEM[(const void * *)0B + 80B];
                  goto <D.103108>;
                  <D.103107>:
                  iftmp.16 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103108>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.16;
                }
              catch
                {
                  if (1 == 0) goto <D.103110>; else goto <D.103111>;
                  <D.103110>:
                  iftmp.17 = 24B;
                  goto <D.103112>;
                  <D.103111>:
                  iftmp.17 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103112>:
                  D.103087 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103087, iftmp.17);
                }
            }
          catch
            {
              if (1 == 0) goto <D.103114>; else goto <D.103115>;
              <D.103114>:
              iftmp.18 = 8B;
              goto <D.103116>;
              <D.103115>:
              iftmp.18 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103116>:
              D.103080 = &this->D.97992;
              Glib::Interface::~Interface (D.103080, iftmp.18);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103117>; else goto <D.103118>;
          <D.103117>:
          if (1 == 0) goto <D.103120>; else goto <D.103121>;
          <D.103120>:
          iftmp.19 = 88B;
          goto <D.103122>;
          <D.103121>:
          iftmp.19 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103122>:
          D.103074 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103074, iftmp.19);
          goto <D.103123>;
          <D.103118>:
          <D.103123>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103124>; else goto <D.103125>;
      <D.103124>:
      D.103066 = &this->D.97997;
      sigc::trackable::~trackable (D.103066);
      goto <D.103126>;
      <D.103125>:
      <D.103126>:
    }
}


Glib::RefPtr<Gio::TlsClientConnection> Glib::wrap(GTlsClientConnection*, bool) (struct GTlsClientConnection * object, bool take_copy)
{
  int D.103133;
  struct TlsClientConnection * D.103134;

  D.103133 = (int) take_copy;
  D.103134 = Glib::wrap_auto_interface<Gio::TlsClientConnection> (object, D.103133);
  Glib::RefPtr<Gio::TlsClientConnection>::RefPtr (<retval>, D.103134);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::TlsClientConnection; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct TlsClientConnection * D.103139;
  long unsigned int D.103142;
  struct TlsClientConnection * iftmp.20;
  struct ObjectBase * pCppObject.21;
  const struct type_info * iftmp.22;
  int (*__vtbl_ptr_type) () * D.103156;
  const char * D.103158;
  void * result.23;
  bool D.103161;
  bool D.103162;
  int (*__vtbl_ptr_type) () * D.103165;
  int (*__vtbl_ptr_type) () * D.103166;
  long int D.103167;
  sizetype D.103168;
  struct ObjectBase * D.103169;
  int (*__vtbl_ptr_type) () * D.103170;
  int (*__vtbl_ptr_type) () * D.103171;
  int (*__vtbl_ptr_type) () D.103172;
  struct ObjectBase * pCppObject;
  struct TlsClientConnection * result;

  if (object == 0B) goto <D.103137>; else goto <D.103138>;
  <D.103137>:
  D.103139 = 0B;
  return D.103139;
  <D.103138>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.103140>; else goto <D.103141>;
  <D.103140>:
  D.103142 = Gio::TlsClientConnection::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.103142);
  goto <D.103143>;
  <D.103141>:
  <D.103143>:
  result = 0B;
  if (pCppObject != 0B) goto <D.103144>; else goto <D.103145>;
  <D.103144>:
  pCppObject.21 = pCppObject;
  if (pCppObject.21 == 0B) goto <D.103148>; else goto <D.103149>;
  <D.103148>:
  iftmp.20 = 0B;
  goto <D.103150>;
  <D.103149>:
  iftmp.20 = __dynamic_cast (pCppObject.21, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio19TlsClientConnectionE, -1);
  <D.103150>:
  result = iftmp.20;
  if (result == 0B) goto <D.103151>; else goto <D.103152>;
  <D.103151>:
  if (pCppObject != 0B) goto <D.103154>; else goto <D.103155>;
  <D.103154>:
  D.103156 = pCppObject->_vptr.ObjectBase;
  iftmp.22 = MEM[(int (*__vtbl_ptr_type) () *)D.103156 + -8B];
  goto <D.103157>;
  <D.103155>:
  __cxa_bad_typeid ();
  <D.103157>:
  D.103158 = std::type_info::name (iftmp.22);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.103158);
  goto <D.103159>;
  <D.103152>:
  <D.103159>:
  goto <D.103160>;
  <D.103145>:
  result.23 = operator new (56);
  try
    {
      Gio::TlsClientConnection::TlsClientConnection (result.23, object);
    }
  catch
    {
      operator delete (result.23);
    }
  result = result.23;
  <D.103160>:
  D.103161 = result != 0B;
  D.103162 = D.103161 & take_copy;
  if (D.103162 != 0) goto <D.103163>; else goto <D.103164>;
  <D.103163>:
  D.103165 = result->D.97992._vptr.Interface;
  D.103166 = D.103165 + 18446744073709551592;
  D.103167 = MEM[(long int *)D.103166];
  D.103168 = (sizetype) D.103167;
  D.103169 = result + D.103168;
  D.103165 = result->D.97992._vptr.Interface;
  D.103166 = D.103165 + 18446744073709551592;
  D.103167 = MEM[(long int *)D.103166];
  D.103168 = (sizetype) D.103167;
  D.103169 = result + D.103168;
  D.103170 = D.103169->_vptr.ObjectBase;
  D.103171 = D.103170 + 16;
  D.103172 = *D.103171;
  D.103165 = result->D.97992._vptr.Interface;
  D.103166 = D.103165 + 18446744073709551592;
  D.103167 = MEM[(long int *)D.103166];
  D.103168 = (sizetype) D.103167;
  D.103169 = result + D.103168;
  OBJ_TYPE_REF(D.103172;(const struct ObjectBase)D.103169->2) (D.103169);
  goto <D.103173>;
  <D.103164>:
  <D.103173>:
  D.103139 = result;
  return D.103139;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.103180;
  const char * iftmp.24;
  const char * D.103182;
  char D.103183;

  D.103182 = this->__name;
  D.103183 = *D.103182;
  if (D.103183 == 42) goto <D.103184>; else goto <D.103185>;
  <D.103184>:
  D.103182 = this->__name;
  iftmp.24 = D.103182 + 1;
  goto <D.103186>;
  <D.103185>:
  iftmp.24 = this->__name;
  <D.103186>:
  D.103180 = iftmp.24;
  return D.103180;
}


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


const Glib::Interface_Class& Gio::TlsClientConnection_Class::init() (struct TlsClientConnection_Class * const this)
{
  long unsigned int D.103188;
  long unsigned int D.103191;
  const struct Interface_Class & D.103193;

  D.103188 = this->D.98035.D.98021.gtype_;
  if (D.103188 == 0) goto <D.103189>; else goto <D.103190>;
  <D.103189>:
  this->D.98035.D.98021.class_init_func_ = iface_init_function;
  D.103191 = g_tls_client_connection_get_type ();
  this->D.98035.D.98021.gtype_ = D.103191;
  goto <D.103192>;
  <D.103190>:
  <D.103192>:
  D.103193 = &this->D.98035;
  return D.103193;
}


static void Gio::TlsClientConnection_Class::iface_init_function(void*, void*) (void * g_iface, void * D.98427)
{
  bool retval.25;
  int retval.26;
  long int D.103201;
  long int D.103202;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[78] = "static void Gio::TlsClientConnection_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.103198>; else goto <D.103199>;
        <D.103198>:
        _g_boolean_var_ = 1;
        goto <D.103200>;
        <D.103199>:
        _g_boolean_var_ = 0;
        <D.103200>:
        retval.26 = _g_boolean_var_;
      }
      D.103201 = (long int) retval.26;
      D.103202 = __builtin_expect (D.103201, 1);
      retval.25 = D.103202 != 0;
      if (retval.25 != 0) goto <D.103203>; else goto <D.103204>;
      <D.103203>:
      goto <D.103205>;
      <D.103204>:
      g_assertion_message_expr ("giomm", "tlsclientconnection.cc", 83, &__PRETTY_FUNCTION__, "klass != 0");
      <D.103205>:
    }
  }
}


static Glib::ObjectBase* Gio::TlsClientConnection_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.103206;
  struct ObjectBase * iftmp.27;
  void * D.98440;
  void * D.103208;
  int (*__vtbl_ptr_type) () * D.103211;
  int (*__vtbl_ptr_type) () * D.103212;
  long int D.103213;
  sizetype D.103214;

  D.98440 = operator new (56);
  try
    {
      Gio::TlsClientConnection::TlsClientConnection (D.98440, object);
    }
  catch
    {
      operator delete (D.98440);
    }
  D.103208 = D.98440;
  if (D.103208 != 0B) goto <D.103209>; else goto <D.103210>;
  <D.103209>:
  D.103211 = MEM[(struct TlsClientConnection *)D.103208].D.97992._vptr.Interface;
  D.103212 = D.103211 + 18446744073709551592;
  D.103213 = MEM[(long int *)D.103212];
  D.103214 = (sizetype) D.103213;
  iftmp.27 = D.103208 + D.103214;
  goto <D.103215>;
  <D.103210>:
  iftmp.27 = 0B;
  <D.103215>:
  D.103206 = iftmp.27;
  return D.103206;
}


Gio::TlsClientConnection::TlsClientConnection() (struct TlsClientConnection * const this, const void * * __vtt_parm)
{
  struct trackable * D.103221;
  const void * * iftmp.28;
  struct ObjectBase * D.103229;
  const struct Interface_Class & D.103231;
  const void * * iftmp.29;
  struct Interface * D.103236;
  const void * * iftmp.30;
  struct TlsConnection * D.103241;
  int (*__vtbl_ptr_type) () * iftmp.31;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.103249;
  int (*__vtbl_ptr_type) () * D.103250;
  long int D.103251;
  struct ObjectBase * D.103253;
  int (*__vtbl_ptr_type) () * iftmp.33;
  int (*__vtbl_ptr_type) () * iftmp.34;
  const void * * iftmp.35;
  const void * * iftmp.36;
  const void * * iftmp.37;

  if (0 != 0) goto <D.103219>; else goto <D.103220>;
  <D.103219>:
  D.103221 = &this->D.97997;
  sigc::trackable::trackable (D.103221);
  goto <D.103222>;
  <D.103220>:
  <D.103222>:
  try
    {
      if (0 != 0) goto <D.103223>; else goto <D.103224>;
      <D.103223>:
      if (0 == 0) goto <D.103226>; else goto <D.103227>;
      <D.103226>:
      iftmp.28 = __vtt_parm + 88;
      goto <D.103228>;
      <D.103227>:
      iftmp.28 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103228>:
      D.103229 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103229, iftmp.28);
      goto <D.103230>;
      <D.103224>:
      <D.103230>:
      try
        {
          D.103231 = Gio::TlsClientConnection_Class::init (&tlsclientconnection_class_);
          if (0 == 0) goto <D.103233>; else goto <D.103234>;
          <D.103233>:
          iftmp.29 = __vtt_parm + 8;
          goto <D.103235>;
          <D.103234>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103235>:
          D.103236 = &this->D.97992;
          Glib::Interface::Interface (D.103236, iftmp.29, D.103231);
          try
            {
              if (0 == 0) goto <D.103238>; else goto <D.103239>;
              <D.103238>:
              iftmp.30 = __vtt_parm + 24;
              goto <D.103240>;
              <D.103239>:
              iftmp.30 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103240>:
              D.103241 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103241, iftmp.30);
              try
                {
                  if (0 == 0) goto <D.103243>; else goto <D.103244>;
                  <D.103243>:
                  iftmp.31 = *__vtt_parm;
                  goto <D.103245>;
                  <D.103244>:
                  iftmp.31 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103245>:
                  this->D.97992._vptr.Interface = iftmp.31;
                  if (0 == 0) goto <D.103247>; else goto <D.103248>;
                  <D.103247>:
                  D.103249 = this->D.97992._vptr.Interface;
                  D.103250 = D.103249 + 18446744073709551592;
                  D.103251 = MEM[(long int *)D.103250];
                  iftmp.32 = (sizetype) D.103251;
                  goto <D.103252>;
                  <D.103248>:
                  iftmp.32 = 16;
                  <D.103252>:
                  D.103253 = this + iftmp.32;
                  if (0 == 0) goto <D.103255>; else goto <D.103256>;
                  <D.103255>:
                  iftmp.33 = MEM[(const void * *)__vtt_parm + 72B];
                  goto <D.103257>;
                  <D.103256>:
                  iftmp.33 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103257>:
                  D.103253->_vptr.ObjectBase = iftmp.33;
                  if (0 == 0) goto <D.103259>; else goto <D.103260>;
                  <D.103259>:
                  iftmp.34 = MEM[(const void * *)__vtt_parm + 80B];
                  goto <D.103261>;
                  <D.103260>:
                  iftmp.34 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103261>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.34;
                }
              catch
                {
                  if (0 == 0) goto <D.103263>; else goto <D.103264>;
                  <D.103263>:
                  iftmp.35 = __vtt_parm + 24;
                  goto <D.103265>;
                  <D.103264>:
                  iftmp.35 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103265>:
                  D.103241 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103241, iftmp.35);
                }
            }
          catch
            {
              if (0 == 0) goto <D.103267>; else goto <D.103268>;
              <D.103267>:
              iftmp.36 = __vtt_parm + 8;
              goto <D.103269>;
              <D.103268>:
              iftmp.36 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103269>:
              D.103236 = &this->D.97992;
              Glib::Interface::~Interface (D.103236, iftmp.36);
            }
        }
      catch
        {
          if (0 != 0) goto <D.103270>; else goto <D.103271>;
          <D.103270>:
          if (0 == 0) goto <D.103273>; else goto <D.103274>;
          <D.103273>:
          iftmp.37 = __vtt_parm + 88;
          goto <D.103275>;
          <D.103274>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103275>:
          D.103229 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103229, iftmp.37);
          goto <D.103276>;
          <D.103271>:
          <D.103276>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.103277>; else goto <D.103278>;
      <D.103277>:
      D.103221 = &this->D.97997;
      sigc::trackable::~trackable (D.103221);
      goto <D.103279>;
      <D.103278>:
      <D.103279>:
    }
}


Gio::TlsClientConnection::TlsClientConnection() (struct TlsClientConnection * const this)
{
  struct trackable * D.103286;
  const void * * iftmp.38;
  struct ObjectBase * D.103294;
  const struct Interface_Class & D.103296;
  const void * * iftmp.39;
  struct Interface * D.103301;
  const void * * iftmp.40;
  struct TlsConnection * D.103306;
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * D.103310;
  sizetype iftmp.42;
  int (*__vtbl_ptr_type) () * D.103315;
  int (*__vtbl_ptr_type) () * D.103316;
  long int D.103317;
  struct ObjectBase * D.103319;
  int (*__vtbl_ptr_type) () * iftmp.43;
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * iftmp.45;
  const void * * iftmp.46;
  const void * * iftmp.47;

  if (1 != 0) goto <D.103284>; else goto <D.103285>;
  <D.103284>:
  D.103286 = &this->D.97997;
  sigc::trackable::trackable (D.103286);
  goto <D.103287>;
  <D.103285>:
  <D.103287>:
  try
    {
      if (1 != 0) goto <D.103288>; else goto <D.103289>;
      <D.103288>:
      if (1 == 0) goto <D.103291>; else goto <D.103292>;
      <D.103291>:
      iftmp.38 = 88B;
      goto <D.103293>;
      <D.103292>:
      iftmp.38 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103293>:
      D.103294 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103294, iftmp.38);
      goto <D.103295>;
      <D.103289>:
      <D.103295>:
      try
        {
          D.103296 = Gio::TlsClientConnection_Class::init (&tlsclientconnection_class_);
          if (1 == 0) goto <D.103298>; else goto <D.103299>;
          <D.103298>:
          iftmp.39 = 8B;
          goto <D.103300>;
          <D.103299>:
          iftmp.39 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103300>:
          D.103301 = &this->D.97992;
          Glib::Interface::Interface (D.103301, iftmp.39, D.103296);
          try
            {
              if (1 == 0) goto <D.103303>; else goto <D.103304>;
              <D.103303>:
              iftmp.40 = 24B;
              goto <D.103305>;
              <D.103304>:
              iftmp.40 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103305>:
              D.103306 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103306, iftmp.40);
              try
                {
                  if (1 == 0) goto <D.103308>; else goto <D.103309>;
                  <D.103308>:
                  D.103310 = 0B;
                  iftmp.41 = *D.103310;
                  goto <D.103311>;
                  <D.103309>:
                  iftmp.41 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103311>:
                  this->D.97992._vptr.Interface = iftmp.41;
                  if (1 == 0) goto <D.103313>; else goto <D.103314>;
                  <D.103313>:
                  D.103315 = this->D.97992._vptr.Interface;
                  D.103316 = D.103315 + 18446744073709551592;
                  D.103317 = MEM[(long int *)D.103316];
                  iftmp.42 = (sizetype) D.103317;
                  goto <D.103318>;
                  <D.103314>:
                  iftmp.42 = 16;
                  <D.103318>:
                  D.103319 = this + iftmp.42;
                  if (1 == 0) goto <D.103321>; else goto <D.103322>;
                  <D.103321>:
                  iftmp.43 = MEM[(const void * *)0B + 72B];
                  goto <D.103323>;
                  <D.103322>:
                  iftmp.43 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103323>:
                  D.103319->_vptr.ObjectBase = iftmp.43;
                  if (1 == 0) goto <D.103325>; else goto <D.103326>;
                  <D.103325>:
                  iftmp.44 = MEM[(const void * *)0B + 80B];
                  goto <D.103327>;
                  <D.103326>:
                  iftmp.44 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103327>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.44;
                }
              catch
                {
                  if (1 == 0) goto <D.103329>; else goto <D.103330>;
                  <D.103329>:
                  iftmp.45 = 24B;
                  goto <D.103331>;
                  <D.103330>:
                  iftmp.45 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103331>:
                  D.103306 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103306, iftmp.45);
                }
            }
          catch
            {
              if (1 == 0) goto <D.103333>; else goto <D.103334>;
              <D.103333>:
              iftmp.46 = 8B;
              goto <D.103335>;
              <D.103334>:
              iftmp.46 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103335>:
              D.103301 = &this->D.97992;
              Glib::Interface::~Interface (D.103301, iftmp.46);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103336>; else goto <D.103337>;
          <D.103336>:
          if (1 == 0) goto <D.103339>; else goto <D.103340>;
          <D.103339>:
          iftmp.47 = 88B;
          goto <D.103341>;
          <D.103340>:
          iftmp.47 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103341>:
          D.103294 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103294, iftmp.47);
          goto <D.103342>;
          <D.103337>:
          <D.103342>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103343>; else goto <D.103344>;
      <D.103343>:
      D.103286 = &this->D.97997;
      sigc::trackable::~trackable (D.103286);
      goto <D.103345>;
      <D.103344>:
      <D.103345>:
    }
}


Gio::TlsClientConnection::TlsClientConnection(const Glib::Interface_Class&) (struct TlsClientConnection * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.103352;
  const void * * iftmp.48;
  struct ObjectBase * D.103360;
  const void * * iftmp.49;
  struct Interface * D.103366;
  const void * * iftmp.50;
  struct TlsConnection * D.103371;
  int (*__vtbl_ptr_type) () * iftmp.51;
  sizetype iftmp.52;
  int (*__vtbl_ptr_type) () * D.103379;
  int (*__vtbl_ptr_type) () * D.103380;
  long int D.103381;
  struct ObjectBase * D.103383;
  int (*__vtbl_ptr_type) () * iftmp.53;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;
  const void * * iftmp.57;

  if (0 != 0) goto <D.103350>; else goto <D.103351>;
  <D.103350>:
  D.103352 = &this->D.97997;
  sigc::trackable::trackable (D.103352);
  goto <D.103353>;
  <D.103351>:
  <D.103353>:
  try
    {
      if (0 != 0) goto <D.103354>; else goto <D.103355>;
      <D.103354>:
      if (0 == 0) goto <D.103357>; else goto <D.103358>;
      <D.103357>:
      iftmp.48 = __vtt_parm + 88;
      goto <D.103359>;
      <D.103358>:
      iftmp.48 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103359>:
      D.103360 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103360, iftmp.48);
      goto <D.103361>;
      <D.103355>:
      <D.103361>:
      try
        {
          if (0 == 0) goto <D.103363>; else goto <D.103364>;
          <D.103363>:
          iftmp.49 = __vtt_parm + 8;
          goto <D.103365>;
          <D.103364>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103365>:
          D.103366 = &this->D.97992;
          Glib::Interface::Interface (D.103366, iftmp.49, interface_class);
          try
            {
              if (0 == 0) goto <D.103368>; else goto <D.103369>;
              <D.103368>:
              iftmp.50 = __vtt_parm + 24;
              goto <D.103370>;
              <D.103369>:
              iftmp.50 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103370>:
              D.103371 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103371, iftmp.50);
              try
                {
                  if (0 == 0) goto <D.103373>; else goto <D.103374>;
                  <D.103373>:
                  iftmp.51 = *__vtt_parm;
                  goto <D.103375>;
                  <D.103374>:
                  iftmp.51 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103375>:
                  this->D.97992._vptr.Interface = iftmp.51;
                  if (0 == 0) goto <D.103377>; else goto <D.103378>;
                  <D.103377>:
                  D.103379 = this->D.97992._vptr.Interface;
                  D.103380 = D.103379 + 18446744073709551592;
                  D.103381 = MEM[(long int *)D.103380];
                  iftmp.52 = (sizetype) D.103381;
                  goto <D.103382>;
                  <D.103378>:
                  iftmp.52 = 16;
                  <D.103382>:
                  D.103383 = this + iftmp.52;
                  if (0 == 0) goto <D.103385>; else goto <D.103386>;
                  <D.103385>:
                  iftmp.53 = MEM[(const void * *)__vtt_parm + 72B];
                  goto <D.103387>;
                  <D.103386>:
                  iftmp.53 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103387>:
                  D.103383->_vptr.ObjectBase = iftmp.53;
                  if (0 == 0) goto <D.103389>; else goto <D.103390>;
                  <D.103389>:
                  iftmp.54 = MEM[(const void * *)__vtt_parm + 80B];
                  goto <D.103391>;
                  <D.103390>:
                  iftmp.54 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103391>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.54;
                }
              catch
                {
                  if (0 == 0) goto <D.103393>; else goto <D.103394>;
                  <D.103393>:
                  iftmp.55 = __vtt_parm + 24;
                  goto <D.103395>;
                  <D.103394>:
                  iftmp.55 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103395>:
                  D.103371 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103371, iftmp.55);
                }
            }
          catch
            {
              if (0 == 0) goto <D.103397>; else goto <D.103398>;
              <D.103397>:
              iftmp.56 = __vtt_parm + 8;
              goto <D.103399>;
              <D.103398>:
              iftmp.56 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103399>:
              D.103366 = &this->D.97992;
              Glib::Interface::~Interface (D.103366, iftmp.56);
            }
        }
      catch
        {
          if (0 != 0) goto <D.103400>; else goto <D.103401>;
          <D.103400>:
          if (0 == 0) goto <D.103403>; else goto <D.103404>;
          <D.103403>:
          iftmp.57 = __vtt_parm + 88;
          goto <D.103405>;
          <D.103404>:
          iftmp.57 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103405>:
          D.103360 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103360, iftmp.57);
          goto <D.103406>;
          <D.103401>:
          <D.103406>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.103407>; else goto <D.103408>;
      <D.103407>:
      D.103352 = &this->D.97997;
      sigc::trackable::~trackable (D.103352);
      goto <D.103409>;
      <D.103408>:
      <D.103409>:
    }
}


Gio::TlsClientConnection::TlsClientConnection(const Glib::Interface_Class&) (struct TlsClientConnection * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.103415;
  const void * * iftmp.58;
  struct ObjectBase * D.103423;
  const void * * iftmp.59;
  struct Interface * D.103429;
  const void * * iftmp.60;
  struct TlsConnection * D.103434;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * D.103438;
  sizetype iftmp.62;
  int (*__vtbl_ptr_type) () * D.103443;
  int (*__vtbl_ptr_type) () * D.103444;
  long int D.103445;
  struct ObjectBase * D.103447;
  int (*__vtbl_ptr_type) () * iftmp.63;
  int (*__vtbl_ptr_type) () * iftmp.64;
  const void * * iftmp.65;
  const void * * iftmp.66;
  const void * * iftmp.67;

  if (1 != 0) goto <D.103413>; else goto <D.103414>;
  <D.103413>:
  D.103415 = &this->D.97997;
  sigc::trackable::trackable (D.103415);
  goto <D.103416>;
  <D.103414>:
  <D.103416>:
  try
    {
      if (1 != 0) goto <D.103417>; else goto <D.103418>;
      <D.103417>:
      if (1 == 0) goto <D.103420>; else goto <D.103421>;
      <D.103420>:
      iftmp.58 = 88B;
      goto <D.103422>;
      <D.103421>:
      iftmp.58 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
      <D.103422>:
      D.103423 = &this->D.97996;
      Glib::ObjectBase::ObjectBase (D.103423, iftmp.58);
      goto <D.103424>;
      <D.103418>:
      <D.103424>:
      try
        {
          if (1 == 0) goto <D.103426>; else goto <D.103427>;
          <D.103426>:
          iftmp.59 = 8B;
          goto <D.103428>;
          <D.103427>:
          iftmp.59 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
          <D.103428>:
          D.103429 = &this->D.97992;
          Glib::Interface::Interface (D.103429, iftmp.59, interface_class);
          try
            {
              if (1 == 0) goto <D.103431>; else goto <D.103432>;
              <D.103431>:
              iftmp.60 = 24B;
              goto <D.103433>;
              <D.103432>:
              iftmp.60 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
              <D.103433>:
              D.103434 = &this->D.97993;
              Gio::TlsConnection::TlsConnection (D.103434, iftmp.60);
              try
                {
                  if (1 == 0) goto <D.103436>; else goto <D.103437>;
                  <D.103436>:
                  D.103438 = 0B;
                  iftmp.61 = *D.103438;
                  goto <D.103439>;
                  <D.103437>:
                  iftmp.61 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
                  <D.103439>:
                  this->D.97992._vptr.Interface = iftmp.61;
                  if (1 == 0) goto <D.103441>; else goto <D.103442>;
                  <D.103441>:
                  D.103443 = this->D.97992._vptr.Interface;
                  D.103444 = D.103443 + 18446744073709551592;
                  D.103445 = MEM[(long int *)D.103444];
                  iftmp.62 = (sizetype) D.103445;
                  goto <D.103446>;
                  <D.103442>:
                  iftmp.62 = 16;
                  <D.103446>:
                  D.103447 = this + iftmp.62;
                  if (1 == 0) goto <D.103449>; else goto <D.103450>;
                  <D.103449>:
                  iftmp.63 = MEM[(const void * *)0B + 72B];
                  goto <D.103451>;
                  <D.103450>:
                  iftmp.63 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
                  <D.103451>:
                  D.103447->_vptr.ObjectBase = iftmp.63;
                  if (1 == 0) goto <D.103453>; else goto <D.103454>;
                  <D.103453>:
                  iftmp.64 = MEM[(const void * *)0B + 80B];
                  goto <D.103455>;
                  <D.103454>:
                  iftmp.64 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
                  <D.103455>:
                  this->D.97993.D.97827.D.86809._vptr.Object = iftmp.64;
                }
              catch
                {
                  if (1 == 0) goto <D.103457>; else goto <D.103458>;
                  <D.103457>:
                  iftmp.65 = 24B;
                  goto <D.103459>;
                  <D.103458>:
                  iftmp.65 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                  <D.103459>:
                  D.103434 = &this->D.97993;
                  Gio::TlsConnection::~TlsConnection (D.103434, iftmp.65);
                }
            }
          catch
            {
              if (1 == 0) goto <D.103461>; else goto <D.103462>;
              <D.103461>:
              iftmp.66 = 8B;
              goto <D.103463>;
              <D.103462>:
              iftmp.66 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
              <D.103463>:
              D.103429 = &this->D.97992;
              Glib::Interface::~Interface (D.103429, iftmp.66);
            }
        }
      catch
        {
          if (1 != 0) goto <D.103464>; else goto <D.103465>;
          <D.103464>:
          if (1 == 0) goto <D.103467>; else goto <D.103468>;
          <D.103467>:
          iftmp.67 = 88B;
          goto <D.103469>;
          <D.103468>:
          iftmp.67 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
          <D.103469>:
          D.103423 = &this->D.97996;
          Glib::ObjectBase::~ObjectBase (D.103423, iftmp.67);
          goto <D.103470>;
          <D.103465>:
          <D.103470>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.103471>; else goto <D.103472>;
      <D.103471>:
      D.103415 = &this->D.97997;
      sigc::trackable::~trackable (D.103415);
      goto <D.103473>;
      <D.103472>:
      <D.103473>:
    }
}


Gio::TlsClientConnection::~TlsClientConnection() (struct TlsClientConnection * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.68;
  sizetype iftmp.69;
  int (*__vtbl_ptr_type) () * D.103484;
  int (*__vtbl_ptr_type) () * D.103485;
  long int D.103486;
  struct ObjectBase * D.103488;
  int (*__vtbl_ptr_type) () * iftmp.70;
  int (*__vtbl_ptr_type) () * iftmp.71;
  const void * * iftmp.72;
  struct TlsConnection * D.103501;
  const void * * iftmp.73;
  struct Interface * D.103506;
  int D.103507;
  const void * * iftmp.74;
  struct ObjectBase * D.103514;
  struct trackable * D.103518;
  int D.103520;

  {
    if (0 == 0) goto <D.103478>; else goto <D.103479>;
    <D.103478>:
    iftmp.68 = *__vtt_parm;
    goto <D.103480>;
    <D.103479>:
    iftmp.68 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
    <D.103480>:
    this->D.97992._vptr.Interface = iftmp.68;
    if (0 == 0) goto <D.103482>; else goto <D.103483>;
    <D.103482>:
    D.103484 = this->D.97992._vptr.Interface;
    D.103485 = D.103484 + 18446744073709551592;
    D.103486 = MEM[(long int *)D.103485];
    iftmp.69 = (sizetype) D.103486;
    goto <D.103487>;
    <D.103483>:
    iftmp.69 = 16;
    <D.103487>:
    D.103488 = this + iftmp.69;
    if (0 == 0) goto <D.103490>; else goto <D.103491>;
    <D.103490>:
    iftmp.70 = MEM[(const void * *)__vtt_parm + 72B];
    goto <D.103492>;
    <D.103491>:
    iftmp.70 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
    <D.103492>:
    D.103488->_vptr.ObjectBase = iftmp.70;
    if (0 == 0) goto <D.103494>; else goto <D.103495>;
    <D.103494>:
    iftmp.71 = MEM[(const void * *)__vtt_parm + 80B];
    goto <D.103496>;
    <D.103495>:
    iftmp.71 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
    <D.103496>:
    this->D.97993.D.97827.D.86809._vptr.Object = iftmp.71;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (0 == 0) goto <D.103498>; else goto <D.103499>;
                        <D.103498>:
                        iftmp.72 = __vtt_parm + 24;
                        goto <D.103500>;
                        <D.103499>:
                        iftmp.72 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                        <D.103500>:
                        D.103501 = &this->D.97993;
                        Gio::TlsConnection::~TlsConnection (D.103501, iftmp.72);
                      }
                  }
                finally
                  {
                    if (0 == 0) goto <D.103503>; else goto <D.103504>;
                    <D.103503>:
                    iftmp.73 = __vtt_parm + 8;
                    goto <D.103505>;
                    <D.103504>:
                    iftmp.73 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
                    <D.103505>:
                    D.103506 = &this->D.97992;
                    Glib::Interface::~Interface (D.103506, iftmp.73);
                  }
              }
            finally
              {
                D.103507 = 0;
                if (D.103507 != 0) goto <D.103508>; else goto <D.103509>;
                <D.103508>:
                if (0 == 0) goto <D.103511>; else goto <D.103512>;
                <D.103511>:
                iftmp.74 = __vtt_parm + 88;
                goto <D.103513>;
                <D.103512>:
                iftmp.74 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
                <D.103513>:
                D.103514 = &this->D.97996;
                Glib::ObjectBase::~ObjectBase (D.103514, iftmp.74);
                goto <D.103515>;
                <D.103509>:
                <D.103515>:
              }
          }
        finally
          {
            D.103507 = 0;
            if (D.103507 != 0) goto <D.103516>; else goto <D.103517>;
            <D.103516>:
            D.103518 = &this->D.97997;
            sigc::trackable::~trackable (D.103518);
            goto <D.103519>;
            <D.103517>:
            <D.103519>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98479>:
  D.103520 = 0;
  if (D.103520 != 0) goto <D.103521>; else goto <D.103522>;
  <D.103521>:
  operator delete (this);
  goto <D.103523>;
  <D.103522>:
  <D.103523>:
}


virtual Gio::TlsClientConnection::~TlsClientConnection() (struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.75;
  const void * * D.103543;
  sizetype iftmp.76;
  int (*__vtbl_ptr_type) () * D.103548;
  int (*__vtbl_ptr_type) () * D.103549;
  long int D.103550;
  struct ObjectBase * D.103552;
  int (*__vtbl_ptr_type) () * iftmp.77;
  int (*__vtbl_ptr_type) () * iftmp.78;
  const void * * iftmp.79;
  struct TlsConnection * D.103565;
  const void * * iftmp.80;
  struct Interface * D.103570;
  int D.103571;
  const void * * iftmp.81;
  struct ObjectBase * D.103578;
  struct trackable * D.103582;
  int D.103584;

  {
    if (2 == 0) goto <D.103541>; else goto <D.103542>;
    <D.103541>:
    D.103543 = 0B;
    iftmp.75 = *D.103543;
    goto <D.103544>;
    <D.103542>:
    iftmp.75 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 32B];
    <D.103544>:
    this->D.97992._vptr.Interface = iftmp.75;
    if (2 == 0) goto <D.103546>; else goto <D.103547>;
    <D.103546>:
    D.103548 = this->D.97992._vptr.Interface;
    D.103549 = D.103548 + 18446744073709551592;
    D.103550 = MEM[(long int *)D.103549];
    iftmp.76 = (sizetype) D.103550;
    goto <D.103551>;
    <D.103547>:
    iftmp.76 = 16;
    <D.103551>:
    D.103552 = this + iftmp.76;
    if (2 == 0) goto <D.103554>; else goto <D.103555>;
    <D.103554>:
    iftmp.77 = MEM[(const void * *)0B + 72B];
    goto <D.103556>;
    <D.103555>:
    iftmp.77 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 192B];
    <D.103556>:
    D.103552->_vptr.ObjectBase = iftmp.77;
    if (2 == 0) goto <D.103558>; else goto <D.103559>;
    <D.103558>:
    iftmp.78 = MEM[(const void * *)0B + 80B];
    goto <D.103560>;
    <D.103559>:
    iftmp.78 = &MEM[(void *)&_ZTVN3Gio19TlsClientConnectionE + 80B];
    <D.103560>:
    this->D.97993.D.97827.D.86809._vptr.Object = iftmp.78;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (2 == 0) goto <D.103562>; else goto <D.103563>;
                        <D.103562>:
                        iftmp.79 = 24B;
                        goto <D.103564>;
                        <D.103563>:
                        iftmp.79 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 24B];
                        <D.103564>:
                        D.103565 = &this->D.97993;
                        Gio::TlsConnection::~TlsConnection (D.103565, iftmp.79);
                      }
                  }
                finally
                  {
                    if (2 == 0) goto <D.103567>; else goto <D.103568>;
                    <D.103567>:
                    iftmp.80 = 8B;
                    goto <D.103569>;
                    <D.103568>:
                    iftmp.80 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 8B];
                    <D.103569>:
                    D.103570 = &this->D.97992;
                    Glib::Interface::~Interface (D.103570, iftmp.80);
                  }
              }
            finally
              {
                D.103571 = 2;
                if (D.103571 != 0) goto <D.103572>; else goto <D.103573>;
                <D.103572>:
                if (2 == 0) goto <D.103575>; else goto <D.103576>;
                <D.103575>:
                iftmp.81 = 88B;
                goto <D.103577>;
                <D.103576>:
                iftmp.81 = &MEM[(void *)&_ZTTN3Gio19TlsClientConnectionE + 88B];
                <D.103577>:
                D.103578 = &this->D.97996;
                Glib::ObjectBase::~ObjectBase (D.103578, iftmp.81);
                goto <D.103579>;
                <D.103573>:
                <D.103579>:
              }
          }
        finally
          {
            D.103571 = 2;
            if (D.103571 != 0) goto <D.103580>; else goto <D.103581>;
            <D.103580>:
            D.103582 = &this->D.97997;
            sigc::trackable::~trackable (D.103582);
            goto <D.103583>;
            <D.103581>:
            <D.103583>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98482>:
  D.103584 = 0;
  if (D.103584 != 0) goto <D.103585>; else goto <D.103586>;
  <D.103585>:
  operator delete (this);
  goto <D.103587>;
  <D.103586>:
  <D.103587>:
}


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


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

  D.103604 = Gio::TlsClientConnection_Class::init (&tlsclientconnection_class_);
  Glib::Interface_Class::add_interface (D.103604, gtype_implementer);
}


static GType Gio::TlsClientConnection::get_type() ()
{
  GType D.103606;
  const struct Interface_Class & D.103607;
  const struct Class * D.103608;

  D.103607 = Gio::TlsClientConnection_Class::init (&tlsclientconnection_class_);
  D.103608 = &D.103607->D.98021;
  D.103606 = Glib::Class::get_type (D.103608);
  return D.103606;
}


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

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


static GType Gio::TlsClientConnection::get_base_type() ()
{
  GType D.103613;

  D.103613 = g_tls_client_connection_get_type ();
  return D.103613;
}


static Glib::RefPtr<Gio::TlsClientConnection> Gio::TlsClientConnection::create(const Glib::RefPtr<Gio::IOStream>&, const Glib::RefPtr<const Gio::SocketConnectable>&) (const struct RefPtr & base_io_stream, const struct RefPtr & server_identity)
{
  long unsigned int D.103617;
  const struct BaseObjectType * D.103618;
  struct BaseObjectType * D.103619;
  struct GIOStream * D.103620;
  struct GTypeInstance * D.103621;
  struct GError * gerror.82;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103617 = g_tls_client_connection_get_type ();
      D.103618 = Glib::unwrap<Gio::SocketConnectable> (server_identity);
      D.103619 = Glib::unwrap<Gio::IOStream> (base_io_stream);
      D.103620 = g_tls_client_connection_new (D.103619, D.103618, &gerror);
      D.103621 = g_type_check_instance_cast (D.103620, D.103617);
      *<retval> = Glib::wrap (D.103621, 0); [return slot optimization]
      try
        {
          gerror.82 = gerror;
          if (gerror.82 != 0B) goto <D.103623>; else goto <D.103624>;
          <D.103623>:
          gerror.82 = gerror;
          Glib::Error::throw_exception (gerror.82);
          <D.103624>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsClientConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


const typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<const T>&) [with T = Gio::SocketConnectable; typename T::BaseObjectType = _GSocketConnectable] (const struct RefPtr & ptr)
{
  const struct BaseObjectType * D.103634;
  const struct BaseObjectType * iftmp.83;
  bool D.103636;
  const struct SocketConnectable * D.103639;

  D.103636 = Glib::RefPtr<const Gio::SocketConnectable>::operator bool (ptr);
  if (D.103636 != 0) goto <D.103637>; else goto <D.103638>;
  <D.103637>:
  D.103639 = Glib::RefPtr<const Gio::SocketConnectable>::operator-> (ptr);
  iftmp.83 = Gio::SocketConnectable::gobj (D.103639);
  goto <D.103640>;
  <D.103638>:
  iftmp.83 = 0B;
  <D.103640>:
  D.103634 = iftmp.83;
  return D.103634;
}


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

  D.103643 = this->pCppObject_;
  D.103642 = D.103643 != 0B;
  return D.103642;
}


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

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


const GSocketConnectable* Gio::SocketConnectable::gobj() const (const struct SocketConnectable * const this)
{
  const struct GSocketConnectable * D.103647;
  int (*__vtbl_ptr_type) () * D.103648;
  int (*__vtbl_ptr_type) () * D.103649;
  long int D.103650;
  sizetype D.103651;
  const struct ObjectBase * D.103652;

  D.103648 = this->D.98257._vptr.Interface;
  D.103649 = D.103648 + 18446744073709551592;
  D.103650 = MEM[(long int *)D.103649];
  D.103651 = (sizetype) D.103650;
  D.103652 = this + D.103651;
  D.103647 = D.103652->gobject_;
  return D.103647;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::IOStream; typename T::BaseObjectType = _GIOStream] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.103654;
  struct BaseObjectType * iftmp.84;
  bool D.103656;
  struct IOStream * D.103659;

  D.103656 = Glib::RefPtr<Gio::IOStream>::operator bool (ptr);
  if (D.103656 != 0) goto <D.103657>; else goto <D.103658>;
  <D.103657>:
  D.103659 = Glib::RefPtr<Gio::IOStream>::operator-> (ptr);
  iftmp.84 = Gio::IOStream::gobj (D.103659);
  goto <D.103660>;
  <D.103658>:
  iftmp.84 = 0B;
  <D.103660>:
  D.103654 = iftmp.84;
  return D.103654;
}


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

  D.103663 = this->pCppObject_;
  D.103662 = D.103663 != 0B;
  return D.103662;
}


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

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


GIOStream* Gio::IOStream::gobj() (struct IOStream * const this)
{
  struct GIOStream * D.103667;
  int (*__vtbl_ptr_type) () * D.103668;
  int (*__vtbl_ptr_type) () * D.103669;
  long int D.103670;
  sizetype D.103671;
  struct ObjectBase * D.103672;

  D.103668 = this->D.86809._vptr.Object;
  D.103669 = D.103668 + 18446744073709551592;
  D.103670 = MEM[(long int *)D.103669];
  D.103671 = (sizetype) D.103670;
  D.103672 = this + D.103671;
  D.103667 = D.103672->gobject_;
  return D.103667;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::TlsClientConnection] (struct RefPtr * const this)
{
  struct TlsClientConnection * D.103674;
  int (*__vtbl_ptr_type) () * D.103677;
  int (*__vtbl_ptr_type) () * D.103678;
  long int D.103679;
  sizetype D.103680;
  struct ObjectBase * D.103681;
  int (*__vtbl_ptr_type) () * D.103682;
  int (*__vtbl_ptr_type) () * D.103683;
  int (*__vtbl_ptr_type) () D.103684;

  {
    try
      {
        D.103674 = this->pCppObject_;
        if (D.103674 != 0B) goto <D.103675>; else goto <D.103676>;
        <D.103675>:
        D.103674 = this->pCppObject_;
        D.103674 = this->pCppObject_;
        D.103677 = D.103674->D.97992._vptr.Interface;
        D.103678 = D.103677 + 18446744073709551592;
        D.103679 = MEM[(long int *)D.103678];
        D.103680 = (sizetype) D.103679;
        D.103681 = D.103674 + D.103680;
        D.103674 = this->pCppObject_;
        D.103674 = this->pCppObject_;
        D.103677 = D.103674->D.97992._vptr.Interface;
        D.103678 = D.103677 + 18446744073709551592;
        D.103679 = MEM[(long int *)D.103678];
        D.103680 = (sizetype) D.103679;
        D.103681 = D.103674 + D.103680;
        D.103682 = D.103681->_vptr.ObjectBase;
        D.103683 = D.103682 + 24;
        D.103684 = *D.103683;
        D.103674 = this->pCppObject_;
        D.103674 = this->pCppObject_;
        D.103677 = D.103674->D.97992._vptr.Interface;
        D.103678 = D.103677 + 18446744073709551592;
        D.103679 = MEM[(long int *)D.103678];
        D.103680 = (sizetype) D.103679;
        D.103681 = D.103674 + D.103680;
        OBJ_TYPE_REF(D.103684;(const struct ObjectBase)D.103681->3) (D.103681);
        goto <D.103685>;
        <D.103676>:
        <D.103685>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101148>:
}


static Glib::RefPtr<Gio::TlsClientConnection> Gio::TlsClientConnection::create(const Glib::RefPtr<Gio::IOStream>&) (const struct RefPtr & base_io_stream)
{
  long unsigned int D.103688;
  struct BaseObjectType * D.103689;
  struct GIOStream * D.103690;
  struct GTypeInstance * D.103691;
  struct GError * gerror.85;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.103688 = g_tls_client_connection_get_type ();
      D.103689 = Glib::unwrap<Gio::IOStream> (base_io_stream);
      D.103690 = g_tls_client_connection_new (D.103689, 0B, &gerror);
      D.103691 = g_type_check_instance_cast (D.103690, D.103688);
      *<retval> = Glib::wrap (D.103691, 0); [return slot optimization]
      try
        {
          gerror.85 = gerror;
          if (gerror.85 != 0B) goto <D.103693>; else goto <D.103694>;
          <D.103693>:
          gerror.85 = gerror;
          Glib::Error::throw_exception (gerror.85);
          <D.103694>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsClientConnection>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::TlsClientConnection::set_server_identity(const Glib::RefPtr<Gio::SocketConnectable>&) (struct TlsClientConnection * const this, const struct RefPtr & identity)
{
  struct BaseObjectType * D.103703;
  struct GTlsClientConnection * D.103704;

  D.103703 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.103704 = Gio::TlsClientConnection::gobj (this);
  g_tls_client_connection_set_server_identity (D.103704, D.103703);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::SocketConnectable; typename T::BaseObjectType = _GSocketConnectable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.103706;
  struct BaseObjectType * iftmp.86;
  bool D.103708;
  struct SocketConnectable * D.103711;

  D.103708 = Glib::RefPtr<Gio::SocketConnectable>::operator bool (ptr);
  if (D.103708 != 0) goto <D.103709>; else goto <D.103710>;
  <D.103709>:
  D.103711 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (ptr);
  iftmp.86 = Gio::SocketConnectable::gobj (D.103711);
  goto <D.103712>;
  <D.103710>:
  iftmp.86 = 0B;
  <D.103712>:
  D.103706 = iftmp.86;
  return D.103706;
}


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

  D.103715 = this->pCppObject_;
  D.103714 = D.103715 != 0B;
  return D.103714;
}


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

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


GSocketConnectable* Gio::SocketConnectable::gobj() (struct SocketConnectable * const this)
{
  struct GSocketConnectable * D.103719;
  int (*__vtbl_ptr_type) () * D.103720;
  int (*__vtbl_ptr_type) () * D.103721;
  long int D.103722;
  sizetype D.103723;
  struct ObjectBase * D.103724;

  D.103720 = this->D.98257._vptr.Interface;
  D.103721 = D.103720 + 18446744073709551592;
  D.103722 = MEM[(long int *)D.103721];
  D.103723 = (sizetype) D.103722;
  D.103724 = this + D.103723;
  D.103719 = D.103724->gobject_;
  return D.103719;
}


GTlsClientConnection* Gio::TlsClientConnection::gobj() (struct TlsClientConnection * const this)
{
  struct GTlsClientConnection * D.103726;
  int (*__vtbl_ptr_type) () * D.103727;
  int (*__vtbl_ptr_type) () * D.103728;
  long int D.103729;
  sizetype D.103730;
  struct ObjectBase * D.103731;

  D.103727 = this->D.97992._vptr.Interface;
  D.103728 = D.103727 + 18446744073709551592;
  D.103729 = MEM[(long int *)D.103728];
  D.103730 = (sizetype) D.103729;
  D.103731 = this + D.103730;
  D.103726 = D.103731->gobject_;
  return D.103726;
}


Glib::RefPtr<Gio::SocketConnectable> Gio::TlsClientConnection::get_server_identity() (struct TlsClientConnection * const this)
{
  struct GTlsClientConnection * D.103734;
  struct GSocketConnectable * D.103735;
  bool retval.87;
  struct SocketConnectable * D.103739;
  int (*__vtbl_ptr_type) () * D.103740;
  int (*__vtbl_ptr_type) () * D.103741;
  long int D.103742;
  sizetype D.103743;
  struct ObjectBase * D.103744;
  int (*__vtbl_ptr_type) () * D.103745;
  int (*__vtbl_ptr_type) () * D.103746;
  int (*__vtbl_ptr_type) () D.103747;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.103734 = Gio::TlsClientConnection::gobj (this);
  D.103735 = g_tls_client_connection_get_server_identity (D.103734);
  *<retval> = Glib::wrap (D.103735, 0); [return slot optimization]
  try
    {
      retval.87 = Glib::RefPtr<Gio::SocketConnectable>::operator bool (<retval>);
      if (retval.87 != 0) goto <D.103737>; else goto <D.103738>;
      <D.103737>:
      D.103739 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (<retval>);
      D.103740 = D.103739->D.98257._vptr.Interface;
      D.103741 = D.103740 + 18446744073709551592;
      D.103742 = MEM[(long int *)D.103741];
      D.103743 = (sizetype) D.103742;
      D.103744 = D.103739 + D.103743;
      D.103740 = D.103739->D.98257._vptr.Interface;
      D.103741 = D.103740 + 18446744073709551592;
      D.103742 = MEM[(long int *)D.103741];
      D.103743 = (sizetype) D.103742;
      D.103744 = D.103739 + D.103743;
      D.103745 = D.103744->_vptr.ObjectBase;
      D.103746 = D.103745 + 16;
      D.103747 = *D.103746;
      D.103740 = D.103739->D.98257._vptr.Interface;
      D.103741 = D.103740 + 18446744073709551592;
      D.103742 = MEM[(long int *)D.103741];
      D.103743 = (sizetype) D.103742;
      D.103744 = D.103739 + D.103743;
      OBJ_TYPE_REF(D.103747;(const struct ObjectBase)D.103744->2) (D.103744);
      goto <D.103748>;
      <D.103738>:
      <D.103748>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnectable] (struct RefPtr * const this)
{
  struct SocketConnectable * D.103752;
  int (*__vtbl_ptr_type) () * D.103755;
  int (*__vtbl_ptr_type) () * D.103756;
  long int D.103757;
  sizetype D.103758;
  struct ObjectBase * D.103759;
  int (*__vtbl_ptr_type) () * D.103760;
  int (*__vtbl_ptr_type) () * D.103761;
  int (*__vtbl_ptr_type) () D.103762;

  {
    try
      {
        D.103752 = this->pCppObject_;
        if (D.103752 != 0B) goto <D.103753>; else goto <D.103754>;
        <D.103753>:
        D.103752 = this->pCppObject_;
        D.103752 = this->pCppObject_;
        D.103755 = D.103752->D.98257._vptr.Interface;
        D.103756 = D.103755 + 18446744073709551592;
        D.103757 = MEM[(long int *)D.103756];
        D.103758 = (sizetype) D.103757;
        D.103759 = D.103752 + D.103758;
        D.103752 = this->pCppObject_;
        D.103752 = this->pCppObject_;
        D.103755 = D.103752->D.98257._vptr.Interface;
        D.103756 = D.103755 + 18446744073709551592;
        D.103757 = MEM[(long int *)D.103756];
        D.103758 = (sizetype) D.103757;
        D.103759 = D.103752 + D.103758;
        D.103760 = D.103759->_vptr.ObjectBase;
        D.103761 = D.103760 + 24;
        D.103762 = *D.103761;
        D.103752 = this->pCppObject_;
        D.103752 = this->pCppObject_;
        D.103755 = D.103752->D.98257._vptr.Interface;
        D.103756 = D.103755 + 18446744073709551592;
        D.103757 = MEM[(long int *)D.103756];
        D.103758 = (sizetype) D.103757;
        D.103759 = D.103752 + D.103758;
        OBJ_TYPE_REF(D.103762;(const struct ObjectBase)D.103759->3) (D.103759);
        goto <D.103763>;
        <D.103754>:
        <D.103763>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101161>:
}


Glib::RefPtr<const Gio::SocketConnectable> Gio::TlsClientConnection::get_server_identity() const (const struct TlsClientConnection * const this)
{
  struct RefPtr D.98927;

  D.98927 = Gio::TlsClientConnection::get_server_identity (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::SocketConnectable>::RefPtr<Gio::SocketConnectable> (<retval>, &D.98927);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (&D.98927);
      D.98927 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::SocketConnectable; T_CppObject = const Gio::SocketConnectable] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct SocketConnectable * D.103769;
  const struct SocketConnectable * D.103770;
  int (*__vtbl_ptr_type) () * D.103773;
  int (*__vtbl_ptr_type) () * D.103774;
  long int D.103775;
  sizetype D.103776;
  const struct ObjectBase * D.103777;
  int (*__vtbl_ptr_type) () * D.103778;
  int (*__vtbl_ptr_type) () * D.103779;
  int (*__vtbl_ptr_type) () D.103780;

  D.103769 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (src);
  this->pCppObject_ = D.103769;
  D.103770 = this->pCppObject_;
  if (D.103770 != 0B) goto <D.103771>; else goto <D.103772>;
  <D.103771>:
  D.103770 = this->pCppObject_;
  D.103770 = this->pCppObject_;
  D.103773 = D.103770->D.98257._vptr.Interface;
  D.103774 = D.103773 + 18446744073709551592;
  D.103775 = MEM[(long int *)D.103774];
  D.103776 = (sizetype) D.103775;
  D.103777 = D.103770 + D.103776;
  D.103770 = this->pCppObject_;
  D.103770 = this->pCppObject_;
  D.103773 = D.103770->D.98257._vptr.Interface;
  D.103774 = D.103773 + 18446744073709551592;
  D.103775 = MEM[(long int *)D.103774];
  D.103776 = (sizetype) D.103775;
  D.103777 = D.103770 + D.103776;
  D.103778 = D.103777->_vptr.ObjectBase;
  D.103779 = D.103778 + 16;
  D.103780 = *D.103779;
  D.103770 = this->pCppObject_;
  D.103770 = this->pCppObject_;
  D.103773 = D.103770->D.98257._vptr.Interface;
  D.103774 = D.103773 + 18446744073709551592;
  D.103775 = MEM[(long int *)D.103774];
  D.103776 = (sizetype) D.103775;
  D.103777 = D.103770 + D.103776;
  OBJ_TYPE_REF(D.103780;(const struct ObjectBase)D.103777->2) (D.103777);
  goto <D.103781>;
  <D.103772>:
  <D.103781>:
}


void Gio::TlsClientConnection::set_validation_flags(Gio::TlsCertificateFlags) (struct TlsClientConnection * const this, TlsCertificateFlags flags)
{
  struct GTlsClientConnection * D.103782;

  D.103782 = Gio::TlsClientConnection::gobj (this);
  g_tls_client_connection_set_validation_flags (D.103782, flags);
}


Gio::TlsCertificateFlags Gio::TlsClientConnection::get_validation_flags() const (const struct TlsClientConnection * const this)
{
  TlsCertificateFlags D.103783;
  const struct GTlsClientConnection * D.103784;

  D.103784 = Gio::TlsClientConnection::gobj (this);
  D.103783 = g_tls_client_connection_get_validation_flags (D.103784);
  return D.103783;
}


const GTlsClientConnection* Gio::TlsClientConnection::gobj() const (const struct TlsClientConnection * const this)
{
  const struct GTlsClientConnection * D.103787;
  int (*__vtbl_ptr_type) () * D.103788;
  int (*__vtbl_ptr_type) () * D.103789;
  long int D.103790;
  sizetype D.103791;
  const struct ObjectBase * D.103792;

  D.103788 = this->D.97992._vptr.Interface;
  D.103789 = D.103788 + 18446744073709551592;
  D.103790 = MEM[(long int *)D.103789];
  D.103791 = (sizetype) D.103790;
  D.103792 = this + D.103791;
  D.103787 = D.103792->gobject_;
  return D.103787;
}


void Gio::TlsClientConnection::set_use_ssl3(bool) (struct TlsClientConnection * const this, bool use_ssl3)
{
  int D.103794;
  struct GTlsClientConnection * D.103795;

  D.103794 = (int) use_ssl3;
  D.103795 = Gio::TlsClientConnection::gobj (this);
  g_tls_client_connection_set_use_ssl3 (D.103795, D.103794);
}


bool Gio::TlsClientConnection::get_use_ssl3() const (const struct TlsClientConnection * const this)
{
  bool D.103796;
  const struct GTlsClientConnection * D.103797;
  int D.103798;

  D.103797 = Gio::TlsClientConnection::gobj (this);
  D.103798 = g_tls_client_connection_get_use_ssl3 (D.103797);
  D.103796 = D.103798 != 0;
  return D.103796;
}


std::vector<Glib::RefPtr<Glib::ByteArray> > Gio::TlsClientConnection::get_accepted_cas() (struct TlsClientConnection * const this)
{
  struct GTlsClientConnection * D.103802;
  struct GList * D.103803;

  D.103802 = Gio::TlsClientConnection::gobj (this);
  D.103803 = g_tls_client_connection_get_accepted_cas (D.103802);
  *<retval> = Glib::ListHandler<Glib::RefPtr<Glib::ByteArray> >::list_to_vector (D.103803, 2); [return slot optimization]
  return <retval>;
}


static Glib::ListHandler<T, Tr>::VectorType Glib::ListHandler<T, Tr>::list_to_vector(GList*, Glib::OwnershipType) [with T = Glib::RefPtr<Glib::ByteArray>; Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >; Glib::ListHandler<T, Tr>::VectorType = std::vector<Glib::RefPtr<Glib::ByteArray> >; GList = _GList] (struct GList * glist, OwnershipType ownership)
{
  struct allocator_type D.101289;
  struct ListIteratorType D.101272;
  struct ListIteratorType D.101271;
  struct GListKeeperType keeper;

  try
    {
      Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::GListKeeper (&keeper, glist, ownership);
      try
        {
          std::allocator<Glib::RefPtr<Glib::ByteArray> >::allocator (&D.101289);
          try
            {
              Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::ListIterator (&D.101272, 0B);
              try
                {
                  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::ListIterator (&D.101271, glist);
                  try
                    {
                      std::vector<Glib::RefPtr<Glib::ByteArray> >::vector<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (<retval>, D.101271, D.101272, &D.101289);
                      return <retval>;
                    }
                  finally
                    {
                      D.101271 = {CLOBBER};
                    }
                }
              finally
                {
                  D.101272 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<Glib::RefPtr<Glib::ByteArray> >::~allocator (&D.101289);
              D.101289 = {CLOBBER};
            }
        }
      finally
        {
          Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::~GListKeeper (&keeper);
        }
    }
  finally
    {
      keeper = {CLOBBER};
    }
}


Glib::Container_Helpers::GListKeeper<Tr>::GListKeeper(const GList*, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >; GList = _GList] (struct GListKeeper * const this, const struct GList * glist, OwnershipType ownership)
{
  this->glist_ = glist;
  this->ownership_ = ownership;
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct allocator * const this)
{
  void * D.103818;

  try
    {
      {
        __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103818 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103818);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct new_allocator * const this)
{
  void * D.103819;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103819 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103819);
          
        }
    }
}


Glib::Container_Helpers::ListIterator<Tr>::ListIterator(const GList*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >; GList = _GList] (struct ListIterator * const this, const struct GList * node)
{
  this->node_ = node;
}


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.103820;
  struct _Integral D.101966;
  struct __false_type D.103821;

  D.103820 = &this->D.99705;
  std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_Vector_base (D.103820, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<Glib::RefPtr<Glib::ByteArray> >::_M_initialize_dispatch<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (this, __first, __last, D.103821);
          }
        finally
          {
            D.101966 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.103820 = &this->D.99705;
      std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::~_Vector_base (D.103820);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base(const allocator_type&) [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct _Vector_base * const this, const struct allocator_type & __a)
{
  struct _Vector_impl * D.103824;

  D.103824 = &this->_M_impl;
  std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_Vector_impl::_Vector_impl (D.103824, __a);
  try
    {

    }
  catch
    {
      D.103824 = &this->_M_impl;
      std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_Vector_impl::~_Vector_impl (D.103824);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl(const _Tp_alloc_type&) [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct _Vector_impl * const this, const struct _Tp_alloc_type & __a)
{
  std::allocator<Glib::RefPtr<Glib::ByteArray> >::allocator (this, __a);
  try
    {
      this->_M_start = 0B;
      this->_M_finish = 0B;
      this->_M_end_of_storage = 0B;
    }
  catch
    {
      std::allocator<Glib::RefPtr<Glib::ByteArray> >::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator< <template-parameter-1-1> >&) [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct allocator * const this, const struct allocator & __a)
{
  void * D.103825;

  try
    {
      {
        __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103825 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103825);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct new_allocator * const this, const struct new_allocator & D.99045)
{
  void * D.103826;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103826 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103826);
          
        }
    }
}


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct __false_type D.101920)
{
  struct _IterCategory D.102384;
  struct forward_iterator_tag D.103827;
  typedef struct _IterCategory _IterCategory;

  try
    {
      std::vector<Glib::RefPtr<Glib::ByteArray> >::_M_range_initialize<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (this, __first, __last, D.103827);
    }
  finally
    {
      D.102384 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct forward_iterator_tag D.102389)
{
  long int D.103829;
  struct _Vector_base * D.103830;
  struct RefPtr * D.103831;
  struct RefPtr * D.103832;
  long unsigned int D.103833;
  struct RefPtr * D.103834;
  struct _Tp_alloc_type & D.103835;
  struct RefPtr * D.103836;
  const size_type __n;

  D.103829 = std::distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (__first, __last);
  __n = (const size_type) D.103829;
  D.103830 = &this->D.99705;
  D.103831 = std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_M_allocate (D.103830, __n);
  this->D.99705._M_impl._M_start = D.103831;
  D.103832 = this->D.99705._M_impl._M_start;
  D.103833 = __n * 8;
  D.103834 = D.103832 + D.103833;
  this->D.99705._M_impl._M_end_of_storage = D.103834;
  D.103830 = &this->D.99705;
  D.103835 = std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_M_get_Tp_allocator (D.103830);
  D.103832 = this->D.99705._M_impl._M_start;
  D.103836 = std::__uninitialized_copy_a<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >, Glib::RefPtr<Glib::ByteArray>*, Glib::RefPtr<Glib::ByteArray> > (__first, __last, D.103832, D.103835);
  this->D.99705._M_impl._M_finish = D.103836;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last)
{
  difference_type D.103840;
  struct input_iterator_tag D.102836;
  struct iterator_category D.102799;
  struct iterator_category * D.103841;
  struct input_iterator_tag D.103842;

  std::__iterator_category<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (&__first);
  try
    {
      D.103841 = &D.102799;
      D.103840 = std::__distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > > > (__first, __last, D.103842);
      return D.103840;
    }
  finally
    {
      D.102799 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::iterator_category = std::forward_iterator_tag] (const struct ListIterator & D.102798)
{
  struct iterator_category D.103847;

  return D.103847;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_InputIterator, _InputIterator, std::input_iterator_tag) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last, struct input_iterator_tag D.102818)
{
  bool retval.88;
  difference_type D.103850;
  difference_type __n;

  __n = 0;
  goto <D.102902>;
  <D.102903>:
  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::operator++ (&__first);
  __n = __n + 1;
  <D.102902>:
  retval.88 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::operator!= (&__first, &__last);
  if (retval.88 != 0) goto <D.102903>; else goto <D.102901>;
  <D.102901>:
  D.103850 = __n;
  return D.103850;
}


Glib::Container_Helpers::ListIterator<Tr>& Glib::Container_Helpers::ListIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >] (struct ListIterator * const this)
{
  const struct GList * D.103852;
  struct GList * D.103853;
  struct ListIterator & D.103854;

  D.103852 = this->node_;
  D.103853 = D.103852->next;
  this->node_ = D.103853;
  D.103854 = this;
  return D.103854;
}


bool Glib::Container_Helpers::ListIterator<Tr>::operator!=(const Glib::Container_Helpers::ListIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >] (const struct ListIterator * const this, const struct ListIterator & rhs)
{
  bool D.103856;
  const struct GList * D.103857;
  const struct GList * D.103858;

  D.103857 = this->node_;
  D.103858 = rhs->node_;
  D.103856 = D.103857 != D.103858;
  return D.103856;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::pointer = Glib::RefPtr<Glib::ByteArray>*; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct RefPtr * D.103860;
  struct RefPtr * iftmp.89;
  struct _Vector_impl * D.103864;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.103862>; else goto <D.103863>;
  <D.103862>:
  D.103864 = &this->_M_impl;
  iftmp.89 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Glib::ByteArray> > >::allocate (D.103864, __n);
  goto <D.103865>;
  <D.103863>:
  iftmp.89 = 0B;
  <D.103865>:
  D.103860 = iftmp.89;
  return D.103860;
}


static __gnu_cxx::__alloc_traits<_Alloc>::pointer __gnu_cxx::__alloc_traits<_Alloc>::allocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<Glib::ByteArray>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct RefPtr * D.103868;

  D.103868 = __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::allocate (__a, __n, 0B);
  return D.103868;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::RefPtr<Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Glib::ByteArray>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.99018)
{
  bool retval.90;
  long unsigned int D.103872;
  struct RefPtr * D.103875;
  long unsigned int D.103876;

  D.103872 = __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::max_size (this);
  retval.90 = D.103872 < __n;
  if (retval.90 != 0) goto <D.103873>; else goto <D.103874>;
  <D.103873>:
  std::__throw_bad_alloc ();
  <D.103874>:
  D.103876 = __n * 8;
  D.103875 = operator new (D.103876);
  return D.103875;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = Glib::RefPtr<Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.103879;
  void * D.103880;

  try
    {
      D.103879 = 2305843009213693951;
      return D.103879;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103880 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103880);
          
        }
    }
}


std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct _Vector_base * const this)
{
  struct _Tp_alloc_type & D.103882;

  D.103882 = &this->_M_impl;
  return D.103882;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<Glib::ByteArray>*; _Tp = Glib::RefPtr<Glib::ByteArray>] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result, struct allocator & D.102651)
{
  struct RefPtr * D.103884;

  D.103884 = std::uninitialized_copy<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >, Glib::RefPtr<Glib::ByteArray>*> (__first, __last, __result);
  return D.103884;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<Glib::ByteArray>*] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct RefPtr * D.103887;
  typedef struct _ValueType1 _ValueType1;
  typedef struct _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.103887 = std::__uninitialized_copy<false>::__uninit_copy<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >, Glib::RefPtr<Glib::ByteArray>*> (__first, __last, __result);
  return D.103887;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<Glib::ByteArray>*; bool _TrivialValueTypes = false] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct value_type D.102949;
  struct RefPtr * D.103890;
  bool retval.91;
  struct RefPtr * D.103892;
  void * D.103893;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.102953>;
      <D.102952>:
      D.102949 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.103890 = std::__addressof<Glib::RefPtr<Glib::ByteArray> > (__cur);
          std::_Construct<Glib::RefPtr<Glib::ByteArray>, Glib::RefPtr<Glib::ByteArray> > (D.103890, &D.102949);
        }
      finally
        {
          Glib::RefPtr<Glib::ByteArray>::~RefPtr (&D.102949);
          D.102949 = {CLOBBER};
        }
      Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.102953>:
      retval.91 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> > >::operator!= (&__first, &__last);
      if (retval.91 != 0) goto <D.102952>; else goto <D.102950>;
      <D.102950>:
      D.103892 = __cur;
      return D.103892;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.103893 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.103893);
              std::_Destroy<Glib::RefPtr<Glib::ByteArray>*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::Container_Helpers::ListIterator<Tr>::value_type Glib::Container_Helpers::ListIterator<Tr>::operator*() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >; Glib::Container_Helpers::ListIterator<Tr>::value_type = Glib::RefPtr<Glib::ByteArray>] (const struct ListIterator * const this)
{
  const struct GList * D.103900;
  void * D.103901;

  D.103900 = this->node_;
  D.103901 = D.103900->data;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >::to_cpp_type (D.103901); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CppType Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::to_cpp_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType) [with T = Glib::ByteArray; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CppType = Glib::RefPtr<Glib::ByteArray>; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType = _GByteArray*; typename T::BaseObjectType = _GByteArray] (struct BaseObjectType * ptr)
{
  struct ByteArray * iftmp.92;
  struct ObjectBase * D.103905;
  struct GObject * cobj;

  cobj = ptr;
  D.103905 = Glib::wrap_auto (cobj, 1);
  if (D.103905 == 0B) goto <D.103906>; else goto <D.103907>;
  <D.103906>:
  iftmp.92 = 0B;
  goto <D.103908>;
  <D.103907>:
  iftmp.92 = __dynamic_cast (D.103905, &_ZTIN4Glib10ObjectBaseE, &_ZTIN4Glib9ByteArrayE, -2);
  <D.103908>:
  Glib::RefPtr<Glib::ByteArray>::RefPtr (<retval>, iftmp.92);
  return <retval>;
}


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


_Tp* std::__addressof(_Tp&) [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct RefPtr & __r)
{
  struct RefPtr * D.103911;

  D.103911 = __r;
  return D.103911;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::RefPtr<Glib::ByteArray>; _T2 = Glib::RefPtr<Glib::ByteArray>] (struct RefPtr * __p, const struct RefPtr & __value)
{
  void * D.102855;
  void * D.102856;
  struct RefPtr * iftmp.93;

  D.102855 = __p;
  D.102856 = operator new (8, D.102855);
  if (D.102856 != 0B) goto <D.103914>; else goto <D.103915>;
  <D.103914>:
  try
    {
      Glib::RefPtr<Glib::ByteArray>::RefPtr (D.102856, __value);
    }
  catch
    {
      operator delete (D.102856, D.102855);
    }
  iftmp.93 = D.102856;
  goto <D.103916>;
  <D.103915>:
  iftmp.93 = D.102856;
  <D.103916>:
}


void* operator new(std::size_t, void*) (size_t D.14707, void * __p)
{
  void * D.103918;
  void * D.103919;

  try
    {
      D.103918 = __p;
      return D.103918;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103919 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103919);
          
        }
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Glib::ByteArray] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct ByteArray * D.103921;
  struct ByteArray * D.103922;

  D.103921 = src->pCppObject_;
  this->pCppObject_ = D.103921;
  D.103922 = this->pCppObject_;
  if (D.103922 != 0B) goto <D.103923>; else goto <D.103924>;
  <D.103923>:
  D.103922 = this->pCppObject_;
  Glib::ByteArray::reference (D.103922);
  goto <D.103925>;
  <D.103924>:
  <D.103925>:
}


void operator delete(void*, void*) (void * D.14715, void * D.14716)
{
  void * D.103926;

  try
    {

    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103926 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103926);
          
        }
    }
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Glib::ByteArray] (struct RefPtr * const this)
{
  struct ByteArray * D.103927;

  {
    try
      {
        D.103927 = this->pCppObject_;
        if (D.103927 != 0B) goto <D.103928>; else goto <D.103929>;
        <D.103928>:
        D.103927 = this->pCppObject_;
        Glib::ByteArray::unreference (D.103927);
        goto <D.103930>;
        <D.103929>:
        <D.103930>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101115>:
}


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = Glib::RefPtr<Glib::ByteArray>*] (struct RefPtr * __first, struct RefPtr * __last)
{
  typedef struct _Value_type _Value_type;

  std::_Destroy_aux<false>::__destroy<Glib::RefPtr<Glib::ByteArray>*> (__first, __last);
}


static void std::_Destroy_aux<<anonymous> >::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = Glib::RefPtr<Glib::ByteArray>*; bool <anonymous> = false] (struct RefPtr * __first, struct RefPtr * __last)
{
  struct RefPtr * D.103932;

  goto <D.102671>;
  <D.102670>:
  D.103932 = std::__addressof<Glib::RefPtr<Glib::ByteArray> > (__first);
  std::_Destroy<Glib::RefPtr<Glib::ByteArray> > (D.103932);
  __first = __first + 8;
  <D.102671>:
  if (__first != __last) goto <D.102670>; else goto <D.102668>;
  <D.102668>:
}


void std::_Destroy(_Tp*) [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct RefPtr * __pointer)
{
  Glib::RefPtr<Glib::ByteArray>::~RefPtr (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >] (struct _Vector_base * const this)
{
  struct RefPtr * D.103933;
  long int D.103934;
  struct RefPtr * D.103935;
  long int D.103936;
  long int D.103937;
  long int D.103938;
  long unsigned int D.103939;
  struct _Vector_impl * D.103940;

  {
    try
      {
        try
          {
            D.103933 = this->_M_impl._M_end_of_storage;
            D.103934 = (long int) D.103933;
            D.103935 = this->_M_impl._M_start;
            D.103936 = (long int) D.103935;
            D.103937 = D.103934 - D.103936;
            D.103938 = D.103937 /[ex] 8;
            D.103939 = (long unsigned int) D.103938;
            D.103935 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_M_deallocate (this, D.103935, D.103939);
          }
        finally
          {
            D.103940 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_Vector_impl::~_Vector_impl (D.103940);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101979>:
}


void std::_Vector_base<_Tp, _Alloc>::_M_deallocate(std::_Vector_base<_Tp, _Alloc>::pointer, std::size_t) [with _Tp = Glib::RefPtr<Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::pointer = Glib::RefPtr<Glib::ByteArray>*; std::size_t = long unsigned int] (struct _Vector_base * const this, struct RefPtr * __p, size_t __n)
{
  struct _Vector_impl * D.103945;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.103943>; else goto <D.103944>;
  <D.103943>:
  D.103945 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Glib::ByteArray> > >::deallocate (D.103945, __p, __n);
  goto <D.103946>;
  <D.103944>:
  <D.103946>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<Glib::ByteArray> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<Glib::ByteArray>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct RefPtr * __p, size_type __n)
{
  __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::deallocate (__a, __p, __n);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = Glib::RefPtr<Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Glib::ByteArray>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct RefPtr * __p, size_type D.99022)
{
  operator delete (__p);
}


std::_Vector_base<Glib::RefPtr<Glib::ByteArray>, std::allocator<Glib::RefPtr<Glib::ByteArray> > >::_Vector_impl::~_Vector_impl() (struct _Vector_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<Glib::RefPtr<Glib::ByteArray> >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101974>:
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct allocator * const this)
{
  void * D.103947;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<Glib::RefPtr<Glib::ByteArray> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.101904>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103947 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103947);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = Glib::RefPtr<Glib::ByteArray>] (struct new_allocator * const this)
{
  void * D.103948;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.102368>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103948 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103948);
          
        }
    }
}


Glib::Container_Helpers::GListKeeper<Tr>::~GListKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >] (struct GListKeeper * const this)
{
  struct GList * D.103949;
  OwnershipType D.103952;
  void * D.103957;

  {
    try
      {
        {
          typedef struct BaseObjectType * CTypeNonConst;

          {
            D.103949 = this->glist_;
            if (D.103949 != 0B) goto <D.103950>; else goto <D.103951>;
            <D.103950>:
            D.103952 = this->ownership_;
            if (D.103952 != 0) goto <D.103953>; else goto <D.103954>;
            <D.103953>:
            {
              {
                D.103952 = this->ownership_;
                if (D.103952 != 1) goto <D.103955>; else goto <D.103956>;
                <D.103955>:
                {
                  {
                    struct GList * node;

                    node = this->glist_;
                    goto <D.101888>;
                    <D.101889>:
                    D.103957 = node->data;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Glib::ByteArray> >::release_c_type (D.103957);
                    node = node->next;
                    <D.101888>:
                    if (node != 0B) goto <D.101889>; else goto <D.101890>;
                    <D.101890>:
                  }
                }
                goto <D.103958>;
                <D.103956>:
                <D.103958>:
              }
              D.103949 = this->glist_;
              g_list_free (D.103949);
            }
            goto <D.103959>;
            <D.103954>:
            <D.103959>:
            <D.103951>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101891>:
}


static void Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::release_c_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType) [with T = Glib::ByteArray; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType = _GByteArray*; typename T::BaseObjectType = _GByteArray] (struct BaseObjectType * ptr)
{
  g_object_unref (ptr);
}


std::vector<Glib::RefPtr<const Glib::ByteArray> > Gio::TlsClientConnection::get_accepted_cas() const (const struct TlsClientConnection * const this)
{
  const struct GTlsClientConnection * D.103962;
  struct GList * D.103963;

  D.103962 = Gio::TlsClientConnection::gobj (this);
  D.103963 = g_tls_client_connection_get_accepted_cas (D.103962);
  *<retval> = Glib::ListHandler<Glib::RefPtr<const Glib::ByteArray> >::list_to_vector (D.103963, 2); [return slot optimization]
  return <retval>;
}


static Glib::ListHandler<T, Tr>::VectorType Glib::ListHandler<T, Tr>::list_to_vector(GList*, Glib::OwnershipType) [with T = Glib::RefPtr<const Glib::ByteArray>; Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >; Glib::ListHandler<T, Tr>::VectorType = std::vector<Glib::RefPtr<const Glib::ByteArray> >; GList = _GList] (struct GList * glist, OwnershipType ownership)
{
  struct allocator_type D.101570;
  struct ListIteratorType D.101553;
  struct ListIteratorType D.101552;
  struct GListKeeperType keeper;

  try
    {
      Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::GListKeeper (&keeper, glist, ownership);
      try
        {
          std::allocator<Glib::RefPtr<const Glib::ByteArray> >::allocator (&D.101570);
          try
            {
              Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::ListIterator (&D.101553, 0B);
              try
                {
                  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::ListIterator (&D.101552, glist);
                  try
                    {
                      std::vector<Glib::RefPtr<const Glib::ByteArray> >::vector<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (<retval>, D.101552, D.101553, &D.101570);
                      return <retval>;
                    }
                  finally
                    {
                      D.101552 = {CLOBBER};
                    }
                }
              finally
                {
                  D.101553 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<Glib::RefPtr<const Glib::ByteArray> >::~allocator (&D.101570);
              D.101570 = {CLOBBER};
            }
        }
      finally
        {
          Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::~GListKeeper (&keeper);
        }
    }
  finally
    {
      keeper = {CLOBBER};
    }
}


Glib::Container_Helpers::GListKeeper<Tr>::GListKeeper(const GList*, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >; GList = _GList] (struct GListKeeper * const this, const struct GList * glist, OwnershipType ownership)
{
  this->glist_ = glist;
  this->ownership_ = ownership;
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct allocator * const this)
{
  void * D.103978;

  try
    {
      {
        __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103978 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103978);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct new_allocator * const this)
{
  void * D.103979;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103979 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103979);
          
        }
    }
}


Glib::Container_Helpers::ListIterator<Tr>::ListIterator(const GList*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >; GList = _GList] (struct ListIterator * const this, const struct GList * node)
{
  this->node_ = node;
}


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.103980;
  struct _Integral D.102069;
  struct __false_type D.103981;

  D.103980 = &this->D.100482;
  std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_Vector_base (D.103980, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<Glib::RefPtr<const Glib::ByteArray> >::_M_initialize_dispatch<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (this, __first, __last, D.103981);
          }
        finally
          {
            D.102069 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.103980 = &this->D.100482;
      std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::~_Vector_base (D.103980);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base(const allocator_type&) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct _Vector_base * const this, const struct allocator_type & __a)
{
  struct _Vector_impl * D.103984;

  D.103984 = &this->_M_impl;
  std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_Vector_impl::_Vector_impl (D.103984, __a);
  try
    {

    }
  catch
    {
      D.103984 = &this->_M_impl;
      std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_Vector_impl::~_Vector_impl (D.103984);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl(const _Tp_alloc_type&) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct _Vector_impl * const this, const struct _Tp_alloc_type & __a)
{
  std::allocator<Glib::RefPtr<const Glib::ByteArray> >::allocator (this, __a);
  try
    {
      this->_M_start = 0B;
      this->_M_finish = 0B;
      this->_M_end_of_storage = 0B;
    }
  catch
    {
      std::allocator<Glib::RefPtr<const Glib::ByteArray> >::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator< <template-parameter-1-1> >&) [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct allocator * const this, const struct allocator & __a)
{
  void * D.103985;

  try
    {
      {
        __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103985 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103985);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct new_allocator * const this, const struct new_allocator & D.99822)
{
  void * D.103986;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.103986 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.103986);
          
        }
    }
}


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct __false_type D.102053)
{
  struct _IterCategory D.102516;
  struct forward_iterator_tag D.103987;
  typedef struct _IterCategory _IterCategory;

  try
    {
      std::vector<Glib::RefPtr<const Glib::ByteArray> >::_M_range_initialize<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (this, __first, __last, D.103987);
    }
  finally
    {
      D.102516 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct forward_iterator_tag D.102521)
{
  long int D.103989;
  struct _Vector_base * D.103990;
  struct RefPtr * D.103991;
  struct RefPtr * D.103992;
  long unsigned int D.103993;
  struct RefPtr * D.103994;
  struct _Tp_alloc_type & D.103995;
  struct RefPtr * D.103996;
  const size_type __n;

  D.103989 = std::distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (__first, __last);
  __n = (const size_type) D.103989;
  D.103990 = &this->D.100482;
  D.103991 = std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_M_allocate (D.103990, __n);
  this->D.100482._M_impl._M_start = D.103991;
  D.103992 = this->D.100482._M_impl._M_start;
  D.103993 = __n * 8;
  D.103994 = D.103992 + D.103993;
  this->D.100482._M_impl._M_end_of_storage = D.103994;
  D.103990 = &this->D.100482;
  D.103995 = std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_M_get_Tp_allocator (D.103990);
  D.103992 = this->D.100482._M_impl._M_start;
  D.103996 = std::__uninitialized_copy_a<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >, Glib::RefPtr<const Glib::ByteArray>*, Glib::RefPtr<const Glib::ByteArray> > (__first, __last, D.103992, D.103995);
  this->D.100482._M_impl._M_finish = D.103996;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last)
{
  difference_type D.104000;
  struct input_iterator_tag D.102867;
  struct iterator_category D.102860;
  struct iterator_category * D.104001;
  struct input_iterator_tag D.104002;

  std::__iterator_category<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (&__first);
  try
    {
      D.104001 = &D.102860;
      D.104000 = std::__distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > > > (__first, __last, D.104002);
      return D.104000;
    }
  finally
    {
      D.102860 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::iterator_category = std::forward_iterator_tag] (const struct ListIterator & D.102859)
{
  struct iterator_category D.104007;

  return D.104007;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_InputIterator, _InputIterator, std::input_iterator_tag) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last, struct input_iterator_tag D.102864)
{
  bool retval.94;
  difference_type D.104010;
  difference_type __n;

  __n = 0;
  goto <D.102921>;
  <D.102922>:
  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::operator++ (&__first);
  __n = __n + 1;
  <D.102921>:
  retval.94 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::operator!= (&__first, &__last);
  if (retval.94 != 0) goto <D.102922>; else goto <D.102920>;
  <D.102920>:
  D.104010 = __n;
  return D.104010;
}


Glib::Container_Helpers::ListIterator<Tr>& Glib::Container_Helpers::ListIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >] (struct ListIterator * const this)
{
  const struct GList * D.104012;
  struct GList * D.104013;
  struct ListIterator & D.104014;

  D.104012 = this->node_;
  D.104013 = D.104012->next;
  this->node_ = D.104013;
  D.104014 = this;
  return D.104014;
}


bool Glib::Container_Helpers::ListIterator<Tr>::operator!=(const Glib::Container_Helpers::ListIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >] (const struct ListIterator * const this, const struct ListIterator & rhs)
{
  bool D.104016;
  const struct GList * D.104017;
  const struct GList * D.104018;

  D.104017 = this->node_;
  D.104018 = rhs->node_;
  D.104016 = D.104017 != D.104018;
  return D.104016;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::pointer = Glib::RefPtr<const Glib::ByteArray>*; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct RefPtr * D.104020;
  struct RefPtr * iftmp.95;
  struct _Vector_impl * D.104024;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.104022>; else goto <D.104023>;
  <D.104022>:
  D.104024 = &this->_M_impl;
  iftmp.95 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::allocate (D.104024, __n);
  goto <D.104025>;
  <D.104023>:
  iftmp.95 = 0B;
  <D.104025>:
  D.104020 = iftmp.95;
  return D.104020;
}


static __gnu_cxx::__alloc_traits<_Alloc>::pointer __gnu_cxx::__alloc_traits<_Alloc>::allocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<const Glib::ByteArray>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct RefPtr * D.104028;

  D.104028 = __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::allocate (__a, __n, 0B);
  return D.104028;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<const Glib::ByteArray>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.99795)
{
  bool retval.96;
  long unsigned int D.104032;
  struct RefPtr * D.104035;
  long unsigned int D.104036;

  D.104032 = __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::max_size (this);
  retval.96 = D.104032 < __n;
  if (retval.96 != 0) goto <D.104033>; else goto <D.104034>;
  <D.104033>:
  std::__throw_bad_alloc ();
  <D.104034>:
  D.104036 = __n * 8;
  D.104035 = operator new (D.104036);
  return D.104035;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = Glib::RefPtr<const Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.104039;
  void * D.104040;

  try
    {
      D.104039 = 2305843009213693951;
      return D.104039;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.104040 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.104040);
          
        }
    }
}


std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct _Vector_base * const this)
{
  struct _Tp_alloc_type & D.104042;

  D.104042 = &this->_M_impl;
  return D.104042;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<const Glib::ByteArray>*; _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result, struct allocator & D.102721)
{
  struct RefPtr * D.104044;

  D.104044 = std::uninitialized_copy<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >, Glib::RefPtr<const Glib::ByteArray>*> (__first, __last, __result);
  return D.104044;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<const Glib::ByteArray>*] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct RefPtr * D.104047;
  typedef struct _ValueType1 _ValueType1;
  typedef struct _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.104047 = std::__uninitialized_copy<false>::__uninit_copy<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >, Glib::RefPtr<const Glib::ByteArray>*> (__first, __last, __result);
  return D.104047;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >; _ForwardIterator = Glib::RefPtr<const Glib::ByteArray>*; bool _TrivialValueTypes = false] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct value_type D.102965;
  struct RefPtr * D.104050;
  bool retval.97;
  struct RefPtr * D.104052;
  void * D.104053;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.102969>;
      <D.102968>:
      D.102965 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.104050 = std::__addressof<Glib::RefPtr<const Glib::ByteArray> > (__cur);
          std::_Construct<Glib::RefPtr<const Glib::ByteArray>, Glib::RefPtr<const Glib::ByteArray> > (D.104050, &D.102965);
        }
      finally
        {
          Glib::RefPtr<const Glib::ByteArray>::~RefPtr (&D.102965);
          D.102965 = {CLOBBER};
        }
      Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.102969>:
      retval.97 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> > >::operator!= (&__first, &__last);
      if (retval.97 != 0) goto <D.102968>; else goto <D.102966>;
      <D.102966>:
      D.104052 = __cur;
      return D.104052;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.104053 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.104053);
              std::_Destroy<Glib::RefPtr<const Glib::ByteArray>*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::Container_Helpers::ListIterator<Tr>::value_type Glib::Container_Helpers::ListIterator<Tr>::operator*() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >; Glib::Container_Helpers::ListIterator<Tr>::value_type = Glib::RefPtr<const Glib::ByteArray>] (const struct ListIterator * const this)
{
  const struct GList * D.104060;
  void * D.104061;

  D.104060 = this->node_;
  D.104061 = D.104060->data;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >::to_cpp_type (D.104061); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CppType Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::to_cpp_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType) [with T = Glib::ByteArray; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CppType = Glib::RefPtr<const Glib::ByteArray>; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType = const _GByteArray*; typename T::BaseObjectType = _GByteArray] (const struct BaseObjectType * ptr)
{
  const struct ByteArray * iftmp.98;
  struct ObjectBase * D.104065;
  struct GObject * cobj;

  cobj = ptr;
  D.104065 = Glib::wrap_auto (cobj, 1);
  if (D.104065 == 0B) goto <D.104066>; else goto <D.104067>;
  <D.104066>:
  iftmp.98 = 0B;
  goto <D.104068>;
  <D.104067>:
  iftmp.98 = __dynamic_cast (D.104065, &_ZTIN4Glib10ObjectBaseE, &_ZTIN4Glib9ByteArrayE, -2);
  <D.104068>:
  Glib::RefPtr<const Glib::ByteArray>::RefPtr (<retval>, iftmp.98);
  return <retval>;
}


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


_Tp* std::__addressof(_Tp&) [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct RefPtr & __r)
{
  struct RefPtr * D.104071;

  D.104071 = __r;
  return D.104071;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::RefPtr<const Glib::ByteArray>; _T2 = Glib::RefPtr<const Glib::ByteArray>] (struct RefPtr * __p, const struct RefPtr & __value)
{
  void * D.102886;
  void * D.102887;
  struct RefPtr * iftmp.99;

  D.102886 = __p;
  D.102887 = operator new (8, D.102886);
  if (D.102887 != 0B) goto <D.104074>; else goto <D.104075>;
  <D.104074>:
  try
    {
      Glib::RefPtr<const Glib::ByteArray>::RefPtr (D.102887, __value);
    }
  catch
    {
      operator delete (D.102887, D.102886);
    }
  iftmp.99 = D.102887;
  goto <D.104076>;
  <D.104075>:
  iftmp.99 = D.102887;
  <D.104076>:
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = const Glib::ByteArray] (struct RefPtr * const this, const struct RefPtr & src)
{
  const struct ByteArray * D.104078;
  const struct ByteArray * D.104079;

  D.104078 = src->pCppObject_;
  this->pCppObject_ = D.104078;
  D.104079 = this->pCppObject_;
  if (D.104079 != 0B) goto <D.104080>; else goto <D.104081>;
  <D.104080>:
  D.104079 = this->pCppObject_;
  Glib::ByteArray::reference (D.104079);
  goto <D.104082>;
  <D.104081>:
  <D.104082>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Glib::ByteArray] (struct RefPtr * const this)
{
  const struct ByteArray * D.104083;

  {
    try
      {
        D.104083 = this->pCppObject_;
        if (D.104083 != 0B) goto <D.104084>; else goto <D.104085>;
        <D.104084>:
        D.104083 = this->pCppObject_;
        Glib::ByteArray::unreference (D.104083);
        goto <D.104086>;
        <D.104085>:
        <D.104086>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102937>:
}


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = Glib::RefPtr<const Glib::ByteArray>*] (struct RefPtr * __first, struct RefPtr * __last)
{
  typedef struct _Value_type _Value_type;

  std::_Destroy_aux<false>::__destroy<Glib::RefPtr<const Glib::ByteArray>*> (__first, __last);
}


static void std::_Destroy_aux<<anonymous> >::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = Glib::RefPtr<const Glib::ByteArray>*; bool <anonymous> = false] (struct RefPtr * __first, struct RefPtr * __last)
{
  struct RefPtr * D.104088;

  goto <D.102741>;
  <D.102740>:
  D.104088 = std::__addressof<Glib::RefPtr<const Glib::ByteArray> > (__first);
  std::_Destroy<Glib::RefPtr<const Glib::ByteArray> > (D.104088);
  __first = __first + 8;
  <D.102741>:
  if (__first != __last) goto <D.102740>; else goto <D.102738>;
  <D.102738>:
}


void std::_Destroy(_Tp*) [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct RefPtr * __pointer)
{
  Glib::RefPtr<const Glib::ByteArray>::~RefPtr (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >] (struct _Vector_base * const this)
{
  struct RefPtr * D.104089;
  long int D.104090;
  struct RefPtr * D.104091;
  long int D.104092;
  long int D.104093;
  long int D.104094;
  long unsigned int D.104095;
  struct _Vector_impl * D.104096;

  {
    try
      {
        try
          {
            D.104089 = this->_M_impl._M_end_of_storage;
            D.104090 = (long int) D.104089;
            D.104091 = this->_M_impl._M_start;
            D.104092 = (long int) D.104091;
            D.104093 = D.104090 - D.104092;
            D.104094 = D.104093 /[ex] 8;
            D.104095 = (long unsigned int) D.104094;
            D.104091 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_M_deallocate (this, D.104091, D.104095);
          }
        finally
          {
            D.104096 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_Vector_impl::~_Vector_impl (D.104096);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102206>:
}


void std::_Vector_base<_Tp, _Alloc>::_M_deallocate(std::_Vector_base<_Tp, _Alloc>::pointer, std::size_t) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; std::_Vector_base<_Tp, _Alloc>::pointer = Glib::RefPtr<const Glib::ByteArray>*; std::size_t = long unsigned int] (struct _Vector_base * const this, struct RefPtr * __p, size_t __n)
{
  struct _Vector_impl * D.104101;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.104099>; else goto <D.104100>;
  <D.104099>:
  D.104101 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::deallocate (D.104101, __p, __n);
  goto <D.104102>;
  <D.104100>:
  <D.104102>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<const Glib::ByteArray> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<const Glib::ByteArray>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct RefPtr * __p, size_type __n)
{
  __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::deallocate (__a, __p, __n);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = Glib::RefPtr<const Glib::ByteArray>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<const Glib::ByteArray>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct RefPtr * __p, size_type D.99799)
{
  operator delete (__p);
}


std::_Vector_base<Glib::RefPtr<const Glib::ByteArray>, std::allocator<Glib::RefPtr<const Glib::ByteArray> > >::_Vector_impl::~_Vector_impl() (struct _Vector_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<Glib::RefPtr<const Glib::ByteArray> >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102077>:
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct allocator * const this)
{
  void * D.104103;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<Glib::RefPtr<const Glib::ByteArray> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.102037>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.104103 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.104103);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = Glib::RefPtr<const Glib::ByteArray>] (struct new_allocator * const this)
{
  void * D.104104;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.102500>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.104104 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.104104);
          
        }
    }
}


Glib::Container_Helpers::GListKeeper<Tr>::~GListKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >] (struct GListKeeper * const this)
{
  struct GList * D.104105;
  OwnershipType D.104108;
  void * D.104113;

  {
    try
      {
        {
          typedef struct BaseObjectType * CTypeNonConst;

          {
            D.104105 = this->glist_;
            if (D.104105 != 0B) goto <D.104106>; else goto <D.104107>;
            <D.104106>:
            D.104108 = this->ownership_;
            if (D.104108 != 0) goto <D.104109>; else goto <D.104110>;
            <D.104109>:
            {
              {
                D.104108 = this->ownership_;
                if (D.104108 != 1) goto <D.104111>; else goto <D.104112>;
                <D.104111>:
                {
                  {
                    struct GList * node;

                    node = this->glist_;
                    goto <D.102021>;
                    <D.102022>:
                    D.104113 = node->data;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Glib::ByteArray> >::release_c_type (D.104113);
                    node = node->next;
                    <D.102021>:
                    if (node != 0B) goto <D.102022>; else goto <D.102023>;
                    <D.102023>:
                  }
                }
                goto <D.104114>;
                <D.104112>:
                <D.104114>:
              }
              D.104105 = this->glist_;
              g_list_free (D.104105);
            }
            goto <D.104115>;
            <D.104110>:
            <D.104115>:
            <D.104107>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102024>:
}


static void Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::release_c_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType) [with T = Glib::ByteArray; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType = const _GByteArray*; typename T::BaseObjectType = _GByteArray] (const struct BaseObjectType * ptr)
{
  g_object_unref (ptr);
}


Glib::PropertyProxy_ReadOnly<std::vector<Glib::RefPtr<Glib::ByteArray> > > Gio::TlsClientConnection::property_accepted_cas() const (const struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104118;
  int (*__vtbl_ptr_type) () * D.104119;
  long int D.104120;
  sizetype D.104121;
  const struct ObjectBase * D.104122;

  D.104118 = this->D.97992._vptr.Interface;
  D.104119 = D.104118 + 18446744073709551592;
  D.104120 = MEM[(long int *)D.104119];
  D.104121 = (sizetype) D.104120;
  D.104122 = this + D.104121;
  Glib::PropertyProxy_ReadOnly<std::vector<Glib::RefPtr<Glib::ByteArray> > >::PropertyProxy_ReadOnly (<retval>, D.104122, "accepted-cas");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = std::vector<Glib::RefPtr<Glib::ByteArray> >] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.104124;

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


Glib::PropertyProxy<Glib::RefPtr<Gio::SocketConnectable> > Gio::TlsClientConnection::property_server_identity() (struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104126;
  int (*__vtbl_ptr_type) () * D.104127;
  long int D.104128;
  sizetype D.104129;
  struct ObjectBase * D.104130;

  D.104126 = this->D.97992._vptr.Interface;
  D.104127 = D.104126 + 18446744073709551592;
  D.104128 = MEM[(long int *)D.104127];
  D.104129 = (sizetype) D.104128;
  D.104130 = this + D.104129;
  Glib::PropertyProxy<Glib::RefPtr<Gio::SocketConnectable> >::PropertyProxy (<retval>, D.104130, "server-identity");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketConnectable> > Gio::TlsClientConnection::property_server_identity() const (const struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104134;
  int (*__vtbl_ptr_type) () * D.104135;
  long int D.104136;
  sizetype D.104137;
  const struct ObjectBase * D.104138;

  D.104134 = this->D.97992._vptr.Interface;
  D.104135 = D.104134 + 18446744073709551592;
  D.104136 = MEM[(long int *)D.104135];
  D.104137 = (sizetype) D.104136;
  D.104138 = this + D.104137;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::SocketConnectable> >::PropertyProxy_ReadOnly (<retval>, D.104138, "server-identity");
  return <retval>;
}


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

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


Glib::PropertyProxy<bool> Gio::TlsClientConnection::property_use_ssl3() (struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104142;
  int (*__vtbl_ptr_type) () * D.104143;
  long int D.104144;
  sizetype D.104145;
  struct ObjectBase * D.104146;

  D.104142 = this->D.97992._vptr.Interface;
  D.104143 = D.104142 + 18446744073709551592;
  D.104144 = MEM[(long int *)D.104143];
  D.104145 = (sizetype) D.104144;
  D.104146 = this + D.104145;
  Glib::PropertyProxy<bool>::PropertyProxy (<retval>, D.104146, "use-ssl3");
  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.104148;

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


Glib::PropertyProxy_ReadOnly<bool> Gio::TlsClientConnection::property_use_ssl3() const (const struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104150;
  int (*__vtbl_ptr_type) () * D.104151;
  long int D.104152;
  sizetype D.104153;
  const struct ObjectBase * D.104154;

  D.104150 = this->D.97992._vptr.Interface;
  D.104151 = D.104150 + 18446744073709551592;
  D.104152 = MEM[(long int *)D.104151];
  D.104153 = (sizetype) D.104152;
  D.104154 = this + D.104153;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.104154, "use-ssl3");
  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.104156;

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


Glib::PropertyProxy<Gio::TlsCertificateFlags> Gio::TlsClientConnection::property_validation_flags() (struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104158;
  int (*__vtbl_ptr_type) () * D.104159;
  long int D.104160;
  sizetype D.104161;
  struct ObjectBase * D.104162;

  D.104158 = this->D.97992._vptr.Interface;
  D.104159 = D.104158 + 18446744073709551592;
  D.104160 = MEM[(long int *)D.104159];
  D.104161 = (sizetype) D.104160;
  D.104162 = this + D.104161;
  Glib::PropertyProxy<Gio::TlsCertificateFlags>::PropertyProxy (<retval>, D.104162, "validation-flags");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Gio::TlsCertificateFlags> Gio::TlsClientConnection::property_validation_flags() const (const struct TlsClientConnection * const this)
{
  int (*__vtbl_ptr_type) () * D.104166;
  int (*__vtbl_ptr_type) () * D.104167;
  long int D.104168;
  sizetype D.104169;
  const struct ObjectBase * D.104170;

  D.104166 = this->D.97992._vptr.Interface;
  D.104167 = D.104166 + 18446744073709551592;
  D.104168 = MEM[(long int *)D.104167];
  D.104169 = (sizetype) D.104168;
  D.104170 = this + D.104169;
  Glib::PropertyProxy_ReadOnly<Gio::TlsCertificateFlags>::PropertyProxy_ReadOnly (<retval>, D.104170, "validation-flags");
  return <retval>;
}


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

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