static Glib::RefPtr<Gio::TlsCertificate> Gio::TlsCertificate::create_from_pem(const string&, gssize) (const struct string & data, gssize length)
{
  void * D.97355;

  D.97355 = operator new (48);
  try
    {
      Gio::TlsCertificate::TlsCertificate (D.97355, data, length);
    }
  catch
    {
      operator delete (D.97355);
    }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, D.97355);
  return <retval>;
}


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


Glib::RefPtr<Gio::TlsCertificate> Glib::wrap(GTlsCertificate*, bool) (struct GTlsCertificate * object, bool take_copy)
{
  struct TlsCertificate * iftmp.0;
  int D.100282;
  struct ObjectBase * D.100283;

  D.100282 = (int) take_copy;
  D.100283 = Glib::wrap_auto (object, D.100282);
  if (D.100283 == 0B) goto <D.100284>; else goto <D.100285>;
  <D.100284>:
  iftmp.0 = 0B;
  goto <D.100286>;
  <D.100285>:
  iftmp.0 = __dynamic_cast (D.100283, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14TlsCertificateE, -1);
  <D.100286>:
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


const Glib::Class& Gio::TlsCertificate_Class::init() (struct TlsCertificate_Class * const this)
{
  long unsigned int D.100289;
  long unsigned int D.100292;
  struct Class * D.100293;
  const struct Class & D.100295;

  D.100289 = this->D.96715.gtype_;
  if (D.100289 == 0) goto <D.100290>; else goto <D.100291>;
  <D.100290>:
  this->D.96715.class_init_func_ = class_init_function;
  D.100292 = g_tls_certificate_get_type ();
  D.100293 = &this->D.96715;
  Glib::Class::register_derived_type (D.100293, D.100292);
  goto <D.100294>;
  <D.100291>:
  <D.100294>:
  D.100295 = &this->D.96715;
  return D.100295;
}


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

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
  klass->verify = verify_vfunc_callback;
}


static GTlsCertificateFlags Gio::TlsCertificate_Class::verify_vfunc_callback(GTlsCertificate*, GSocketConnectable*, GTlsCertificate*) (struct GTlsCertificate * self, struct GSocketConnectable * identity, struct GTlsCertificate * trusted_ca)
{
  bool retval.1;
  bool iftmp.2;
  bool D.100303;
  struct CppObjectType * const iftmp.3;
  GTlsCertificateFlags D.100313;
  int (*__vtbl_ptr_type) () * D.100314;
  int (*__vtbl_ptr_type) () * D.100315;
  int (*__vtbl_ptr_type) () D.100316;
  const struct RefPtr D.97783;
  struct RefPtr D.97515;
  const struct RefPtr D.97782;
  struct RefPtr D.97514;
  void * D.100317;
  struct GTypeClass * D.100320;
  GTlsCertificateFlags (*<T11166>) (struct GTlsCertificate *, struct GSocketConnectable *, struct GTlsCertificate *) D.100323;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.100302>; else goto <D.100300>;
    <D.100302>:
    D.100303 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.100303 != 0) goto <D.100304>; else goto <D.100300>;
    <D.100304>:
    iftmp.2 = 1;
    goto <D.100301>;
    <D.100300>:
    iftmp.2 = 0;
    <D.100301>:
    retval.1 = iftmp.2;
    if (retval.1 != 0) goto <D.100305>; else goto <D.100306>;
    <D.100305>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.100308>; else goto <D.100309>;
      <D.100308>:
      iftmp.3 = 0B;
      goto <D.100310>;
      <D.100309>:
      iftmp.3 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14TlsCertificateE, -1);
      <D.100310>:
      obj = iftmp.3;
      if (obj != 0B) goto <D.100311>; else goto <D.100312>;
      <D.100311>:
      try
        {
          D.100314 = obj->D.96669._vptr.Object;
          D.100315 = D.100314 + 16;
          D.100316 = *D.100315;
          D.97515 = Glib::wrap (trusted_ca, 1); [return slot optimization]
          try
            {
              Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (&D.97783, &D.97515);
              try
                {
                  D.97514 = Glib::wrap (identity, 1); [return slot optimization]
                  try
                    {
                      Glib::RefPtr<const Gio::SocketConnectable>::RefPtr<Gio::SocketConnectable> (&D.97782, &D.97514);
                      try
                        {
                          D.100313 = OBJ_TYPE_REF(D.100316;(const struct TlsCertificate)obj->2) (obj, &D.97782, &D.97783);
                          return D.100313;
                        }
                      finally
                        {
                          Glib::RefPtr<const Gio::SocketConnectable>::~RefPtr (&D.97782);
                          D.97782 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (&D.97514);
                      D.97514 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<const Gio::TlsCertificate>::~RefPtr (&D.97783);
                  D.97783 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.97515);
              D.97515 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.100317 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.100317);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.100318>;
      <D.100312>:
      <D.100318>:
    }
    goto <D.100319>;
    <D.100306>:
    <D.100319>:
  }
  D.100320 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.100320);
  {
    if (base != 0B) goto <D.100321>; else goto <D.100322>;
    <D.100321>:
    D.100323 = base->verify;
    if (D.100323 != 0B) goto <D.100324>; else goto <D.100325>;
    <D.100324>:
    {
      GTlsCertificateFlags retval;

      D.100323 = base->verify;
      retval = D.100323 (self, identity, trusted_ca);
      D.100313 = retval;
      return D.100313;
    }
    <D.100325>:
    <D.100322>:
  }
  D.100313 = 0;
  return D.100313;
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::TlsCertificate; T_CppObject = const Gio::TlsCertificate] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct TlsCertificate * D.100343;
  const struct TlsCertificate * D.100344;
  int (*__vtbl_ptr_type) () * D.100347;
  int (*__vtbl_ptr_type) () * D.100348;
  long int D.100349;
  sizetype D.100350;
  const struct ObjectBase * D.100351;
  int (*__vtbl_ptr_type) () * D.100352;
  int (*__vtbl_ptr_type) () * D.100353;
  int (*__vtbl_ptr_type) () D.100354;

  D.100343 = Glib::RefPtr<Gio::TlsCertificate>::operator-> (src);
  this->pCppObject_ = D.100343;
  D.100344 = this->pCppObject_;
  if (D.100344 != 0B) goto <D.100345>; else goto <D.100346>;
  <D.100345>:
  D.100344 = this->pCppObject_;
  D.100344 = this->pCppObject_;
  D.100347 = D.100344->D.96669._vptr.Object;
  D.100348 = D.100347 + 18446744073709551592;
  D.100349 = MEM[(long int *)D.100348];
  D.100350 = (sizetype) D.100349;
  D.100351 = D.100344 + D.100350;
  D.100344 = this->pCppObject_;
  D.100344 = this->pCppObject_;
  D.100347 = D.100344->D.96669._vptr.Object;
  D.100348 = D.100347 + 18446744073709551592;
  D.100349 = MEM[(long int *)D.100348];
  D.100350 = (sizetype) D.100349;
  D.100351 = D.100344 + D.100350;
  D.100352 = D.100351->_vptr.ObjectBase;
  D.100353 = D.100352 + 16;
  D.100354 = *D.100353;
  D.100344 = this->pCppObject_;
  D.100344 = this->pCppObject_;
  D.100347 = D.100344->D.96669._vptr.Object;
  D.100348 = D.100347 + 18446744073709551592;
  D.100349 = MEM[(long int *)D.100348];
  D.100350 = (sizetype) D.100349;
  D.100351 = D.100344 + D.100350;
  OBJ_TYPE_REF(D.100354;(const struct ObjectBase)D.100351->2) (D.100351);
  goto <D.100355>;
  <D.100346>:
  <D.100355>:
}


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

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


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.100358;
  const struct SocketConnectable * D.100359;
  int (*__vtbl_ptr_type) () * D.100362;
  int (*__vtbl_ptr_type) () * D.100363;
  long int D.100364;
  sizetype D.100365;
  const struct ObjectBase * D.100366;
  int (*__vtbl_ptr_type) () * D.100367;
  int (*__vtbl_ptr_type) () * D.100368;
  int (*__vtbl_ptr_type) () D.100369;

  D.100358 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (src);
  this->pCppObject_ = D.100358;
  D.100359 = this->pCppObject_;
  if (D.100359 != 0B) goto <D.100360>; else goto <D.100361>;
  <D.100360>:
  D.100359 = this->pCppObject_;
  D.100359 = this->pCppObject_;
  D.100362 = D.100359->D.97209._vptr.Interface;
  D.100363 = D.100362 + 18446744073709551592;
  D.100364 = MEM[(long int *)D.100363];
  D.100365 = (sizetype) D.100364;
  D.100366 = D.100359 + D.100365;
  D.100359 = this->pCppObject_;
  D.100359 = this->pCppObject_;
  D.100362 = D.100359->D.97209._vptr.Interface;
  D.100363 = D.100362 + 18446744073709551592;
  D.100364 = MEM[(long int *)D.100363];
  D.100365 = (sizetype) D.100364;
  D.100366 = D.100359 + D.100365;
  D.100367 = D.100366->_vptr.ObjectBase;
  D.100368 = D.100367 + 16;
  D.100369 = *D.100368;
  D.100359 = this->pCppObject_;
  D.100359 = this->pCppObject_;
  D.100362 = D.100359->D.97209._vptr.Interface;
  D.100363 = D.100362 + 18446744073709551592;
  D.100364 = MEM[(long int *)D.100363];
  D.100365 = (sizetype) D.100364;
  D.100366 = D.100359 + D.100365;
  OBJ_TYPE_REF(D.100369;(const struct ObjectBase)D.100366->2) (D.100366);
  goto <D.100370>;
  <D.100361>:
  <D.100370>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Gio::SocketConnectable] (struct RefPtr * const this)
{
  const struct SocketConnectable * D.100373;
  int (*__vtbl_ptr_type) () * D.100376;
  int (*__vtbl_ptr_type) () * D.100377;
  long int D.100378;
  sizetype D.100379;
  const struct ObjectBase * D.100380;
  int (*__vtbl_ptr_type) () * D.100381;
  int (*__vtbl_ptr_type) () * D.100382;
  int (*__vtbl_ptr_type) () D.100383;

  {
    try
      {
        D.100373 = this->pCppObject_;
        if (D.100373 != 0B) goto <D.100374>; else goto <D.100375>;
        <D.100374>:
        D.100373 = this->pCppObject_;
        D.100373 = this->pCppObject_;
        D.100376 = D.100373->D.97209._vptr.Interface;
        D.100377 = D.100376 + 18446744073709551592;
        D.100378 = MEM[(long int *)D.100377];
        D.100379 = (sizetype) D.100378;
        D.100380 = D.100373 + D.100379;
        D.100373 = this->pCppObject_;
        D.100373 = this->pCppObject_;
        D.100376 = D.100373->D.97209._vptr.Interface;
        D.100377 = D.100376 + 18446744073709551592;
        D.100378 = MEM[(long int *)D.100377];
        D.100379 = (sizetype) D.100378;
        D.100380 = D.100373 + D.100379;
        D.100381 = D.100380->_vptr.ObjectBase;
        D.100382 = D.100381 + 24;
        D.100383 = *D.100382;
        D.100373 = this->pCppObject_;
        D.100373 = this->pCppObject_;
        D.100376 = D.100373->D.97209._vptr.Interface;
        D.100377 = D.100376 + 18446744073709551592;
        D.100378 = MEM[(long int *)D.100377];
        D.100379 = (sizetype) D.100378;
        D.100380 = D.100373 + D.100379;
        OBJ_TYPE_REF(D.100383;(const struct ObjectBase)D.100380->3) (D.100380);
        goto <D.100384>;
        <D.100375>:
        <D.100384>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99209>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnectable] (struct RefPtr * const this)
{
  struct SocketConnectable * D.100386;
  int (*__vtbl_ptr_type) () * D.100389;
  int (*__vtbl_ptr_type) () * D.100390;
  long int D.100391;
  sizetype D.100392;
  struct ObjectBase * D.100393;
  int (*__vtbl_ptr_type) () * D.100394;
  int (*__vtbl_ptr_type) () * D.100395;
  int (*__vtbl_ptr_type) () D.100396;

  {
    try
      {
        D.100386 = this->pCppObject_;
        if (D.100386 != 0B) goto <D.100387>; else goto <D.100388>;
        <D.100387>:
        D.100386 = this->pCppObject_;
        D.100386 = this->pCppObject_;
        D.100389 = D.100386->D.97209._vptr.Interface;
        D.100390 = D.100389 + 18446744073709551592;
        D.100391 = MEM[(long int *)D.100390];
        D.100392 = (sizetype) D.100391;
        D.100393 = D.100386 + D.100392;
        D.100386 = this->pCppObject_;
        D.100386 = this->pCppObject_;
        D.100389 = D.100386->D.97209._vptr.Interface;
        D.100390 = D.100389 + 18446744073709551592;
        D.100391 = MEM[(long int *)D.100390];
        D.100392 = (sizetype) D.100391;
        D.100393 = D.100386 + D.100392;
        D.100394 = D.100393->_vptr.ObjectBase;
        D.100395 = D.100394 + 24;
        D.100396 = *D.100395;
        D.100386 = this->pCppObject_;
        D.100386 = this->pCppObject_;
        D.100389 = D.100386->D.97209._vptr.Interface;
        D.100390 = D.100389 + 18446744073709551592;
        D.100391 = MEM[(long int *)D.100390];
        D.100392 = (sizetype) D.100391;
        D.100393 = D.100386 + D.100392;
        OBJ_TYPE_REF(D.100396;(const struct ObjectBase)D.100393->3) (D.100393);
        goto <D.100397>;
        <D.100388>:
        <D.100397>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99192>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Gio::TlsCertificate] (struct RefPtr * const this)
{
  const struct TlsCertificate * D.100399;
  int (*__vtbl_ptr_type) () * D.100402;
  int (*__vtbl_ptr_type) () * D.100403;
  long int D.100404;
  sizetype D.100405;
  const struct ObjectBase * D.100406;
  int (*__vtbl_ptr_type) () * D.100407;
  int (*__vtbl_ptr_type) () * D.100408;
  int (*__vtbl_ptr_type) () D.100409;

  {
    try
      {
        D.100399 = this->pCppObject_;
        if (D.100399 != 0B) goto <D.100400>; else goto <D.100401>;
        <D.100400>:
        D.100399 = this->pCppObject_;
        D.100399 = this->pCppObject_;
        D.100402 = D.100399->D.96669._vptr.Object;
        D.100403 = D.100402 + 18446744073709551592;
        D.100404 = MEM[(long int *)D.100403];
        D.100405 = (sizetype) D.100404;
        D.100406 = D.100399 + D.100405;
        D.100399 = this->pCppObject_;
        D.100399 = this->pCppObject_;
        D.100402 = D.100399->D.96669._vptr.Object;
        D.100403 = D.100402 + 18446744073709551592;
        D.100404 = MEM[(long int *)D.100403];
        D.100405 = (sizetype) D.100404;
        D.100406 = D.100399 + D.100405;
        D.100407 = D.100406->_vptr.ObjectBase;
        D.100408 = D.100407 + 24;
        D.100409 = *D.100408;
        D.100399 = this->pCppObject_;
        D.100399 = this->pCppObject_;
        D.100402 = D.100399->D.96669._vptr.Object;
        D.100403 = D.100402 + 18446744073709551592;
        D.100404 = MEM[(long int *)D.100403];
        D.100405 = (sizetype) D.100404;
        D.100406 = D.100399 + D.100405;
        OBJ_TYPE_REF(D.100409;(const struct ObjectBase)D.100406->3) (D.100406);
        goto <D.100410>;
        <D.100401>:
        <D.100410>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99225>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::TlsCertificate] (struct RefPtr * const this)
{
  struct TlsCertificate * D.100412;
  int (*__vtbl_ptr_type) () * D.100415;
  int (*__vtbl_ptr_type) () * D.100416;
  long int D.100417;
  sizetype D.100418;
  struct ObjectBase * D.100419;
  int (*__vtbl_ptr_type) () * D.100420;
  int (*__vtbl_ptr_type) () * D.100421;
  int (*__vtbl_ptr_type) () D.100422;

  {
    try
      {
        D.100412 = this->pCppObject_;
        if (D.100412 != 0B) goto <D.100413>; else goto <D.100414>;
        <D.100413>:
        D.100412 = this->pCppObject_;
        D.100412 = this->pCppObject_;
        D.100415 = D.100412->D.96669._vptr.Object;
        D.100416 = D.100415 + 18446744073709551592;
        D.100417 = MEM[(long int *)D.100416];
        D.100418 = (sizetype) D.100417;
        D.100419 = D.100412 + D.100418;
        D.100412 = this->pCppObject_;
        D.100412 = this->pCppObject_;
        D.100415 = D.100412->D.96669._vptr.Object;
        D.100416 = D.100415 + 18446744073709551592;
        D.100417 = MEM[(long int *)D.100416];
        D.100418 = (sizetype) D.100417;
        D.100419 = D.100412 + D.100418;
        D.100420 = D.100419->_vptr.ObjectBase;
        D.100421 = D.100420 + 24;
        D.100422 = *D.100421;
        D.100412 = this->pCppObject_;
        D.100412 = this->pCppObject_;
        D.100415 = D.100412->D.96669._vptr.Object;
        D.100416 = D.100415 + 18446744073709551592;
        D.100417 = MEM[(long int *)D.100416];
        D.100418 = (sizetype) D.100417;
        D.100419 = D.100412 + D.100418;
        OBJ_TYPE_REF(D.100422;(const struct ObjectBase)D.100419->3) (D.100419);
        goto <D.100423>;
        <D.100414>:
        <D.100423>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99182>:
}


static Glib::ObjectBase* Gio::TlsCertificate_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.100425;
  struct ObjectBase * iftmp.4;
  void * D.97791;
  void * D.100427;
  int (*__vtbl_ptr_type) () * D.100430;
  int (*__vtbl_ptr_type) () * D.100431;
  long int D.100432;
  sizetype D.100433;

  D.97791 = operator new (48);
  try
    {
      Gio::TlsCertificate::TlsCertificate (D.97791, object);
    }
  catch
    {
      operator delete (D.97791);
    }
  D.100427 = D.97791;
  if (D.100427 != 0B) goto <D.100428>; else goto <D.100429>;
  <D.100428>:
  D.100430 = MEM[(struct TlsCertificate *)D.100427].D.96669._vptr.Object;
  D.100431 = D.100430 + 18446744073709551592;
  D.100432 = MEM[(long int *)D.100431];
  D.100433 = (sizetype) D.100432;
  iftmp.4 = D.100427 + D.100433;
  goto <D.100434>;
  <D.100429>:
  iftmp.4 = 0B;
  <D.100434>:
  D.100425 = iftmp.4;
  return D.100425;
}


GTlsCertificate* Gio::TlsCertificate::gobj_copy() (struct TlsCertificate * const this)
{
  int (*__vtbl_ptr_type) () * D.100438;
  int (*__vtbl_ptr_type) () * D.100439;
  long int D.100440;
  sizetype D.100441;
  struct ObjectBase * D.100442;
  int (*__vtbl_ptr_type) () * D.100443;
  int (*__vtbl_ptr_type) () * D.100444;
  int (*__vtbl_ptr_type) () D.100445;
  struct GTlsCertificate * D.100446;

  D.100438 = this->D.96669._vptr.Object;
  D.100439 = D.100438 + 18446744073709551592;
  D.100440 = MEM[(long int *)D.100439];
  D.100441 = (sizetype) D.100440;
  D.100442 = this + D.100441;
  D.100438 = this->D.96669._vptr.Object;
  D.100439 = D.100438 + 18446744073709551592;
  D.100440 = MEM[(long int *)D.100439];
  D.100441 = (sizetype) D.100440;
  D.100442 = this + D.100441;
  D.100443 = D.100442->_vptr.ObjectBase;
  D.100444 = D.100443 + 16;
  D.100445 = *D.100444;
  D.100438 = this->D.96669._vptr.Object;
  D.100439 = D.100438 + 18446744073709551592;
  D.100440 = MEM[(long int *)D.100439];
  D.100441 = (sizetype) D.100440;
  D.100442 = this + D.100441;
  OBJ_TYPE_REF(D.100445;(const struct ObjectBase)D.100442->2) (D.100442);
  D.100446 = Gio::TlsCertificate::gobj (this);
  return D.100446;
}


GTlsCertificate* Gio::TlsCertificate::gobj() (struct TlsCertificate * const this)
{
  struct GTlsCertificate * D.100448;
  int (*__vtbl_ptr_type) () * D.100449;
  int (*__vtbl_ptr_type) () * D.100450;
  long int D.100451;
  sizetype D.100452;
  struct ObjectBase * D.100453;

  D.100449 = this->D.96669._vptr.Object;
  D.100450 = D.100449 + 18446744073709551592;
  D.100451 = MEM[(long int *)D.100450];
  D.100452 = (sizetype) D.100451;
  D.100453 = this + D.100452;
  D.100448 = D.100453->gobject_;
  return D.100448;
}


Gio::TlsCertificate::TlsCertificate(const Glib::ConstructParams&) (struct TlsCertificate * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.100457;
  const void * * iftmp.5;
  struct ObjectBase * D.100465;
  const void * * iftmp.6;
  struct Object * D.100471;
  int (*__vtbl_ptr_type) () * iftmp.7;
  sizetype iftmp.8;
  int (*__vtbl_ptr_type) () * D.100479;
  int (*__vtbl_ptr_type) () * D.100480;
  long int D.100481;
  struct ObjectBase * D.100483;
  int (*__vtbl_ptr_type) () * iftmp.9;
  const void * * iftmp.10;
  const void * * iftmp.11;

  if (0 != 0) goto <D.100455>; else goto <D.100456>;
  <D.100455>:
  D.100457 = &this->D.96672;
  sigc::trackable::trackable (D.100457);
  goto <D.100458>;
  <D.100456>:
  <D.100458>:
  try
    {
      if (0 != 0) goto <D.100459>; else goto <D.100460>;
      <D.100459>:
      if (0 == 0) goto <D.100462>; else goto <D.100463>;
      <D.100462>:
      iftmp.5 = __vtt_parm + 32;
      goto <D.100464>;
      <D.100463>:
      iftmp.5 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100464>:
      D.100465 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100465, iftmp.5);
      goto <D.100466>;
      <D.100460>:
      <D.100466>:
      try
        {
          if (0 == 0) goto <D.100468>; else goto <D.100469>;
          <D.100468>:
          iftmp.6 = __vtt_parm + 8;
          goto <D.100470>;
          <D.100469>:
          iftmp.6 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
          <D.100470>:
          D.100471 = &this->D.96669;
          Glib::Object::Object (D.100471, iftmp.6, construct_params);
          try
            {
              if (0 == 0) goto <D.100473>; else goto <D.100474>;
              <D.100473>:
              iftmp.7 = *__vtt_parm;
              goto <D.100475>;
              <D.100474>:
              iftmp.7 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100475>:
              this->D.96669._vptr.Object = iftmp.7;
              if (0 == 0) goto <D.100477>; else goto <D.100478>;
              <D.100477>:
              D.100479 = this->D.96669._vptr.Object;
              D.100480 = D.100479 + 18446744073709551592;
              D.100481 = MEM[(long int *)D.100480];
              iftmp.8 = (sizetype) D.100481;
              goto <D.100482>;
              <D.100478>:
              iftmp.8 = 8;
              <D.100482>:
              D.100483 = this + iftmp.8;
              if (0 == 0) goto <D.100485>; else goto <D.100486>;
              <D.100485>:
              iftmp.9 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100487>;
              <D.100486>:
              iftmp.9 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100487>:
              D.100483->_vptr.ObjectBase = iftmp.9;
            }
          catch
            {
              if (0 == 0) goto <D.100489>; else goto <D.100490>;
              <D.100489>:
              iftmp.10 = __vtt_parm + 8;
              goto <D.100491>;
              <D.100490>:
              iftmp.10 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100491>:
              D.100471 = &this->D.96669;
              Glib::Object::~Object (D.100471, iftmp.10);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100492>; else goto <D.100493>;
          <D.100492>:
          if (0 == 0) goto <D.100495>; else goto <D.100496>;
          <D.100495>:
          iftmp.11 = __vtt_parm + 32;
          goto <D.100497>;
          <D.100496>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100497>:
          D.100465 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100465, iftmp.11);
          goto <D.100498>;
          <D.100493>:
          <D.100498>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100499>; else goto <D.100500>;
      <D.100499>:
      D.100457 = &this->D.96672;
      sigc::trackable::~trackable (D.100457);
      goto <D.100501>;
      <D.100500>:
      <D.100501>:
    }
}


Gio::TlsCertificate::TlsCertificate(const Glib::ConstructParams&) (struct TlsCertificate * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.100506;
  const void * * iftmp.12;
  struct ObjectBase * D.100514;
  const void * * iftmp.13;
  struct Object * D.100520;
  int (*__vtbl_ptr_type) () * iftmp.14;
  const void * * D.100524;
  sizetype iftmp.15;
  int (*__vtbl_ptr_type) () * D.100529;
  int (*__vtbl_ptr_type) () * D.100530;
  long int D.100531;
  struct ObjectBase * D.100533;
  int (*__vtbl_ptr_type) () * iftmp.16;
  const void * * iftmp.17;
  const void * * iftmp.18;

  if (1 != 0) goto <D.100504>; else goto <D.100505>;
  <D.100504>:
  D.100506 = &this->D.96672;
  sigc::trackable::trackable (D.100506);
  goto <D.100507>;
  <D.100505>:
  <D.100507>:
  try
    {
      if (1 != 0) goto <D.100508>; else goto <D.100509>;
      <D.100508>:
      if (1 == 0) goto <D.100511>; else goto <D.100512>;
      <D.100511>:
      iftmp.12 = 32B;
      goto <D.100513>;
      <D.100512>:
      iftmp.12 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100513>:
      D.100514 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100514, iftmp.12);
      goto <D.100515>;
      <D.100509>:
      <D.100515>:
      try
        {
          if (1 == 0) goto <D.100517>; else goto <D.100518>;
          <D.100517>:
          iftmp.13 = 8B;
          goto <D.100519>;
          <D.100518>:
          iftmp.13 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
          <D.100519>:
          D.100520 = &this->D.96669;
          Glib::Object::Object (D.100520, iftmp.13, construct_params);
          try
            {
              if (1 == 0) goto <D.100522>; else goto <D.100523>;
              <D.100522>:
              D.100524 = 0B;
              iftmp.14 = *D.100524;
              goto <D.100525>;
              <D.100523>:
              iftmp.14 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100525>:
              this->D.96669._vptr.Object = iftmp.14;
              if (1 == 0) goto <D.100527>; else goto <D.100528>;
              <D.100527>:
              D.100529 = this->D.96669._vptr.Object;
              D.100530 = D.100529 + 18446744073709551592;
              D.100531 = MEM[(long int *)D.100530];
              iftmp.15 = (sizetype) D.100531;
              goto <D.100532>;
              <D.100528>:
              iftmp.15 = 8;
              <D.100532>:
              D.100533 = this + iftmp.15;
              if (1 == 0) goto <D.100535>; else goto <D.100536>;
              <D.100535>:
              iftmp.16 = MEM[(const void * *)0B + 24B];
              goto <D.100537>;
              <D.100536>:
              iftmp.16 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100537>:
              D.100533->_vptr.ObjectBase = iftmp.16;
            }
          catch
            {
              if (1 == 0) goto <D.100539>; else goto <D.100540>;
              <D.100539>:
              iftmp.17 = 8B;
              goto <D.100541>;
              <D.100540>:
              iftmp.17 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100541>:
              D.100520 = &this->D.96669;
              Glib::Object::~Object (D.100520, iftmp.17);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100542>; else goto <D.100543>;
          <D.100542>:
          if (1 == 0) goto <D.100545>; else goto <D.100546>;
          <D.100545>:
          iftmp.18 = 32B;
          goto <D.100547>;
          <D.100546>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100547>:
          D.100514 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100514, iftmp.18);
          goto <D.100548>;
          <D.100543>:
          <D.100548>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100549>; else goto <D.100550>;
      <D.100549>:
      D.100506 = &this->D.96672;
      sigc::trackable::~trackable (D.100506);
      goto <D.100551>;
      <D.100550>:
      <D.100551>:
    }
}


Gio::TlsCertificate::TlsCertificate(GTlsCertificate*) (struct TlsCertificate * const this, const void * * __vtt_parm, struct GTlsCertificate * castitem)
{
  struct trackable * D.100556;
  const void * * iftmp.19;
  struct ObjectBase * D.100564;
  const void * * iftmp.20;
  struct Object * D.100570;
  int (*__vtbl_ptr_type) () * iftmp.21;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.100578;
  int (*__vtbl_ptr_type) () * D.100579;
  long int D.100580;
  struct ObjectBase * D.100582;
  int (*__vtbl_ptr_type) () * iftmp.23;
  const void * * iftmp.24;
  const void * * iftmp.25;

  if (0 != 0) goto <D.100554>; else goto <D.100555>;
  <D.100554>:
  D.100556 = &this->D.96672;
  sigc::trackable::trackable (D.100556);
  goto <D.100557>;
  <D.100555>:
  <D.100557>:
  try
    {
      if (0 != 0) goto <D.100558>; else goto <D.100559>;
      <D.100558>:
      if (0 == 0) goto <D.100561>; else goto <D.100562>;
      <D.100561>:
      iftmp.19 = __vtt_parm + 32;
      goto <D.100563>;
      <D.100562>:
      iftmp.19 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100563>:
      D.100564 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100564, iftmp.19);
      goto <D.100565>;
      <D.100559>:
      <D.100565>:
      try
        {
          if (0 == 0) goto <D.100567>; else goto <D.100568>;
          <D.100567>:
          iftmp.20 = __vtt_parm + 8;
          goto <D.100569>;
          <D.100568>:
          iftmp.20 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
          <D.100569>:
          D.100570 = &this->D.96669;
          Glib::Object::Object (D.100570, iftmp.20, castitem);
          try
            {
              if (0 == 0) goto <D.100572>; else goto <D.100573>;
              <D.100572>:
              iftmp.21 = *__vtt_parm;
              goto <D.100574>;
              <D.100573>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100574>:
              this->D.96669._vptr.Object = iftmp.21;
              if (0 == 0) goto <D.100576>; else goto <D.100577>;
              <D.100576>:
              D.100578 = this->D.96669._vptr.Object;
              D.100579 = D.100578 + 18446744073709551592;
              D.100580 = MEM[(long int *)D.100579];
              iftmp.22 = (sizetype) D.100580;
              goto <D.100581>;
              <D.100577>:
              iftmp.22 = 8;
              <D.100581>:
              D.100582 = this + iftmp.22;
              if (0 == 0) goto <D.100584>; else goto <D.100585>;
              <D.100584>:
              iftmp.23 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100586>;
              <D.100585>:
              iftmp.23 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100586>:
              D.100582->_vptr.ObjectBase = iftmp.23;
            }
          catch
            {
              if (0 == 0) goto <D.100588>; else goto <D.100589>;
              <D.100588>:
              iftmp.24 = __vtt_parm + 8;
              goto <D.100590>;
              <D.100589>:
              iftmp.24 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100590>:
              D.100570 = &this->D.96669;
              Glib::Object::~Object (D.100570, iftmp.24);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100591>; else goto <D.100592>;
          <D.100591>:
          if (0 == 0) goto <D.100594>; else goto <D.100595>;
          <D.100594>:
          iftmp.25 = __vtt_parm + 32;
          goto <D.100596>;
          <D.100595>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100596>:
          D.100564 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100564, iftmp.25);
          goto <D.100597>;
          <D.100592>:
          <D.100597>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100598>; else goto <D.100599>;
      <D.100598>:
      D.100556 = &this->D.96672;
      sigc::trackable::~trackable (D.100556);
      goto <D.100600>;
      <D.100599>:
      <D.100600>:
    }
}


Gio::TlsCertificate::TlsCertificate(GTlsCertificate*) (struct TlsCertificate * const this, struct GTlsCertificate * castitem)
{
  struct trackable * D.100605;
  const void * * iftmp.26;
  struct ObjectBase * D.100613;
  const void * * iftmp.27;
  struct Object * D.100619;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * D.100623;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.100628;
  int (*__vtbl_ptr_type) () * D.100629;
  long int D.100630;
  struct ObjectBase * D.100632;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * iftmp.31;
  const void * * iftmp.32;

  if (1 != 0) goto <D.100603>; else goto <D.100604>;
  <D.100603>:
  D.100605 = &this->D.96672;
  sigc::trackable::trackable (D.100605);
  goto <D.100606>;
  <D.100604>:
  <D.100606>:
  try
    {
      if (1 != 0) goto <D.100607>; else goto <D.100608>;
      <D.100607>:
      if (1 == 0) goto <D.100610>; else goto <D.100611>;
      <D.100610>:
      iftmp.26 = 32B;
      goto <D.100612>;
      <D.100611>:
      iftmp.26 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100612>:
      D.100613 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100613, iftmp.26);
      goto <D.100614>;
      <D.100608>:
      <D.100614>:
      try
        {
          if (1 == 0) goto <D.100616>; else goto <D.100617>;
          <D.100616>:
          iftmp.27 = 8B;
          goto <D.100618>;
          <D.100617>:
          iftmp.27 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
          <D.100618>:
          D.100619 = &this->D.96669;
          Glib::Object::Object (D.100619, iftmp.27, castitem);
          try
            {
              if (1 == 0) goto <D.100621>; else goto <D.100622>;
              <D.100621>:
              D.100623 = 0B;
              iftmp.28 = *D.100623;
              goto <D.100624>;
              <D.100622>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100624>:
              this->D.96669._vptr.Object = iftmp.28;
              if (1 == 0) goto <D.100626>; else goto <D.100627>;
              <D.100626>:
              D.100628 = this->D.96669._vptr.Object;
              D.100629 = D.100628 + 18446744073709551592;
              D.100630 = MEM[(long int *)D.100629];
              iftmp.29 = (sizetype) D.100630;
              goto <D.100631>;
              <D.100627>:
              iftmp.29 = 8;
              <D.100631>:
              D.100632 = this + iftmp.29;
              if (1 == 0) goto <D.100634>; else goto <D.100635>;
              <D.100634>:
              iftmp.30 = MEM[(const void * *)0B + 24B];
              goto <D.100636>;
              <D.100635>:
              iftmp.30 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100636>:
              D.100632->_vptr.ObjectBase = iftmp.30;
            }
          catch
            {
              if (1 == 0) goto <D.100638>; else goto <D.100639>;
              <D.100638>:
              iftmp.31 = 8B;
              goto <D.100640>;
              <D.100639>:
              iftmp.31 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100640>:
              D.100619 = &this->D.96669;
              Glib::Object::~Object (D.100619, iftmp.31);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100641>; else goto <D.100642>;
          <D.100641>:
          if (1 == 0) goto <D.100644>; else goto <D.100645>;
          <D.100644>:
          iftmp.32 = 32B;
          goto <D.100646>;
          <D.100645>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100646>:
          D.100613 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100613, iftmp.32);
          goto <D.100647>;
          <D.100642>:
          <D.100647>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100648>; else goto <D.100649>;
      <D.100648>:
      D.100605 = &this->D.96672;
      sigc::trackable::~trackable (D.100605);
      goto <D.100650>;
      <D.100649>:
      <D.100650>:
    }
}


Gio::TlsCertificate::~TlsCertificate() (struct TlsCertificate * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.100660;
  int (*__vtbl_ptr_type) () * D.100661;
  long int D.100662;
  struct ObjectBase * D.100664;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * iftmp.36;
  struct Object * D.100673;
  int D.100674;
  const void * * iftmp.37;
  struct ObjectBase * D.100681;
  struct trackable * D.100685;
  int D.100687;

  {
    if (0 == 0) goto <D.100654>; else goto <D.100655>;
    <D.100654>:
    iftmp.33 = *__vtt_parm;
    goto <D.100656>;
    <D.100655>:
    iftmp.33 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
    <D.100656>:
    this->D.96669._vptr.Object = iftmp.33;
    if (0 == 0) goto <D.100658>; else goto <D.100659>;
    <D.100658>:
    D.100660 = this->D.96669._vptr.Object;
    D.100661 = D.100660 + 18446744073709551592;
    D.100662 = MEM[(long int *)D.100661];
    iftmp.34 = (sizetype) D.100662;
    goto <D.100663>;
    <D.100659>:
    iftmp.34 = 8;
    <D.100663>:
    D.100664 = this + iftmp.34;
    if (0 == 0) goto <D.100666>; else goto <D.100667>;
    <D.100666>:
    iftmp.35 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.100668>;
    <D.100667>:
    iftmp.35 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
    <D.100668>:
    D.100664->_vptr.ObjectBase = iftmp.35;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.100670>; else goto <D.100671>;
                    <D.100670>:
                    iftmp.36 = __vtt_parm + 8;
                    goto <D.100672>;
                    <D.100671>:
                    iftmp.36 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
                    <D.100672>:
                    D.100673 = &this->D.96669;
                    Glib::Object::~Object (D.100673, iftmp.36);
                  }
              }
            finally
              {
                D.100674 = 0;
                if (D.100674 != 0) goto <D.100675>; else goto <D.100676>;
                <D.100675>:
                if (0 == 0) goto <D.100678>; else goto <D.100679>;
                <D.100678>:
                iftmp.37 = __vtt_parm + 32;
                goto <D.100680>;
                <D.100679>:
                iftmp.37 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
                <D.100680>:
                D.100681 = &this->D.96671;
                Glib::ObjectBase::~ObjectBase (D.100681, iftmp.37);
                goto <D.100682>;
                <D.100676>:
                <D.100682>:
              }
          }
        finally
          {
            D.100674 = 0;
            if (D.100674 != 0) goto <D.100683>; else goto <D.100684>;
            <D.100683>:
            D.100685 = &this->D.96672;
            sigc::trackable::~trackable (D.100685);
            goto <D.100686>;
            <D.100684>:
            <D.100686>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97819>:
  D.100687 = 0;
  if (D.100687 != 0) goto <D.100688>; else goto <D.100689>;
  <D.100688>:
  operator delete (this);
  goto <D.100690>;
  <D.100689>:
  <D.100690>:
}


virtual Gio::TlsCertificate::~TlsCertificate() (struct TlsCertificate * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * D.100706;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.100711;
  int (*__vtbl_ptr_type) () * D.100712;
  long int D.100713;
  struct ObjectBase * D.100715;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  struct Object * D.100724;
  int D.100725;
  const void * * iftmp.42;
  struct ObjectBase * D.100732;
  struct trackable * D.100736;
  int D.100738;

  {
    if (2 == 0) goto <D.100704>; else goto <D.100705>;
    <D.100704>:
    D.100706 = 0B;
    iftmp.38 = *D.100706;
    goto <D.100707>;
    <D.100705>:
    iftmp.38 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
    <D.100707>:
    this->D.96669._vptr.Object = iftmp.38;
    if (2 == 0) goto <D.100709>; else goto <D.100710>;
    <D.100709>:
    D.100711 = this->D.96669._vptr.Object;
    D.100712 = D.100711 + 18446744073709551592;
    D.100713 = MEM[(long int *)D.100712];
    iftmp.39 = (sizetype) D.100713;
    goto <D.100714>;
    <D.100710>:
    iftmp.39 = 8;
    <D.100714>:
    D.100715 = this + iftmp.39;
    if (2 == 0) goto <D.100717>; else goto <D.100718>;
    <D.100717>:
    iftmp.40 = MEM[(const void * *)0B + 24B];
    goto <D.100719>;
    <D.100718>:
    iftmp.40 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
    <D.100719>:
    D.100715->_vptr.ObjectBase = iftmp.40;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.100721>; else goto <D.100722>;
                    <D.100721>:
                    iftmp.41 = 8B;
                    goto <D.100723>;
                    <D.100722>:
                    iftmp.41 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
                    <D.100723>:
                    D.100724 = &this->D.96669;
                    Glib::Object::~Object (D.100724, iftmp.41);
                  }
              }
            finally
              {
                D.100725 = 2;
                if (D.100725 != 0) goto <D.100726>; else goto <D.100727>;
                <D.100726>:
                if (2 == 0) goto <D.100729>; else goto <D.100730>;
                <D.100729>:
                iftmp.42 = 32B;
                goto <D.100731>;
                <D.100730>:
                iftmp.42 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
                <D.100731>:
                D.100732 = &this->D.96671;
                Glib::ObjectBase::~ObjectBase (D.100732, iftmp.42);
                goto <D.100733>;
                <D.100727>:
                <D.100733>:
              }
          }
        finally
          {
            D.100725 = 2;
            if (D.100725 != 0) goto <D.100734>; else goto <D.100735>;
            <D.100734>:
            D.100736 = &this->D.96672;
            sigc::trackable::~trackable (D.100736);
            goto <D.100737>;
            <D.100735>:
            <D.100737>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97822>:
  D.100738 = 0;
  if (D.100738 != 0) goto <D.100739>; else goto <D.100740>;
  <D.100739>:
  operator delete (this);
  goto <D.100741>;
  <D.100740>:
  <D.100741>:
}


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


static GType Gio::TlsCertificate::get_type() ()
{
  GType D.100754;
  const struct Class & D.100755;

  D.100755 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
  D.100754 = Glib::Class::get_type (D.100755);
  return D.100754;
}


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

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


static GType Gio::TlsCertificate::get_base_type() ()
{
  GType D.100760;

  D.100760 = g_tls_certificate_get_type ();
  return D.100760;
}


Gio::TlsCertificate::TlsCertificate(const string&, gssize) (struct TlsCertificate * const this, const void * * __vtt_parm, const struct string & data, gssize length)
{
  struct trackable * D.100765;
  const void * * iftmp.43;
  struct ObjectBase * D.100773;
  struct ConstructParams D.97847;
  const char * D.100775;
  const struct Class & D.100776;
  const void * * iftmp.44;
  struct Object * D.100781;
  int (*__vtbl_ptr_type) () * iftmp.45;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.100789;
  int (*__vtbl_ptr_type) () * D.100790;
  long int D.100791;
  struct ObjectBase * D.100793;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  const void * * iftmp.49;

  if (0 != 0) goto <D.100763>; else goto <D.100764>;
  <D.100763>:
  D.100765 = &this->D.96672;
  sigc::trackable::trackable (D.100765);
  goto <D.100766>;
  <D.100764>:
  <D.100766>:
  try
    {
      if (0 != 0) goto <D.100767>; else goto <D.100768>;
      <D.100767>:
      if (0 == 0) goto <D.100770>; else goto <D.100771>;
      <D.100770>:
      iftmp.43 = __vtt_parm + 32;
      goto <D.100772>;
      <D.100771>:
      iftmp.43 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100772>:
      D.100773 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100773, iftmp.43, 0B);
      goto <D.100774>;
      <D.100768>:
      <D.100774>:
      try
        {
          D.100775 = std::basic_string<char>::c_str (data);
          D.100776 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97847, D.100776, "data", D.100775, "length", length, 0B);
          try
            {
              if (0 == 0) goto <D.100778>; else goto <D.100779>;
              <D.100778>:
              iftmp.44 = __vtt_parm + 8;
              goto <D.100780>;
              <D.100779>:
              iftmp.44 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100780>:
              D.100781 = &this->D.96669;
              Glib::Object::Object (D.100781, iftmp.44, &D.97847);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97847);
              D.97847 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.100783>; else goto <D.100784>;
              <D.100783>:
              iftmp.45 = *__vtt_parm;
              goto <D.100785>;
              <D.100784>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100785>:
              this->D.96669._vptr.Object = iftmp.45;
              if (0 == 0) goto <D.100787>; else goto <D.100788>;
              <D.100787>:
              D.100789 = this->D.96669._vptr.Object;
              D.100790 = D.100789 + 18446744073709551592;
              D.100791 = MEM[(long int *)D.100790];
              iftmp.46 = (sizetype) D.100791;
              goto <D.100792>;
              <D.100788>:
              iftmp.46 = 8;
              <D.100792>:
              D.100793 = this + iftmp.46;
              if (0 == 0) goto <D.100795>; else goto <D.100796>;
              <D.100795>:
              iftmp.47 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100797>;
              <D.100796>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100797>:
              D.100793->_vptr.ObjectBase = iftmp.47;
            }
          catch
            {
              if (0 == 0) goto <D.100799>; else goto <D.100800>;
              <D.100799>:
              iftmp.48 = __vtt_parm + 8;
              goto <D.100801>;
              <D.100800>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100801>:
              D.100781 = &this->D.96669;
              Glib::Object::~Object (D.100781, iftmp.48);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100802>; else goto <D.100803>;
          <D.100802>:
          if (0 == 0) goto <D.100805>; else goto <D.100806>;
          <D.100805>:
          iftmp.49 = __vtt_parm + 32;
          goto <D.100807>;
          <D.100806>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100807>:
          D.100773 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100773, iftmp.49);
          goto <D.100808>;
          <D.100803>:
          <D.100808>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100809>; else goto <D.100810>;
      <D.100809>:
      D.100765 = &this->D.96672;
      sigc::trackable::~trackable (D.100765);
      goto <D.100811>;
      <D.100810>:
      <D.100811>:
    }
}


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

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


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

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


Gio::TlsCertificate::TlsCertificate(const string&, gssize) (struct TlsCertificate * const this, const struct string & data, gssize length)
{
  struct trackable * D.100824;
  const void * * iftmp.50;
  struct ObjectBase * D.100832;
  struct ConstructParams D.97849;
  const char * D.100834;
  const struct Class & D.100835;
  const void * * iftmp.51;
  struct Object * D.100840;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * D.100844;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.100849;
  int (*__vtbl_ptr_type) () * D.100850;
  long int D.100851;
  struct ObjectBase * D.100853;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;

  if (1 != 0) goto <D.100822>; else goto <D.100823>;
  <D.100822>:
  D.100824 = &this->D.96672;
  sigc::trackable::trackable (D.100824);
  goto <D.100825>;
  <D.100823>:
  <D.100825>:
  try
    {
      if (1 != 0) goto <D.100826>; else goto <D.100827>;
      <D.100826>:
      if (1 == 0) goto <D.100829>; else goto <D.100830>;
      <D.100829>:
      iftmp.50 = 32B;
      goto <D.100831>;
      <D.100830>:
      iftmp.50 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100831>:
      D.100832 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100832, iftmp.50, 0B);
      goto <D.100833>;
      <D.100827>:
      <D.100833>:
      try
        {
          D.100834 = std::basic_string<char>::c_str (data);
          D.100835 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97849, D.100835, "data", D.100834, "length", length, 0B);
          try
            {
              if (1 == 0) goto <D.100837>; else goto <D.100838>;
              <D.100837>:
              iftmp.51 = 8B;
              goto <D.100839>;
              <D.100838>:
              iftmp.51 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100839>:
              D.100840 = &this->D.96669;
              Glib::Object::Object (D.100840, iftmp.51, &D.97849);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97849);
              D.97849 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.100842>; else goto <D.100843>;
              <D.100842>:
              D.100844 = 0B;
              iftmp.52 = *D.100844;
              goto <D.100845>;
              <D.100843>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100845>:
              this->D.96669._vptr.Object = iftmp.52;
              if (1 == 0) goto <D.100847>; else goto <D.100848>;
              <D.100847>:
              D.100849 = this->D.96669._vptr.Object;
              D.100850 = D.100849 + 18446744073709551592;
              D.100851 = MEM[(long int *)D.100850];
              iftmp.53 = (sizetype) D.100851;
              goto <D.100852>;
              <D.100848>:
              iftmp.53 = 8;
              <D.100852>:
              D.100853 = this + iftmp.53;
              if (1 == 0) goto <D.100855>; else goto <D.100856>;
              <D.100855>:
              iftmp.54 = MEM[(const void * *)0B + 24B];
              goto <D.100857>;
              <D.100856>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100857>:
              D.100853->_vptr.ObjectBase = iftmp.54;
            }
          catch
            {
              if (1 == 0) goto <D.100859>; else goto <D.100860>;
              <D.100859>:
              iftmp.55 = 8B;
              goto <D.100861>;
              <D.100860>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100861>:
              D.100840 = &this->D.96669;
              Glib::Object::~Object (D.100840, iftmp.55);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100862>; else goto <D.100863>;
          <D.100862>:
          if (1 == 0) goto <D.100865>; else goto <D.100866>;
          <D.100865>:
          iftmp.56 = 32B;
          goto <D.100867>;
          <D.100866>:
          iftmp.56 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100867>:
          D.100832 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100832, iftmp.56);
          goto <D.100868>;
          <D.100863>:
          <D.100868>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100869>; else goto <D.100870>;
      <D.100869>:
      D.100824 = &this->D.96672;
      sigc::trackable::~trackable (D.100824);
      goto <D.100871>;
      <D.100870>:
      <D.100871>:
    }
}


Gio::TlsCertificate::TlsCertificate(const string&) (struct TlsCertificate * const this, const void * * __vtt_parm, const struct string & file)
{
  struct trackable * D.100879;
  const void * * iftmp.57;
  struct ObjectBase * D.100887;
  struct ConstructParams D.97858;
  const char * D.100889;
  const struct Class & D.100890;
  const void * * iftmp.58;
  struct Object * D.100895;
  int (*__vtbl_ptr_type) () * iftmp.59;
  sizetype iftmp.60;
  int (*__vtbl_ptr_type) () * D.100903;
  int (*__vtbl_ptr_type) () * D.100904;
  long int D.100905;
  struct ObjectBase * D.100907;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * iftmp.62;
  const void * * iftmp.63;

  if (0 != 0) goto <D.100877>; else goto <D.100878>;
  <D.100877>:
  D.100879 = &this->D.96672;
  sigc::trackable::trackable (D.100879);
  goto <D.100880>;
  <D.100878>:
  <D.100880>:
  try
    {
      if (0 != 0) goto <D.100881>; else goto <D.100882>;
      <D.100881>:
      if (0 == 0) goto <D.100884>; else goto <D.100885>;
      <D.100884>:
      iftmp.57 = __vtt_parm + 32;
      goto <D.100886>;
      <D.100885>:
      iftmp.57 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100886>:
      D.100887 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100887, iftmp.57, 0B);
      goto <D.100888>;
      <D.100882>:
      <D.100888>:
      try
        {
          D.100889 = std::basic_string<char>::c_str (file);
          D.100890 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97858, D.100890, "file", D.100889, 0B);
          try
            {
              if (0 == 0) goto <D.100892>; else goto <D.100893>;
              <D.100892>:
              iftmp.58 = __vtt_parm + 8;
              goto <D.100894>;
              <D.100893>:
              iftmp.58 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100894>:
              D.100895 = &this->D.96669;
              Glib::Object::Object (D.100895, iftmp.58, &D.97858);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97858);
              D.97858 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.100897>; else goto <D.100898>;
              <D.100897>:
              iftmp.59 = *__vtt_parm;
              goto <D.100899>;
              <D.100898>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100899>:
              this->D.96669._vptr.Object = iftmp.59;
              if (0 == 0) goto <D.100901>; else goto <D.100902>;
              <D.100901>:
              D.100903 = this->D.96669._vptr.Object;
              D.100904 = D.100903 + 18446744073709551592;
              D.100905 = MEM[(long int *)D.100904];
              iftmp.60 = (sizetype) D.100905;
              goto <D.100906>;
              <D.100902>:
              iftmp.60 = 8;
              <D.100906>:
              D.100907 = this + iftmp.60;
              if (0 == 0) goto <D.100909>; else goto <D.100910>;
              <D.100909>:
              iftmp.61 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.100911>;
              <D.100910>:
              iftmp.61 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100911>:
              D.100907->_vptr.ObjectBase = iftmp.61;
            }
          catch
            {
              if (0 == 0) goto <D.100913>; else goto <D.100914>;
              <D.100913>:
              iftmp.62 = __vtt_parm + 8;
              goto <D.100915>;
              <D.100914>:
              iftmp.62 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100915>:
              D.100895 = &this->D.96669;
              Glib::Object::~Object (D.100895, iftmp.62);
            }
        }
      catch
        {
          if (0 != 0) goto <D.100916>; else goto <D.100917>;
          <D.100916>:
          if (0 == 0) goto <D.100919>; else goto <D.100920>;
          <D.100919>:
          iftmp.63 = __vtt_parm + 32;
          goto <D.100921>;
          <D.100920>:
          iftmp.63 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100921>:
          D.100887 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100887, iftmp.63);
          goto <D.100922>;
          <D.100917>:
          <D.100922>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.100923>; else goto <D.100924>;
      <D.100923>:
      D.100879 = &this->D.96672;
      sigc::trackable::~trackable (D.100879);
      goto <D.100925>;
      <D.100924>:
      <D.100925>:
    }
}


Gio::TlsCertificate::TlsCertificate(const string&) (struct TlsCertificate * const this, const struct string & file)
{
  struct trackable * D.100933;
  const void * * iftmp.64;
  struct ObjectBase * D.100941;
  struct ConstructParams D.97860;
  const char * D.100943;
  const struct Class & D.100944;
  const void * * iftmp.65;
  struct Object * D.100949;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * D.100953;
  sizetype iftmp.67;
  int (*__vtbl_ptr_type) () * D.100958;
  int (*__vtbl_ptr_type) () * D.100959;
  long int D.100960;
  struct ObjectBase * D.100962;
  int (*__vtbl_ptr_type) () * iftmp.68;
  const void * * iftmp.69;
  const void * * iftmp.70;

  if (1 != 0) goto <D.100931>; else goto <D.100932>;
  <D.100931>:
  D.100933 = &this->D.96672;
  sigc::trackable::trackable (D.100933);
  goto <D.100934>;
  <D.100932>:
  <D.100934>:
  try
    {
      if (1 != 0) goto <D.100935>; else goto <D.100936>;
      <D.100935>:
      if (1 == 0) goto <D.100938>; else goto <D.100939>;
      <D.100938>:
      iftmp.64 = 32B;
      goto <D.100940>;
      <D.100939>:
      iftmp.64 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100940>:
      D.100941 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100941, iftmp.64, 0B);
      goto <D.100942>;
      <D.100936>:
      <D.100942>:
      try
        {
          D.100943 = std::basic_string<char>::c_str (file);
          D.100944 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97860, D.100944, "file", D.100943, 0B);
          try
            {
              if (1 == 0) goto <D.100946>; else goto <D.100947>;
              <D.100946>:
              iftmp.65 = 8B;
              goto <D.100948>;
              <D.100947>:
              iftmp.65 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100948>:
              D.100949 = &this->D.96669;
              Glib::Object::Object (D.100949, iftmp.65, &D.97860);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97860);
              D.97860 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.100951>; else goto <D.100952>;
              <D.100951>:
              D.100953 = 0B;
              iftmp.66 = *D.100953;
              goto <D.100954>;
              <D.100952>:
              iftmp.66 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.100954>:
              this->D.96669._vptr.Object = iftmp.66;
              if (1 == 0) goto <D.100956>; else goto <D.100957>;
              <D.100956>:
              D.100958 = this->D.96669._vptr.Object;
              D.100959 = D.100958 + 18446744073709551592;
              D.100960 = MEM[(long int *)D.100959];
              iftmp.67 = (sizetype) D.100960;
              goto <D.100961>;
              <D.100957>:
              iftmp.67 = 8;
              <D.100961>:
              D.100962 = this + iftmp.67;
              if (1 == 0) goto <D.100964>; else goto <D.100965>;
              <D.100964>:
              iftmp.68 = MEM[(const void * *)0B + 24B];
              goto <D.100966>;
              <D.100965>:
              iftmp.68 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.100966>:
              D.100962->_vptr.ObjectBase = iftmp.68;
            }
          catch
            {
              if (1 == 0) goto <D.100968>; else goto <D.100969>;
              <D.100968>:
              iftmp.69 = 8B;
              goto <D.100970>;
              <D.100969>:
              iftmp.69 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.100970>:
              D.100949 = &this->D.96669;
              Glib::Object::~Object (D.100949, iftmp.69);
            }
        }
      catch
        {
          if (1 != 0) goto <D.100971>; else goto <D.100972>;
          <D.100971>:
          if (1 == 0) goto <D.100974>; else goto <D.100975>;
          <D.100974>:
          iftmp.70 = 32B;
          goto <D.100976>;
          <D.100975>:
          iftmp.70 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.100976>:
          D.100941 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100941, iftmp.70);
          goto <D.100977>;
          <D.100972>:
          <D.100977>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100978>; else goto <D.100979>;
      <D.100978>:
      D.100933 = &this->D.96672;
      sigc::trackable::~trackable (D.100933);
      goto <D.100980>;
      <D.100979>:
      <D.100980>:
    }
}


Gio::TlsCertificate::TlsCertificate(const string&, const string&) (struct TlsCertificate * const this, const void * * __vtt_parm, const struct string & cert_file, const struct string & key_file)
{
  struct trackable * D.100988;
  const void * * iftmp.71;
  struct ObjectBase * D.100996;
  struct ConstructParams D.97870;
  const char * D.100998;
  const char * D.100999;
  const struct Class & D.101000;
  const void * * iftmp.72;
  struct Object * D.101005;
  int (*__vtbl_ptr_type) () * iftmp.73;
  sizetype iftmp.74;
  int (*__vtbl_ptr_type) () * D.101013;
  int (*__vtbl_ptr_type) () * D.101014;
  long int D.101015;
  struct ObjectBase * D.101017;
  int (*__vtbl_ptr_type) () * iftmp.75;
  const void * * iftmp.76;
  const void * * iftmp.77;

  if (0 != 0) goto <D.100986>; else goto <D.100987>;
  <D.100986>:
  D.100988 = &this->D.96672;
  sigc::trackable::trackable (D.100988);
  goto <D.100989>;
  <D.100987>:
  <D.100989>:
  try
    {
      if (0 != 0) goto <D.100990>; else goto <D.100991>;
      <D.100990>:
      if (0 == 0) goto <D.100993>; else goto <D.100994>;
      <D.100993>:
      iftmp.71 = __vtt_parm + 32;
      goto <D.100995>;
      <D.100994>:
      iftmp.71 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.100995>:
      D.100996 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.100996, iftmp.71, 0B);
      goto <D.100997>;
      <D.100991>:
      <D.100997>:
      try
        {
          D.100998 = std::basic_string<char>::c_str (key_file);
          D.100999 = std::basic_string<char>::c_str (cert_file);
          D.101000 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97870, D.101000, "cert_file", D.100999, "key_file", D.100998, 0B);
          try
            {
              if (0 == 0) goto <D.101002>; else goto <D.101003>;
              <D.101002>:
              iftmp.72 = __vtt_parm + 8;
              goto <D.101004>;
              <D.101003>:
              iftmp.72 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.101004>:
              D.101005 = &this->D.96669;
              Glib::Object::Object (D.101005, iftmp.72, &D.97870);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97870);
              D.97870 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.101007>; else goto <D.101008>;
              <D.101007>:
              iftmp.73 = *__vtt_parm;
              goto <D.101009>;
              <D.101008>:
              iftmp.73 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.101009>:
              this->D.96669._vptr.Object = iftmp.73;
              if (0 == 0) goto <D.101011>; else goto <D.101012>;
              <D.101011>:
              D.101013 = this->D.96669._vptr.Object;
              D.101014 = D.101013 + 18446744073709551592;
              D.101015 = MEM[(long int *)D.101014];
              iftmp.74 = (sizetype) D.101015;
              goto <D.101016>;
              <D.101012>:
              iftmp.74 = 8;
              <D.101016>:
              D.101017 = this + iftmp.74;
              if (0 == 0) goto <D.101019>; else goto <D.101020>;
              <D.101019>:
              iftmp.75 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.101021>;
              <D.101020>:
              iftmp.75 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.101021>:
              D.101017->_vptr.ObjectBase = iftmp.75;
            }
          catch
            {
              if (0 == 0) goto <D.101023>; else goto <D.101024>;
              <D.101023>:
              iftmp.76 = __vtt_parm + 8;
              goto <D.101025>;
              <D.101024>:
              iftmp.76 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.101025>:
              D.101005 = &this->D.96669;
              Glib::Object::~Object (D.101005, iftmp.76);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101026>; else goto <D.101027>;
          <D.101026>:
          if (0 == 0) goto <D.101029>; else goto <D.101030>;
          <D.101029>:
          iftmp.77 = __vtt_parm + 32;
          goto <D.101031>;
          <D.101030>:
          iftmp.77 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.101031>:
          D.100996 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.100996, iftmp.77);
          goto <D.101032>;
          <D.101027>:
          <D.101032>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101033>; else goto <D.101034>;
      <D.101033>:
      D.100988 = &this->D.96672;
      sigc::trackable::~trackable (D.100988);
      goto <D.101035>;
      <D.101034>:
      <D.101035>:
    }
}


Gio::TlsCertificate::TlsCertificate(const string&, const string&) (struct TlsCertificate * const this, const struct string & cert_file, const struct string & key_file)
{
  struct trackable * D.101044;
  const void * * iftmp.78;
  struct ObjectBase * D.101052;
  struct ConstructParams D.97872;
  const char * D.101054;
  const char * D.101055;
  const struct Class & D.101056;
  const void * * iftmp.79;
  struct Object * D.101061;
  int (*__vtbl_ptr_type) () * iftmp.80;
  const void * * D.101065;
  sizetype iftmp.81;
  int (*__vtbl_ptr_type) () * D.101070;
  int (*__vtbl_ptr_type) () * D.101071;
  long int D.101072;
  struct ObjectBase * D.101074;
  int (*__vtbl_ptr_type) () * iftmp.82;
  const void * * iftmp.83;
  const void * * iftmp.84;

  if (1 != 0) goto <D.101042>; else goto <D.101043>;
  <D.101042>:
  D.101044 = &this->D.96672;
  sigc::trackable::trackable (D.101044);
  goto <D.101045>;
  <D.101043>:
  <D.101045>:
  try
    {
      if (1 != 0) goto <D.101046>; else goto <D.101047>;
      <D.101046>:
      if (1 == 0) goto <D.101049>; else goto <D.101050>;
      <D.101049>:
      iftmp.78 = 32B;
      goto <D.101051>;
      <D.101050>:
      iftmp.78 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
      <D.101051>:
      D.101052 = &this->D.96671;
      Glib::ObjectBase::ObjectBase (D.101052, iftmp.78, 0B);
      goto <D.101053>;
      <D.101047>:
      <D.101053>:
      try
        {
          D.101054 = std::basic_string<char>::c_str (key_file);
          D.101055 = std::basic_string<char>::c_str (cert_file);
          D.101056 = Gio::TlsCertificate_Class::init (&tlscertificate_class_);
          Glib::ConstructParams::ConstructParams (&D.97872, D.101056, "cert_file", D.101055, "key_file", D.101054, 0B);
          try
            {
              if (1 == 0) goto <D.101058>; else goto <D.101059>;
              <D.101058>:
              iftmp.79 = 8B;
              goto <D.101060>;
              <D.101059>:
              iftmp.79 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.101060>:
              D.101061 = &this->D.96669;
              Glib::Object::Object (D.101061, iftmp.79, &D.97872);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.97872);
              D.97872 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.101063>; else goto <D.101064>;
              <D.101063>:
              D.101065 = 0B;
              iftmp.80 = *D.101065;
              goto <D.101066>;
              <D.101064>:
              iftmp.80 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 32B];
              <D.101066>:
              this->D.96669._vptr.Object = iftmp.80;
              if (1 == 0) goto <D.101068>; else goto <D.101069>;
              <D.101068>:
              D.101070 = this->D.96669._vptr.Object;
              D.101071 = D.101070 + 18446744073709551592;
              D.101072 = MEM[(long int *)D.101071];
              iftmp.81 = (sizetype) D.101072;
              goto <D.101073>;
              <D.101069>:
              iftmp.81 = 8;
              <D.101073>:
              D.101074 = this + iftmp.81;
              if (1 == 0) goto <D.101076>; else goto <D.101077>;
              <D.101076>:
              iftmp.82 = MEM[(const void * *)0B + 24B];
              goto <D.101078>;
              <D.101077>:
              iftmp.82 = &MEM[(void *)&_ZTVN3Gio14TlsCertificateE + 120B];
              <D.101078>:
              D.101074->_vptr.ObjectBase = iftmp.82;
            }
          catch
            {
              if (1 == 0) goto <D.101080>; else goto <D.101081>;
              <D.101080>:
              iftmp.83 = 8B;
              goto <D.101082>;
              <D.101081>:
              iftmp.83 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 8B];
              <D.101082>:
              D.101061 = &this->D.96669;
              Glib::Object::~Object (D.101061, iftmp.83);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101083>; else goto <D.101084>;
          <D.101083>:
          if (1 == 0) goto <D.101086>; else goto <D.101087>;
          <D.101086>:
          iftmp.84 = 32B;
          goto <D.101088>;
          <D.101087>:
          iftmp.84 = &MEM[(void *)&_ZTTN3Gio14TlsCertificateE + 32B];
          <D.101088>:
          D.101052 = &this->D.96671;
          Glib::ObjectBase::~ObjectBase (D.101052, iftmp.84);
          goto <D.101089>;
          <D.101084>:
          <D.101089>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101090>; else goto <D.101091>;
      <D.101090>:
      D.101044 = &this->D.96672;
      sigc::trackable::~trackable (D.101044);
      goto <D.101092>;
      <D.101091>:
      <D.101092>:
    }
}


static Glib::RefPtr<Gio::TlsCertificate> Gio::TlsCertificate::create(const string&) (const struct string & file)
{
  void * D.97877;

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


static Glib::RefPtr<Gio::TlsCertificate> Gio::TlsCertificate::create(const string&, const string&) (const struct string & cert_file, const struct string & key_file)
{
  void * D.97884;

  D.97884 = operator new (48);
  try
    {
      Gio::TlsCertificate::TlsCertificate (D.97884, cert_file, key_file);
    }
  catch
    {
      operator delete (D.97884);
    }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, D.97884);
  return <retval>;
}


static std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsCertificate::create_list_from_file(const string&) (const struct string & file)
{
  const char * D.101108;
  struct GList * D.101109;
  struct GError * gerror.85;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.101108 = std::basic_string<char>::c_str (file);
      D.101109 = g_tls_certificate_list_new_from_file (D.101108, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.101109, 2); [return slot optimization]
      try
        {
          gerror.85 = gerror;
          if (gerror.85 != 0B) goto <D.101111>; else goto <D.101112>;
          <D.101111>:
          gerror.85 = gerror;
          Glib::Error::throw_exception (gerror.85);
          <D.101112>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


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

  try
    {
      Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::GListKeeper (&keeper, glist, ownership);
      try
        {
          std::allocator<Glib::RefPtr<Gio::TlsCertificate> >::allocator (&D.99328);
          try
            {
              Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::ListIterator (&D.99311, 0B);
              try
                {
                  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::ListIterator (&D.99310, glist);
                  try
                    {
                      std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (<retval>, D.99310, D.99311, &D.99328);
                      return <retval>;
                    }
                  finally
                    {
                      D.99310 = {CLOBBER};
                    }
                }
              finally
                {
                  D.99311 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<Glib::RefPtr<Gio::TlsCertificate> >::~allocator (&D.99328);
              D.99328 = {CLOBBER};
            }
        }
      finally
        {
          Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::~GListKeeper (&keeper);
        }
    }
  finally
    {
      keeper = {CLOBBER};
    }
}


Glib::Container_Helpers::GListKeeper<Tr>::GListKeeper(const GList*, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >; 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<Gio::TlsCertificate>] (struct allocator * const this)
{
  void * D.101131;

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

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


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

  try
    {
      {

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


Glib::Container_Helpers::ListIterator<Tr>::ListIterator(const GList*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >; 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<Gio::TlsCertificate> > >; _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.101133;
  struct _Integral D.99716;
  struct __false_type D.101134;

  D.101133 = &this->D.98631;
  std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_base (D.101133, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<Glib::RefPtr<Gio::TlsCertificate> >::_M_initialize_dispatch<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (this, __first, __last, D.101134);
          }
        finally
          {
            D.99716 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.101133 = &this->D.98631;
      std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::~_Vector_base (D.101133);
    }
}


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

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

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


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


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

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

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


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = Glib::RefPtr<Gio::TlsCertificate>] (struct new_allocator * const this, const struct new_allocator & D.97971)
{
  void * D.101139;

  try
    {
      {

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


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<Gio::TlsCertificate> > >; _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct __false_type D.99670)
{
  struct _IterCategory D.99911;
  struct forward_iterator_tag D.101140;
  typedef struct _IterCategory _IterCategory;

  try
    {
      std::vector<Glib::RefPtr<Gio::TlsCertificate> >::_M_range_initialize<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (this, __first, __last, D.101140);
    }
  finally
    {
      D.99911 = {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<Gio::TlsCertificate> > >; _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct forward_iterator_tag D.99916)
{
  long int D.101142;
  struct _Vector_base * D.101143;
  struct RefPtr * D.101144;
  struct RefPtr * D.101145;
  long unsigned int D.101146;
  struct RefPtr * D.101147;
  struct _Tp_alloc_type & D.101148;
  struct RefPtr * D.101149;
  const size_type __n;

  D.101142 = std::distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (__first, __last);
  __n = (const size_type) D.101142;
  D.101143 = &this->D.98631;
  D.101144 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_allocate (D.101143, __n);
  this->D.98631._M_impl._M_start = D.101144;
  D.101145 = this->D.98631._M_impl._M_start;
  D.101146 = __n * 8;
  D.101147 = D.101145 + D.101146;
  this->D.98631._M_impl._M_end_of_storage = D.101147;
  D.101143 = &this->D.98631;
  D.101148 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.101143);
  D.101145 = this->D.98631._M_impl._M_start;
  D.101149 = std::__uninitialized_copy_a<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >, Glib::RefPtr<Gio::TlsCertificate>*, Glib::RefPtr<Gio::TlsCertificate> > (__first, __last, D.101145, D.101148);
  this->D.98631._M_impl._M_finish = D.101149;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last)
{
  difference_type D.101153;
  struct input_iterator_tag D.100211;
  struct iterator_category D.100174;
  struct iterator_category * D.101154;
  struct input_iterator_tag D.101155;

  std::__iterator_category<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (&__first);
  try
    {
      D.101154 = &D.100174;
      D.101153 = std::__distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (__first, __last, D.101155);
      return D.101153;
    }
  finally
    {
      D.100174 = {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<Gio::TlsCertificate> > >; typename std::iterator_traits<_Iterator>::iterator_category = std::forward_iterator_tag] (const struct ListIterator & D.100173)
{
  struct iterator_category D.101160;

  return D.101160;
}


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<Gio::TlsCertificate> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last, struct input_iterator_tag D.100193)
{
  bool retval.86;
  difference_type D.101163;
  difference_type __n;

  __n = 0;
  goto <D.100237>;
  <D.100238>:
  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator++ (&__first);
  __n = __n + 1;
  <D.100237>:
  retval.86 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator!= (&__first, &__last);
  if (retval.86 != 0) goto <D.100238>; else goto <D.100236>;
  <D.100236>:
  D.101163 = __n;
  return D.101163;
}


Glib::Container_Helpers::ListIterator<Tr>& Glib::Container_Helpers::ListIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >] (struct ListIterator * const this)
{
  const struct GList * D.101165;
  struct GList * D.101166;
  struct ListIterator & D.101167;

  D.101165 = this->node_;
  D.101166 = D.101165->next;
  this->node_ = D.101166;
  D.101167 = this;
  return D.101167;
}


bool Glib::Container_Helpers::ListIterator<Tr>::operator!=(const Glib::Container_Helpers::ListIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >] (const struct ListIterator * const this, const struct ListIterator & rhs)
{
  bool D.101169;
  const struct GList * D.101170;
  const struct GList * D.101171;

  D.101170 = this->node_;
  D.101171 = rhs->node_;
  D.101169 = D.101170 != D.101171;
  return D.101169;
}


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

  if (__n != 0) goto <D.101175>; else goto <D.101176>;
  <D.101175>:
  D.101177 = &this->_M_impl;
  iftmp.87 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::allocate (D.101177, __n);
  goto <D.101178>;
  <D.101176>:
  iftmp.87 = 0B;
  <D.101178>:
  D.101173 = iftmp.87;
  return D.101173;
}


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<Gio::TlsCertificate> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<Gio::TlsCertificate>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct RefPtr * D.101181;

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Gio::TlsCertificate>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.97944)
{
  bool retval.88;
  long unsigned int D.101185;
  struct RefPtr * D.101188;
  long unsigned int D.101189;

  D.101185 = __gnu_cxx::new_allocator<Glib::RefPtr<Gio::TlsCertificate> >::max_size (this);
  retval.88 = D.101185 < __n;
  if (retval.88 != 0) goto <D.101186>; else goto <D.101187>;
  <D.101186>:
  std::__throw_bad_alloc ();
  <D.101187>:
  D.101189 = __n * 8;
  D.101188 = operator new (D.101189);
  return D.101188;
}


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

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


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

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


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

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


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

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


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >; _ForwardIterator = Glib::RefPtr<Gio::TlsCertificate>*; bool _TrivialValueTypes = false] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct value_type D.100255;
  struct RefPtr * D.101203;
  bool retval.89;
  struct RefPtr * D.101205;
  void * D.101206;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.100259>;
      <D.100258>:
      D.100255 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.101203 = std::__addressof<Glib::RefPtr<Gio::TlsCertificate> > (__cur);
          std::_Construct<Glib::RefPtr<Gio::TlsCertificate>, Glib::RefPtr<Gio::TlsCertificate> > (D.101203, &D.100255);
        }
      finally
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100255);
          D.100255 = {CLOBBER};
        }
      Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.100259>:
      retval.89 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator!= (&__first, &__last);
      if (retval.89 != 0) goto <D.100258>; else goto <D.100256>;
      <D.100256>:
      D.101205 = __cur;
      return D.101205;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.101206 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.101206);
              std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*> (__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<Gio::TlsCertificate> >; Glib::Container_Helpers::ListIterator<Tr>::value_type = Glib::RefPtr<Gio::TlsCertificate>] (const struct ListIterator * const this)
{
  const struct GList * D.101213;
  void * D.101214;

  D.101213 = this->node_;
  D.101214 = D.101213->data;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >::to_cpp_type (D.101214); [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 = Gio::TlsCertificate; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CppType = Glib::RefPtr<Gio::TlsCertificate>; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType = _GTlsCertificate*; typename T::BaseObjectType = _GTlsCertificate] (struct BaseObjectType * ptr)
{
  struct TlsCertificate * iftmp.90;
  struct ObjectBase * D.101218;
  struct GObject * cobj;

  cobj = ptr;
  D.101218 = Glib::wrap_auto (cobj, 1);
  if (D.101218 == 0B) goto <D.101219>; else goto <D.101220>;
  <D.101219>:
  iftmp.90 = 0B;
  goto <D.101221>;
  <D.101220>:
  iftmp.90 = __dynamic_cast (D.101218, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14TlsCertificateE, -1);
  <D.101221>:
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, iftmp.90);
  return <retval>;
}


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

  D.101224 = __r;
  return D.101224;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::RefPtr<Gio::TlsCertificate>; _T2 = Glib::RefPtr<Gio::TlsCertificate>] (struct RefPtr * __p, const struct RefPtr & __value)
{
  void * D.100230;
  void * D.100231;
  struct RefPtr * iftmp.91;

  D.100230 = __p;
  D.100231 = operator new (8, D.100230);
  if (D.100231 != 0B) goto <D.101227>; else goto <D.101228>;
  <D.101227>:
  try
    {
      Glib::RefPtr<Gio::TlsCertificate>::RefPtr (D.100231, __value);
    }
  catch
    {
      operator delete (D.100231, D.100230);
    }
  iftmp.91 = D.100231;
  goto <D.101229>;
  <D.101228>:
  iftmp.91 = D.100231;
  <D.101229>:
}


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

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


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::TlsCertificate] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct TlsCertificate * D.101234;
  struct TlsCertificate * D.101235;
  int (*__vtbl_ptr_type) () * D.101238;
  int (*__vtbl_ptr_type) () * D.101239;
  long int D.101240;
  sizetype D.101241;
  struct ObjectBase * D.101242;
  int (*__vtbl_ptr_type) () * D.101243;
  int (*__vtbl_ptr_type) () * D.101244;
  int (*__vtbl_ptr_type) () D.101245;

  D.101234 = src->pCppObject_;
  this->pCppObject_ = D.101234;
  D.101235 = this->pCppObject_;
  if (D.101235 != 0B) goto <D.101236>; else goto <D.101237>;
  <D.101236>:
  D.101235 = this->pCppObject_;
  D.101235 = this->pCppObject_;
  D.101238 = D.101235->D.96669._vptr.Object;
  D.101239 = D.101238 + 18446744073709551592;
  D.101240 = MEM[(long int *)D.101239];
  D.101241 = (sizetype) D.101240;
  D.101242 = D.101235 + D.101241;
  D.101235 = this->pCppObject_;
  D.101235 = this->pCppObject_;
  D.101238 = D.101235->D.96669._vptr.Object;
  D.101239 = D.101238 + 18446744073709551592;
  D.101240 = MEM[(long int *)D.101239];
  D.101241 = (sizetype) D.101240;
  D.101242 = D.101235 + D.101241;
  D.101243 = D.101242->_vptr.ObjectBase;
  D.101244 = D.101243 + 16;
  D.101245 = *D.101244;
  D.101235 = this->pCppObject_;
  D.101235 = this->pCppObject_;
  D.101238 = D.101235->D.96669._vptr.Object;
  D.101239 = D.101238 + 18446744073709551592;
  D.101240 = MEM[(long int *)D.101239];
  D.101241 = (sizetype) D.101240;
  D.101242 = D.101235 + D.101241;
  OBJ_TYPE_REF(D.101245;(const struct ObjectBase)D.101242->2) (D.101242);
  goto <D.101246>;
  <D.101237>:
  <D.101246>:
}


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

  try
    {

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


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

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


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

  goto <D.100116>;
  <D.100115>:
  D.101248 = std::__addressof<Glib::RefPtr<Gio::TlsCertificate> > (__first);
  std::_Destroy<Glib::RefPtr<Gio::TlsCertificate> > (D.101248);
  __first = __first + 8;
  <D.100116>:
  if (__first != __last) goto <D.100115>; else goto <D.100113>;
  <D.100113>:
}


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


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct _Vector_base * const this)
{
  struct RefPtr * D.101249;
  long int D.101250;
  struct RefPtr * D.101251;
  long int D.101252;
  long int D.101253;
  long int D.101254;
  long unsigned int D.101255;
  struct _Vector_impl * D.101256;

  {
    try
      {
        try
          {
            D.101249 = this->_M_impl._M_end_of_storage;
            D.101250 = (long int) D.101249;
            D.101251 = this->_M_impl._M_start;
            D.101252 = (long int) D.101251;
            D.101253 = D.101250 - D.101252;
            D.101254 = D.101253 /[ex] 8;
            D.101255 = (long unsigned int) D.101254;
            D.101251 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_deallocate (this, D.101251, D.101255);
          }
        finally
          {
            D.101256 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_impl::~_Vector_impl (D.101256);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99729>:
}


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

  if (__p != 0B) goto <D.101259>; else goto <D.101260>;
  <D.101259>:
  D.101261 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::deallocate (D.101261, __p, __n);
  goto <D.101262>;
  <D.101260>:
  <D.101262>:
}


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<Gio::TlsCertificate> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<Gio::TlsCertificate>*; __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<Gio::TlsCertificate> >::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<Gio::TlsCertificate>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Gio::TlsCertificate>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct RefPtr * __p, size_type D.97948)
{
  operator delete (__p);
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<Glib::RefPtr<Gio::TlsCertificate> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.99654>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.101263 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.101263);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


Glib::Container_Helpers::GListKeeper<Tr>::~GListKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >] (struct GListKeeper * const this)
{
  struct GList * D.101265;
  OwnershipType D.101268;
  void * D.101273;

  {
    try
      {
        {
          typedef struct BaseObjectType * CTypeNonConst;

          {
            D.101265 = this->glist_;
            if (D.101265 != 0B) goto <D.101266>; else goto <D.101267>;
            <D.101266>:
            D.101268 = this->ownership_;
            if (D.101268 != 0) goto <D.101269>; else goto <D.101270>;
            <D.101269>:
            {
              {
                D.101268 = this->ownership_;
                if (D.101268 != 1) goto <D.101271>; else goto <D.101272>;
                <D.101271>:
                {
                  {
                    struct GList * node;

                    node = this->glist_;
                    goto <D.99638>;
                    <D.99639>:
                    D.101273 = node->data;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >::release_c_type (D.101273);
                    node = node->next;
                    <D.99638>:
                    if (node != 0B) goto <D.99639>; else goto <D.99640>;
                    <D.99640>:
                  }
                }
                goto <D.101274>;
                <D.101272>:
                <D.101274>:
              }
              D.101265 = this->glist_;
              g_list_free (D.101265);
            }
            goto <D.101275>;
            <D.101270>:
            <D.101275>:
            <D.101267>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99641>:
}


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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct vector * const this)
{
  struct _Vector_base * D.101277;
  struct _Tp_alloc_type & D.101278;
  struct RefPtr * D.101279;
  struct RefPtr * D.101280;

  {
    try
      {
        try
          {
            D.101277 = &this->D.98631;
            D.101278 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.101277);
            D.101279 = this->D.98631._M_impl._M_finish;
            D.101280 = this->D.98631._M_impl._M_start;
            std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*, Glib::RefPtr<Gio::TlsCertificate> > (D.101280, D.101279, D.101278);
          }
        finally
          {
            D.101277 = &this->D.98631;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::~_Vector_base (D.101277);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99342>:
}


void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = Glib::RefPtr<Gio::TlsCertificate>*; _Tp = Glib::RefPtr<Gio::TlsCertificate>] (struct RefPtr * __first, struct RefPtr * __last, struct allocator & D.99335)
{
  std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*> (__first, __last);
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsCertificate::get_issuer() (struct TlsCertificate * const this)
{
  struct GTlsCertificate * D.101284;
  struct GTlsCertificate * D.101285;
  bool retval.92;
  struct TlsCertificate * D.101289;
  int (*__vtbl_ptr_type) () * D.101290;
  int (*__vtbl_ptr_type) () * D.101291;
  long int D.101292;
  sizetype D.101293;
  struct ObjectBase * D.101294;
  int (*__vtbl_ptr_type) () * D.101295;
  int (*__vtbl_ptr_type) () * D.101296;
  int (*__vtbl_ptr_type) () D.101297;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.101284 = Gio::TlsCertificate::gobj (this);
  D.101285 = g_tls_certificate_get_issuer (D.101284);
  *<retval> = Glib::wrap (D.101285, 0); [return slot optimization]
  try
    {
      retval.92 = Glib::RefPtr<Gio::TlsCertificate>::operator bool (<retval>);
      if (retval.92 != 0) goto <D.101287>; else goto <D.101288>;
      <D.101287>:
      D.101289 = Glib::RefPtr<Gio::TlsCertificate>::operator-> (<retval>);
      D.101290 = D.101289->D.96669._vptr.Object;
      D.101291 = D.101290 + 18446744073709551592;
      D.101292 = MEM[(long int *)D.101291];
      D.101293 = (sizetype) D.101292;
      D.101294 = D.101289 + D.101293;
      D.101290 = D.101289->D.96669._vptr.Object;
      D.101291 = D.101290 + 18446744073709551592;
      D.101292 = MEM[(long int *)D.101291];
      D.101293 = (sizetype) D.101292;
      D.101294 = D.101289 + D.101293;
      D.101295 = D.101294->_vptr.ObjectBase;
      D.101296 = D.101295 + 16;
      D.101297 = *D.101296;
      D.101290 = D.101289->D.96669._vptr.Object;
      D.101291 = D.101290 + 18446744073709551592;
      D.101292 = MEM[(long int *)D.101291];
      D.101293 = (sizetype) D.101292;
      D.101294 = D.101289 + D.101293;
      OBJ_TYPE_REF(D.101297;(const struct ObjectBase)D.101294->2) (D.101294);
      goto <D.101298>;
      <D.101288>:
      <D.101298>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::TlsCertificate] (const struct RefPtr * const this)
{
  bool D.101302;
  struct TlsCertificate * D.101303;

  D.101303 = this->pCppObject_;
  D.101302 = D.101303 != 0B;
  return D.101302;
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsCertificate::get_issuer() const (const struct TlsCertificate * const this)
{
  struct RefPtr D.98676;

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


Gio::TlsCertificateFlags Gio::TlsCertificate::verify(const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsCertificate * const this, const struct RefPtr & identity, const struct RefPtr & trusted_ca)
{
  TlsCertificateFlags D.101309;
  const struct BaseObjectType * D.101310;
  const struct BaseObjectType * D.101311;
  const struct GTlsCertificate * D.101312;

  D.101310 = Glib::unwrap<Gio::TlsCertificate> (trusted_ca);
  D.101311 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.101312 = Gio::TlsCertificate::gobj (this);
  D.101309 = g_tls_certificate_verify (D.101312, D.101311, D.101310);
  return D.101309;
}


const typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<const T>&) [with T = Gio::TlsCertificate; typename T::BaseObjectType = _GTlsCertificate] (const struct RefPtr & ptr)
{
  const struct BaseObjectType * D.101317;
  const struct BaseObjectType * iftmp.93;
  bool D.101319;
  const struct TlsCertificate * D.101322;

  D.101319 = Glib::RefPtr<const Gio::TlsCertificate>::operator bool (ptr);
  if (D.101319 != 0) goto <D.101320>; else goto <D.101321>;
  <D.101320>:
  D.101322 = Glib::RefPtr<const Gio::TlsCertificate>::operator-> (ptr);
  iftmp.93 = Gio::TlsCertificate::gobj (D.101322);
  goto <D.101323>;
  <D.101321>:
  iftmp.93 = 0B;
  <D.101323>:
  D.101317 = iftmp.93;
  return D.101317;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = const Gio::TlsCertificate] (const struct RefPtr * const this)
{
  bool D.101325;
  const struct TlsCertificate * D.101326;

  D.101326 = this->pCppObject_;
  D.101325 = D.101326 != 0B;
  return D.101325;
}


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

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


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.101330;
  const struct BaseObjectType * iftmp.94;
  bool D.101332;
  const struct SocketConnectable * D.101335;

  D.101332 = Glib::RefPtr<const Gio::SocketConnectable>::operator bool (ptr);
  if (D.101332 != 0) goto <D.101333>; else goto <D.101334>;
  <D.101333>:
  D.101335 = Glib::RefPtr<const Gio::SocketConnectable>::operator-> (ptr);
  iftmp.94 = Gio::SocketConnectable::gobj (D.101335);
  goto <D.101336>;
  <D.101334>:
  iftmp.94 = 0B;
  <D.101336>:
  D.101330 = iftmp.94;
  return D.101330;
}


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

  D.101339 = this->pCppObject_;
  D.101338 = D.101339 != 0B;
  return D.101338;
}


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

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


const GSocketConnectable* Gio::SocketConnectable::gobj() const (const struct SocketConnectable * const this)
{
  const struct GSocketConnectable * D.101343;
  int (*__vtbl_ptr_type) () * D.101344;
  int (*__vtbl_ptr_type) () * D.101345;
  long int D.101346;
  sizetype D.101347;
  const struct ObjectBase * D.101348;

  D.101344 = this->D.97209._vptr.Interface;
  D.101345 = D.101344 + 18446744073709551592;
  D.101346 = MEM[(long int *)D.101345];
  D.101347 = (sizetype) D.101346;
  D.101348 = this + D.101347;
  D.101343 = D.101348->gobject_;
  return D.101343;
}


const GTlsCertificate* Gio::TlsCertificate::gobj() const (const struct TlsCertificate * const this)
{
  const struct GTlsCertificate * D.101350;
  int (*__vtbl_ptr_type) () * D.101351;
  int (*__vtbl_ptr_type) () * D.101352;
  long int D.101353;
  sizetype D.101354;
  const struct ObjectBase * D.101355;

  D.101351 = this->D.96669._vptr.Object;
  D.101352 = D.101351 + 18446744073709551592;
  D.101353 = MEM[(long int *)D.101352];
  D.101354 = (sizetype) D.101353;
  D.101355 = this + D.101354;
  D.101350 = D.101355->gobject_;
  return D.101350;
}


Gio::TlsCertificateFlags Gio::TlsCertificate::verify(const Glib::RefPtr<const Gio::SocketConnectable>&) const (const struct TlsCertificate * const this, const struct RefPtr & identity)
{
  TlsCertificateFlags D.101357;
  const struct BaseObjectType * D.101358;
  const struct GTlsCertificate * D.101359;

  D.101358 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.101359 = Gio::TlsCertificate::gobj (this);
  D.101357 = g_tls_certificate_verify (D.101359, D.101358, 0B);
  return D.101357;
}


Gio::TlsCertificateFlags Gio::TlsCertificate::verify(const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsCertificate * const this, const struct RefPtr & trusted_ca)
{
  TlsCertificateFlags D.101363;
  const struct BaseObjectType * D.101364;
  const struct GTlsCertificate * D.101365;

  D.101364 = Glib::unwrap<Gio::TlsCertificate> (trusted_ca);
  D.101365 = Gio::TlsCertificate::gobj (this);
  D.101363 = g_tls_certificate_verify (D.101365, 0B, D.101364);
  return D.101363;
}


Gio::TlsCertificateFlags Gio::TlsCertificate::verify() const (const struct TlsCertificate * const this)
{
  TlsCertificateFlags D.101369;
  const struct GTlsCertificate * D.101370;

  D.101370 = Gio::TlsCertificate::gobj (this);
  D.101369 = g_tls_certificate_verify (D.101370, 0B, 0B);
  return D.101369;
}


bool Gio::TlsCertificate::is_same(const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsCertificate * const this, const struct RefPtr & cert_two)
{
  bool D.101373;
  const struct BaseObjectType * D.101374;
  const struct GTlsCertificate * D.101375;
  int D.101376;

  D.101374 = Glib::unwrap<Gio::TlsCertificate> (cert_two);
  D.101375 = Gio::TlsCertificate::gobj (this);
  D.101376 = g_tls_certificate_is_same (D.101375, D.101374);
  D.101373 = D.101376 != 0;
  return D.101373;
}


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Glib::ByteArray> > Gio::TlsCertificate::property_certificate() const (const struct TlsCertificate * const this)
{
  int (*__vtbl_ptr_type) () * D.101381;
  int (*__vtbl_ptr_type) () * D.101382;
  long int D.101383;
  sizetype D.101384;
  const struct ObjectBase * D.101385;

  D.101381 = this->D.96669._vptr.Object;
  D.101382 = D.101381 + 18446744073709551592;
  D.101383 = MEM[(long int *)D.101382];
  D.101384 = (sizetype) D.101383;
  D.101385 = this + D.101384;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Glib::ByteArray> >::PropertyProxy_ReadOnly (<retval>, D.101385, "certificate");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<std::basic_string<char> > Gio::TlsCertificate::property_certificate_pem() const (const struct TlsCertificate * const this)
{
  int (*__vtbl_ptr_type) () * D.101389;
  int (*__vtbl_ptr_type) () * D.101390;
  long int D.101391;
  sizetype D.101392;
  const struct ObjectBase * D.101393;

  D.101389 = this->D.96669._vptr.Object;
  D.101390 = D.101389 + 18446744073709551592;
  D.101391 = MEM[(long int *)D.101390];
  D.101392 = (sizetype) D.101391;
  D.101393 = this + D.101392;
  Glib::PropertyProxy_ReadOnly<std::basic_string<char> >::PropertyProxy_ReadOnly (<retval>, D.101393, "certificate-pem");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsCertificate::property_issuer() const (const struct TlsCertificate * const this)
{
  int (*__vtbl_ptr_type) () * D.101397;
  int (*__vtbl_ptr_type) () * D.101398;
  long int D.101399;
  sizetype D.101400;
  const struct ObjectBase * D.101401;

  D.101397 = this->D.96669._vptr.Object;
  D.101398 = D.101397 + 18446744073709551592;
  D.101399 = MEM[(long int *)D.101398];
  D.101400 = (sizetype) D.101399;
  D.101401 = this + D.101400;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::TlsCertificate> >::PropertyProxy_ReadOnly (<retval>, D.101401, "issuer");
  return <retval>;
}


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

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


virtual Gio::TlsCertificateFlags Gio::TlsCertificate::verify_vfunc(const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsCertificate * const this, const struct RefPtr & identity, const struct RefPtr & trusted_ca)
{
  int (*__vtbl_ptr_type) () * D.101404;
  int (*__vtbl_ptr_type) () * D.101405;
  long int D.101406;
  sizetype D.101407;
  const struct ObjectBase * D.101408;
  struct GObject * D.101409;
  struct GTypeClass * D.101410;
  GTlsCertificateFlags (*<T11166>) (struct GTlsCertificate *, struct GSocketConnectable *, struct GTlsCertificate *) D.101413;
  const struct BaseObjectType * D.101416;
  const struct BaseObjectType * D.101417;
  const struct GTlsCertificate * D.101418;
  TlsCertificateFlags D.101419;
  struct BaseClassType * const base;
  typedef RType RType;

  D.101404 = this->D.96669._vptr.Object;
  D.101405 = D.101404 + 18446744073709551592;
  D.101406 = MEM[(long int *)D.101405];
  D.101407 = (sizetype) D.101406;
  D.101408 = this + D.101407;
  D.101409 = D.101408->gobject_;
  D.101410 = MEM[(struct GTypeInstance *)D.101409].g_class;
  base = g_type_class_peek_parent (D.101410);
  {
    if (base != 0B) goto <D.101411>; else goto <D.101412>;
    <D.101411>:
    D.101413 = base->verify;
    if (D.101413 != 0B) goto <D.101414>; else goto <D.101415>;
    <D.101414>:
    {
      TlsCertificateFlags retval;

      D.101413 = base->verify;
      D.101416 = Glib::unwrap<Gio::TlsCertificate> (trusted_ca);
      D.101417 = Glib::unwrap<Gio::SocketConnectable> (identity);
      D.101418 = Gio::TlsCertificate::gobj (this);
      retval = D.101413 (D.101418, D.101417, D.101416);
      D.101419 = retval;
      return D.101419;
    }
    <D.101415>:
    <D.101412>:
  }
  D.101419 = 0;
  return D.101419;
}