static GType Glib::Value<Gio::TlsDatabaseVerifyFlags>::value_type() ()
{
  GType D.104895;

  D.104895 = g_tls_database_verify_flags_get_type ();
  return D.104895;
}


static GType Glib::Value<Gio::TlsDatabaseLookupFlags>::value_type() ()
{
  GType D.104898;

  D.104898 = g_tls_database_lookup_flags_get_type ();
  return D.104898;
}


Glib::RefPtr<Gio::TlsDatabase> Glib::wrap(GTlsDatabase*, bool) (struct GTlsDatabase * object, bool take_copy)
{
  struct TlsDatabase * iftmp.0;
  int D.104903;
  struct ObjectBase * D.104904;

  D.104903 = (int) take_copy;
  D.104904 = Glib::wrap_auto (object, D.104903);
  if (D.104904 == 0B) goto <D.104905>; else goto <D.104906>;
  <D.104905>:
  iftmp.0 = 0B;
  goto <D.104907>;
  <D.104906>:
  iftmp.0 = __dynamic_cast (D.104904, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
  <D.104907>:
  Glib::RefPtr<Gio::TlsDatabase>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::TlsDatabase_Class::init() (struct TlsDatabase_Class * const this)
{
  long unsigned int D.104910;
  long unsigned int D.104913;
  struct Class * D.104914;
  const struct Class & D.104916;

  D.104910 = this->D.97330.gtype_;
  if (D.104910 == 0) goto <D.104911>; else goto <D.104912>;
  <D.104911>:
  this->D.97330.class_init_func_ = class_init_function;
  D.104913 = g_tls_database_get_type ();
  D.104914 = &this->D.97330;
  Glib::Class::register_derived_type (D.104914, D.104913);
  goto <D.104915>;
  <D.104912>:
  <D.104915>:
  D.104916 = &this->D.97330;
  return D.104916;
}


static void Gio::TlsDatabase_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_chain = verify_chain_vfunc_callback;
  klass->verify_chain_async = verify_chain_async_vfunc_callback;
  klass->verify_chain_finish = verify_chain_finish_vfunc_callback;
  klass->create_certificate_handle = create_certificate_handle_vfunc_callback;
  klass->lookup_certificate_for_handle = lookup_certificate_for_handle_vfunc_callback;
  klass->lookup_certificate_for_handle_async = lookup_certificate_for_handle_async_vfunc_callback;
  klass->lookup_certificate_for_handle_finish = lookup_certificate_for_handle_finish_vfunc_callback;
  klass->lookup_certificate_issuer = lookup_certificate_issuer_vfunc_callback;
  klass->lookup_certificate_issuer_async = lookup_certificate_issuer_async_vfunc_callback;
  klass->lookup_certificate_issuer_finish = lookup_certificate_issuer_finish_vfunc_callback;
  klass->lookup_certificates_issued_by = lookup_certificates_issued_by_vfunc_callback;
  klass->lookup_certificates_issued_by_async = lookup_certificates_issued_by_async_vfunc_callback;
  klass->lookup_certificates_issued_by_finish = lookup_certificates_issued_by_finish_vfunc_callback;
}


static GTlsCertificateFlags Gio::TlsDatabase_Class::verify_chain_vfunc_callback(GTlsDatabase*, GTlsCertificate*, const gchar*, GSocketConnectable*, GTlsInteraction*, GTlsDatabaseVerifyFlags, GCancellable*, GError**) (struct GTlsDatabase * self, struct GTlsCertificate * chain, const gchar * purpose, struct GSocketConnectable * identity, struct GTlsInteraction * interaction, GTlsDatabaseVerifyFlags flags, struct GCancellable * cancellable, struct GError * * error)
{
  bool retval.1;
  bool iftmp.2;
  bool D.104924;
  struct CppObjectType * const iftmp.3;
  GTlsCertificateFlags D.104934;
  int (*__vtbl_ptr_type) () * D.104935;
  int (*__vtbl_ptr_type) () * D.104936;
  int (*__vtbl_ptr_type) () D.104937;
  struct RefPtr D.99715;
  struct RefPtr D.99590;
  const struct RefPtr D.99849;
  struct RefPtr D.99465;
  struct ustring D.99340;
  struct RefPtr D.99339;
  void * D.104938;
  struct GTypeClass * D.104941;
  GTlsCertificateFlags (*<T1124f>) (struct GTlsDatabase *, struct GTlsCertificate *, const gchar *, struct GSocketConnectable *, struct GTlsInteraction *, GTlsDatabaseVerifyFlags, struct GCancellable *, struct GError * *) D.104944;
  struct GError * D.104947;
  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.104923>; else goto <D.104921>;
    <D.104923>:
    D.104924 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.104924 != 0) goto <D.104925>; else goto <D.104921>;
    <D.104925>:
    iftmp.2 = 1;
    goto <D.104922>;
    <D.104921>:
    iftmp.2 = 0;
    <D.104922>:
    retval.1 = iftmp.2;
    if (retval.1 != 0) goto <D.104926>; else goto <D.104927>;
    <D.104926>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.104929>; else goto <D.104930>;
      <D.104929>:
      iftmp.3 = 0B;
      goto <D.104931>;
      <D.104930>:
      iftmp.3 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.104931>:
      obj = iftmp.3;
      if (obj != 0B) goto <D.104932>; else goto <D.104933>;
      <D.104932>:
      try
        {
          D.104935 = obj->D.97204._vptr.Object;
          D.104936 = D.104935 + 16;
          D.104937 = *D.104936;
          D.99715 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.99590 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.99465 = Glib::wrap (identity, 1); [return slot optimization]
                  try
                    {
                      Glib::RefPtr<const Gio::SocketConnectable>::RefPtr<Gio::SocketConnectable> (&D.99849, &D.99465);
                      try
                        {
                          D.99340 = Glib::convert_const_gchar_ptr_to_ustring (purpose); [return slot optimization]
                          try
                            {
                              D.99339 = Glib::wrap (chain, 1); [return slot optimization]
                              try
                                {
                                  D.104934 = OBJ_TYPE_REF(D.104937;(const struct TlsDatabase)obj->2) (obj, &D.99339, &D.99340, &D.99849, &D.99590, &D.99715, flags);
                                  return D.104934;
                                }
                              finally
                                {
                                  Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.99339);
                                  D.99339 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              Glib::ustring::~ustring (&D.99340);
                              D.99340 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          Glib::RefPtr<const Gio::SocketConnectable>::~RefPtr (&D.99849);
                          D.99849 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (&D.99465);
                      D.99465 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.99590);
                  D.99590 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.99715);
              D.99715 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.104938 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.104938);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.104939>;
      <D.104933>:
      <D.104939>:
    }
    goto <D.104940>;
    <D.104927>:
    <D.104940>:
  }
  D.104941 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.104941);
  {
    if (base != 0B) goto <D.104942>; else goto <D.104943>;
    <D.104942>:
    D.104944 = base->verify_chain;
    if (D.104944 != 0B) goto <D.104945>; else goto <D.104946>;
    <D.104945>:
    {
      GTlsCertificateFlags retval;

      D.104944 = base->verify_chain;
      retval = D.104944 (self, chain, purpose, identity, interaction, flags, cancellable, error);
      D.104947 = *error;
      if (D.104947 != 0B) goto <D.104948>; else goto <D.104949>;
      <D.104948>:
      D.104947 = *error;
      Glib::Error::throw_exception (D.104947);
      <D.104949>:
      D.104934 = retval;
      return D.104934;
    }
    <D.104946>:
    <D.104943>:
  }
  D.104934 = 0;
  return D.104934;
}


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.104972;
  const struct SocketConnectable * D.104973;
  int (*__vtbl_ptr_type) () * D.104976;
  int (*__vtbl_ptr_type) () * D.104977;
  long int D.104978;
  sizetype D.104979;
  const struct ObjectBase * D.104980;
  int (*__vtbl_ptr_type) () * D.104981;
  int (*__vtbl_ptr_type) () * D.104982;
  int (*__vtbl_ptr_type) () D.104983;

  D.104972 = Glib::RefPtr<Gio::SocketConnectable>::operator-> (src);
  this->pCppObject_ = D.104972;
  D.104973 = this->pCppObject_;
  if (D.104973 != 0B) goto <D.104974>; else goto <D.104975>;
  <D.104974>:
  D.104973 = this->pCppObject_;
  D.104973 = this->pCppObject_;
  D.104976 = D.104973->D.97692._vptr.Interface;
  D.104977 = D.104976 + 18446744073709551592;
  D.104978 = MEM[(long int *)D.104977];
  D.104979 = (sizetype) D.104978;
  D.104980 = D.104973 + D.104979;
  D.104973 = this->pCppObject_;
  D.104973 = this->pCppObject_;
  D.104976 = D.104973->D.97692._vptr.Interface;
  D.104977 = D.104976 + 18446744073709551592;
  D.104978 = MEM[(long int *)D.104977];
  D.104979 = (sizetype) D.104978;
  D.104980 = D.104973 + D.104979;
  D.104981 = D.104980->_vptr.ObjectBase;
  D.104982 = D.104981 + 16;
  D.104983 = *D.104982;
  D.104973 = this->pCppObject_;
  D.104973 = this->pCppObject_;
  D.104976 = D.104973->D.97692._vptr.Interface;
  D.104977 = D.104976 + 18446744073709551592;
  D.104978 = MEM[(long int *)D.104977];
  D.104979 = (sizetype) D.104978;
  D.104980 = D.104973 + D.104979;
  OBJ_TYPE_REF(D.104983;(const struct ObjectBase)D.104980->2) (D.104980);
  goto <D.104984>;
  <D.104975>:
  <D.104984>:
}


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

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


Glib::ustring Glib::convert_const_gchar_ptr_to_ustring(const char*) (const char * str)
{
  struct ustring * D.104990;

  if (str != 0B) goto <D.104988>; else goto <D.104989>;
  <D.104988>:
  D.104990 = <retval>;
  Glib::ustring::ustring (D.104990, str);
  goto <D.104991>;
  <D.104989>:
  D.104990 = <retval>;
  Glib::ustring::ustring (D.104990);
  <D.104991>:
  return <retval>;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::TlsCertificate] (struct RefPtr * const this)
{
  struct TlsCertificate * D.104993;
  int (*__vtbl_ptr_type) () * D.104996;
  int (*__vtbl_ptr_type) () * D.104997;
  long int D.104998;
  sizetype D.104999;
  struct ObjectBase * D.105000;
  int (*__vtbl_ptr_type) () * D.105001;
  int (*__vtbl_ptr_type) () * D.105002;
  int (*__vtbl_ptr_type) () D.105003;

  {
    try
      {
        D.104993 = this->pCppObject_;
        if (D.104993 != 0B) goto <D.104994>; else goto <D.104995>;
        <D.104994>:
        D.104993 = this->pCppObject_;
        D.104993 = this->pCppObject_;
        D.104996 = D.104993->D.97883._vptr.Object;
        D.104997 = D.104996 + 18446744073709551592;
        D.104998 = MEM[(long int *)D.104997];
        D.104999 = (sizetype) D.104998;
        D.105000 = D.104993 + D.104999;
        D.104993 = this->pCppObject_;
        D.104993 = this->pCppObject_;
        D.104996 = D.104993->D.97883._vptr.Object;
        D.104997 = D.104996 + 18446744073709551592;
        D.104998 = MEM[(long int *)D.104997];
        D.104999 = (sizetype) D.104998;
        D.105000 = D.104993 + D.104999;
        D.105001 = D.105000->_vptr.ObjectBase;
        D.105002 = D.105001 + 24;
        D.105003 = *D.105002;
        D.104993 = this->pCppObject_;
        D.104993 = this->pCppObject_;
        D.104996 = D.104993->D.97883._vptr.Object;
        D.104997 = D.104996 + 18446744073709551592;
        D.104998 = MEM[(long int *)D.104997];
        D.104999 = (sizetype) D.104998;
        D.105000 = D.104993 + D.104999;
        OBJ_TYPE_REF(D.105003;(const struct ObjectBase)D.105000->3) (D.105000);
        goto <D.105004>;
        <D.104995>:
        <D.105004>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103142>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Gio::SocketConnectable] (struct RefPtr * const this)
{
  const struct SocketConnectable * D.105006;
  int (*__vtbl_ptr_type) () * D.105009;
  int (*__vtbl_ptr_type) () * D.105010;
  long int D.105011;
  sizetype D.105012;
  const struct ObjectBase * D.105013;
  int (*__vtbl_ptr_type) () * D.105014;
  int (*__vtbl_ptr_type) () * D.105015;
  int (*__vtbl_ptr_type) () D.105016;

  {
    try
      {
        D.105006 = this->pCppObject_;
        if (D.105006 != 0B) goto <D.105007>; else goto <D.105008>;
        <D.105007>:
        D.105006 = this->pCppObject_;
        D.105006 = this->pCppObject_;
        D.105009 = D.105006->D.97692._vptr.Interface;
        D.105010 = D.105009 + 18446744073709551592;
        D.105011 = MEM[(long int *)D.105010];
        D.105012 = (sizetype) D.105011;
        D.105013 = D.105006 + D.105012;
        D.105006 = this->pCppObject_;
        D.105006 = this->pCppObject_;
        D.105009 = D.105006->D.97692._vptr.Interface;
        D.105010 = D.105009 + 18446744073709551592;
        D.105011 = MEM[(long int *)D.105010];
        D.105012 = (sizetype) D.105011;
        D.105013 = D.105006 + D.105012;
        D.105014 = D.105013->_vptr.ObjectBase;
        D.105015 = D.105014 + 24;
        D.105016 = *D.105015;
        D.105006 = this->pCppObject_;
        D.105006 = this->pCppObject_;
        D.105009 = D.105006->D.97692._vptr.Interface;
        D.105010 = D.105009 + 18446744073709551592;
        D.105011 = MEM[(long int *)D.105010];
        D.105012 = (sizetype) D.105011;
        D.105013 = D.105006 + D.105012;
        OBJ_TYPE_REF(D.105016;(const struct ObjectBase)D.105013->3) (D.105013);
        goto <D.105017>;
        <D.105008>:
        <D.105017>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103180>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::SocketConnectable] (struct RefPtr * const this)
{
  struct SocketConnectable * D.105019;
  int (*__vtbl_ptr_type) () * D.105022;
  int (*__vtbl_ptr_type) () * D.105023;
  long int D.105024;
  sizetype D.105025;
  struct ObjectBase * D.105026;
  int (*__vtbl_ptr_type) () * D.105027;
  int (*__vtbl_ptr_type) () * D.105028;
  int (*__vtbl_ptr_type) () D.105029;

  {
    try
      {
        D.105019 = this->pCppObject_;
        if (D.105019 != 0B) goto <D.105020>; else goto <D.105021>;
        <D.105020>:
        D.105019 = this->pCppObject_;
        D.105019 = this->pCppObject_;
        D.105022 = D.105019->D.97692._vptr.Interface;
        D.105023 = D.105022 + 18446744073709551592;
        D.105024 = MEM[(long int *)D.105023];
        D.105025 = (sizetype) D.105024;
        D.105026 = D.105019 + D.105025;
        D.105019 = this->pCppObject_;
        D.105019 = this->pCppObject_;
        D.105022 = D.105019->D.97692._vptr.Interface;
        D.105023 = D.105022 + 18446744073709551592;
        D.105024 = MEM[(long int *)D.105023];
        D.105025 = (sizetype) D.105024;
        D.105026 = D.105019 + D.105025;
        D.105027 = D.105026->_vptr.ObjectBase;
        D.105028 = D.105027 + 24;
        D.105029 = *D.105028;
        D.105019 = this->pCppObject_;
        D.105019 = this->pCppObject_;
        D.105022 = D.105019->D.97692._vptr.Interface;
        D.105023 = D.105022 + 18446744073709551592;
        D.105024 = MEM[(long int *)D.105023];
        D.105025 = (sizetype) D.105024;
        D.105026 = D.105019 + D.105025;
        OBJ_TYPE_REF(D.105029;(const struct ObjectBase)D.105026->3) (D.105026);
        goto <D.105030>;
        <D.105021>:
        <D.105030>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103149>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::TlsInteraction] (struct RefPtr * const this)
{
  struct TlsInteraction * D.105032;
  int (*__vtbl_ptr_type) () * D.105035;
  int (*__vtbl_ptr_type) () * D.105036;
  long int D.105037;
  sizetype D.105038;
  struct ObjectBase * D.105039;
  int (*__vtbl_ptr_type) () * D.105040;
  int (*__vtbl_ptr_type) () * D.105041;
  int (*__vtbl_ptr_type) () D.105042;

  {
    try
      {
        D.105032 = this->pCppObject_;
        if (D.105032 != 0B) goto <D.105033>; else goto <D.105034>;
        <D.105033>:
        D.105032 = this->pCppObject_;
        D.105032 = this->pCppObject_;
        D.105035 = D.105032->D.99027._vptr.Object;
        D.105036 = D.105035 + 18446744073709551592;
        D.105037 = MEM[(long int *)D.105036];
        D.105038 = (sizetype) D.105037;
        D.105039 = D.105032 + D.105038;
        D.105032 = this->pCppObject_;
        D.105032 = this->pCppObject_;
        D.105035 = D.105032->D.99027._vptr.Object;
        D.105036 = D.105035 + 18446744073709551592;
        D.105037 = MEM[(long int *)D.105036];
        D.105038 = (sizetype) D.105037;
        D.105039 = D.105032 + D.105038;
        D.105040 = D.105039->_vptr.ObjectBase;
        D.105041 = D.105040 + 24;
        D.105042 = *D.105041;
        D.105032 = this->pCppObject_;
        D.105032 = this->pCppObject_;
        D.105035 = D.105032->D.99027._vptr.Object;
        D.105036 = D.105035 + 18446744073709551592;
        D.105037 = MEM[(long int *)D.105036];
        D.105038 = (sizetype) D.105037;
        D.105039 = D.105032 + D.105038;
        OBJ_TYPE_REF(D.105042;(const struct ObjectBase)D.105039->3) (D.105039);
        goto <D.105043>;
        <D.105034>:
        <D.105043>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103156>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Cancellable] (struct RefPtr * const this)
{
  struct Cancellable * D.105045;
  int (*__vtbl_ptr_type) () * D.105048;
  int (*__vtbl_ptr_type) () * D.105049;
  long int D.105050;
  sizetype D.105051;
  struct ObjectBase * D.105052;
  int (*__vtbl_ptr_type) () * D.105053;
  int (*__vtbl_ptr_type) () * D.105054;
  int (*__vtbl_ptr_type) () D.105055;

  {
    try
      {
        D.105045 = this->pCppObject_;
        if (D.105045 != 0B) goto <D.105046>; else goto <D.105047>;
        <D.105046>:
        D.105045 = this->pCppObject_;
        D.105045 = this->pCppObject_;
        D.105048 = D.105045->D.97456._vptr.Object;
        D.105049 = D.105048 + 18446744073709551592;
        D.105050 = MEM[(long int *)D.105049];
        D.105051 = (sizetype) D.105050;
        D.105052 = D.105045 + D.105051;
        D.105045 = this->pCppObject_;
        D.105045 = this->pCppObject_;
        D.105048 = D.105045->D.97456._vptr.Object;
        D.105049 = D.105048 + 18446744073709551592;
        D.105050 = MEM[(long int *)D.105049];
        D.105051 = (sizetype) D.105050;
        D.105052 = D.105045 + D.105051;
        D.105053 = D.105052->_vptr.ObjectBase;
        D.105054 = D.105053 + 24;
        D.105055 = *D.105054;
        D.105045 = this->pCppObject_;
        D.105045 = this->pCppObject_;
        D.105048 = D.105045->D.97456._vptr.Object;
        D.105049 = D.105048 + 18446744073709551592;
        D.105050 = MEM[(long int *)D.105049];
        D.105051 = (sizetype) D.105050;
        D.105052 = D.105045 + D.105051;
        OBJ_TYPE_REF(D.105055;(const struct ObjectBase)D.105052->3) (D.105052);
        goto <D.105056>;
        <D.105047>:
        <D.105056>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103163>:
}


static void Gio::TlsDatabase_Class::verify_chain_async_vfunc_callback(GTlsDatabase*, GTlsCertificate*, const gchar*, GSocketConnectable*, GTlsInteraction*, GTlsDatabaseVerifyFlags, GCancellable*, GAsyncReadyCallback, gpointer) (struct GTlsDatabase * self, struct GTlsCertificate * chain, const gchar * purpose, struct GSocketConnectable * identity, struct GTlsInteraction * interaction, GTlsDatabaseVerifyFlags flags, struct GCancellable * cancellable, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *) callback, void * user_data)
{
  bool retval.4;
  bool iftmp.5;
  bool D.105063;
  struct CppObjectType * const iftmp.6;
  int (*__vtbl_ptr_type) () * D.105073;
  int (*__vtbl_ptr_type) () * D.105074;
  int (*__vtbl_ptr_type) () D.105075;
  struct RefPtr D.99872;
  struct RefPtr D.99871;
  const struct RefPtr D.99873;
  struct RefPtr D.99870;
  struct ustring D.99869;
  struct RefPtr D.99868;
  void * D.105076;
  struct GTypeClass * D.105079;
  void (*<T11253>) (struct GTlsDatabase *, struct GTlsCertificate *, const gchar *, struct GSocketConnectable *, struct GTlsInteraction *, GTlsDatabaseVerifyFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.105082;
  const struct SlotAsyncReady * slot;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  slot = user_data;
  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105062>; else goto <D.105060>;
    <D.105062>:
    D.105063 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105063 != 0) goto <D.105064>; else goto <D.105060>;
    <D.105064>:
    iftmp.5 = 1;
    goto <D.105061>;
    <D.105060>:
    iftmp.5 = 0;
    <D.105061>:
    retval.4 = iftmp.5;
    if (retval.4 != 0) goto <D.105065>; else goto <D.105066>;
    <D.105065>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105068>; else goto <D.105069>;
      <D.105068>:
      iftmp.6 = 0B;
      goto <D.105070>;
      <D.105069>:
      iftmp.6 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105070>:
      obj = iftmp.6;
      if (obj != 0B) goto <D.105071>; else goto <D.105072>;
      <D.105071>:
      try
        {
          D.105073 = obj->D.97204._vptr.Object;
          D.105074 = D.105073 + 24;
          D.105075 = *D.105074;
          D.99872 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.99871 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.99870 = Glib::wrap (identity, 1); [return slot optimization]
                  try
                    {
                      Glib::RefPtr<const Gio::SocketConnectable>::RefPtr<Gio::SocketConnectable> (&D.99873, &D.99870);
                      try
                        {
                          D.99869 = Glib::convert_const_gchar_ptr_to_ustring (purpose); [return slot optimization]
                          try
                            {
                              D.99868 = Glib::wrap (chain, 1); [return slot optimization]
                              try
                                {
                                  OBJ_TYPE_REF(D.105075;(const struct TlsDatabase)obj->3) (obj, &D.99868, &D.99869, &D.99873, &D.99871, slot, &D.99872, flags);
                                }
                              finally
                                {
                                  Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.99868);
                                  D.99868 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              Glib::ustring::~ustring (&D.99869);
                              D.99869 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          Glib::RefPtr<const Gio::SocketConnectable>::~RefPtr (&D.99873);
                          D.99873 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::SocketConnectable>::~RefPtr (&D.99870);
                      D.99870 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.99871);
                  D.99871 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.99872);
              D.99872 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105076 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105076);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105077>;
      <D.105072>:
      <D.105077>:
    }
    goto <D.105078>;
    <D.105066>:
    <D.105078>:
  }
  D.105079 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105079);
  if (base != 0B) goto <D.105080>; else goto <D.105081>;
  <D.105080>:
  D.105082 = base->verify_chain_async;
  if (D.105082 != 0B) goto <D.105083>; else goto <D.105084>;
  <D.105083>:
  D.105082 = base->verify_chain_async;
  D.105082 (self, chain, purpose, identity, interaction, flags, cancellable, callback, user_data);
  goto <D.105085>;
  <D.105084>:
  <D.105085>:
  <D.105081>:
}


static GTlsCertificateFlags Gio::TlsDatabase_Class::verify_chain_finish_vfunc_callback(GTlsDatabase*, GAsyncResult*, GError**) (struct GTlsDatabase * self, struct GAsyncResult * result, struct GError * * error)
{
  bool retval.7;
  bool iftmp.8;
  bool D.105104;
  struct CppObjectType * const iftmp.9;
  GTlsCertificateFlags D.105114;
  int (*__vtbl_ptr_type) () * D.105115;
  int (*__vtbl_ptr_type) () * D.105116;
  int (*__vtbl_ptr_type) () D.105117;
  struct RefPtr D.100007;
  void * D.105118;
  struct GTypeClass * D.105121;
  GTlsCertificateFlags (*<T11257>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.105124;
  struct GError * D.105127;
  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.105103>; else goto <D.105101>;
    <D.105103>:
    D.105104 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105104 != 0) goto <D.105105>; else goto <D.105101>;
    <D.105105>:
    iftmp.8 = 1;
    goto <D.105102>;
    <D.105101>:
    iftmp.8 = 0;
    <D.105102>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.105106>; else goto <D.105107>;
    <D.105106>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105109>; else goto <D.105110>;
      <D.105109>:
      iftmp.9 = 0B;
      goto <D.105111>;
      <D.105110>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105111>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.105112>; else goto <D.105113>;
      <D.105112>:
      try
        {
          D.105115 = obj->D.97204._vptr.Object;
          D.105116 = D.105115 + 32;
          D.105117 = *D.105116;
          D.100007 = Glib::wrap (result, 1); [return slot optimization]
          try
            {
              D.105114 = OBJ_TYPE_REF(D.105117;(struct TlsDatabase)obj->4) (obj, &D.100007);
              return D.105114;
            }
          finally
            {
              Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&D.100007);
              D.100007 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105118 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105118);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105119>;
      <D.105113>:
      <D.105119>:
    }
    goto <D.105120>;
    <D.105107>:
    <D.105120>:
  }
  D.105121 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105121);
  {
    if (base != 0B) goto <D.105122>; else goto <D.105123>;
    <D.105122>:
    D.105124 = base->verify_chain_finish;
    if (D.105124 != 0B) goto <D.105125>; else goto <D.105126>;
    <D.105125>:
    {
      GTlsCertificateFlags retval;

      D.105124 = base->verify_chain_finish;
      retval = D.105124 (self, result, error);
      D.105127 = *error;
      if (D.105127 != 0B) goto <D.105128>; else goto <D.105129>;
      <D.105128>:
      D.105127 = *error;
      Glib::Error::throw_exception (D.105127);
      <D.105129>:
      D.105114 = retval;
      return D.105114;
    }
    <D.105126>:
    <D.105123>:
  }
  D.105114 = 0;
  return D.105114;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::AsyncResult] (struct RefPtr * const this)
{
  struct AsyncResult * D.105141;
  int (*__vtbl_ptr_type) () * D.105144;
  int (*__vtbl_ptr_type) () * D.105145;
  long int D.105146;
  sizetype D.105147;
  struct ObjectBase * D.105148;
  int (*__vtbl_ptr_type) () * D.105149;
  int (*__vtbl_ptr_type) () * D.105150;
  int (*__vtbl_ptr_type) () D.105151;

  {
    try
      {
        D.105141 = this->pCppObject_;
        if (D.105141 != 0B) goto <D.105142>; else goto <D.105143>;
        <D.105142>:
        D.105141 = this->pCppObject_;
        D.105141 = this->pCppObject_;
        D.105144 = D.105141->D.86030._vptr.Interface;
        D.105145 = D.105144 + 18446744073709551592;
        D.105146 = MEM[(long int *)D.105145];
        D.105147 = (sizetype) D.105146;
        D.105148 = D.105141 + D.105147;
        D.105141 = this->pCppObject_;
        D.105141 = this->pCppObject_;
        D.105144 = D.105141->D.86030._vptr.Interface;
        D.105145 = D.105144 + 18446744073709551592;
        D.105146 = MEM[(long int *)D.105145];
        D.105147 = (sizetype) D.105146;
        D.105148 = D.105141 + D.105147;
        D.105149 = D.105148->_vptr.ObjectBase;
        D.105150 = D.105149 + 24;
        D.105151 = *D.105150;
        D.105141 = this->pCppObject_;
        D.105141 = this->pCppObject_;
        D.105144 = D.105141->D.86030._vptr.Interface;
        D.105145 = D.105144 + 18446744073709551592;
        D.105146 = MEM[(long int *)D.105145];
        D.105147 = (sizetype) D.105146;
        D.105148 = D.105141 + D.105147;
        OBJ_TYPE_REF(D.105151;(const struct ObjectBase)D.105148->3) (D.105148);
        goto <D.105152>;
        <D.105143>:
        <D.105152>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103187>:
}


static gchar* Gio::TlsDatabase_Class::create_certificate_handle_vfunc_callback(GTlsDatabase*, GTlsCertificate*) (struct GTlsDatabase * self, struct GTlsCertificate * certificate)
{
  bool retval.10;
  bool iftmp.11;
  bool D.105159;
  struct CppObjectType * const iftmp.12;
  gchar * D.105169;
  struct ustring D.100153;
  int (*__vtbl_ptr_type) () * D.105170;
  int (*__vtbl_ptr_type) () * D.105171;
  int (*__vtbl_ptr_type) () D.105172;
  const struct RefPtr D.100152;
  struct RefPtr D.100018;
  const char * D.105173;
  void * D.105174;
  struct GTypeClass * D.105177;
  gchar * (*<T1125b>) (struct GTlsDatabase *, struct GTlsCertificate *) D.105180;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef gchar * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105158>; else goto <D.105156>;
    <D.105158>:
    D.105159 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105159 != 0) goto <D.105160>; else goto <D.105156>;
    <D.105160>:
    iftmp.11 = 1;
    goto <D.105157>;
    <D.105156>:
    iftmp.11 = 0;
    <D.105157>:
    retval.10 = iftmp.11;
    if (retval.10 != 0) goto <D.105161>; else goto <D.105162>;
    <D.105161>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105164>; else goto <D.105165>;
      <D.105164>:
      iftmp.12 = 0B;
      goto <D.105166>;
      <D.105165>:
      iftmp.12 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105166>:
      obj = iftmp.12;
      if (obj != 0B) goto <D.105167>; else goto <D.105168>;
      <D.105167>:
      try
        {
          D.105170 = obj->D.97204._vptr.Object;
          D.105171 = D.105170 + 40;
          D.105172 = *D.105171;
          D.100018 = Glib::wrap (certificate, 1); [return slot optimization]
          try
            {
              Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (&D.100152, &D.100018);
              try
                {
                  D.100153 = OBJ_TYPE_REF(D.105172;(const struct TlsDatabase)obj->5) (obj, &D.100152); [return slot optimization]
                  try
                    {
                      D.105173 = Glib::ustring::c_str (&D.100153);
                      D.105169 = g_strdup (D.105173);
                      return D.105169;
                    }
                  finally
                    {
                      Glib::ustring::~ustring (&D.100153);
                      D.100153 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<const Gio::TlsCertificate>::~RefPtr (&D.100152);
                  D.100152 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100018);
              D.100018 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105174 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105174);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105175>;
      <D.105168>:
      <D.105175>:
    }
    goto <D.105176>;
    <D.105162>:
    <D.105176>:
  }
  D.105177 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105177);
  {
    if (base != 0B) goto <D.105178>; else goto <D.105179>;
    <D.105178>:
    D.105180 = base->create_certificate_handle;
    if (D.105180 != 0B) goto <D.105181>; else goto <D.105182>;
    <D.105181>:
    {
      gchar * retval;

      D.105180 = base->create_certificate_handle;
      retval = D.105180 (self, certificate);
      D.105169 = retval;
      return D.105169;
    }
    <D.105182>:
    <D.105179>:
  }
  D.105169 = 0B;
  return D.105169;
}


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.105199;
  const struct TlsCertificate * D.105200;
  int (*__vtbl_ptr_type) () * D.105203;
  int (*__vtbl_ptr_type) () * D.105204;
  long int D.105205;
  sizetype D.105206;
  const struct ObjectBase * D.105207;
  int (*__vtbl_ptr_type) () * D.105208;
  int (*__vtbl_ptr_type) () * D.105209;
  int (*__vtbl_ptr_type) () D.105210;

  D.105199 = Glib::RefPtr<Gio::TlsCertificate>::operator-> (src);
  this->pCppObject_ = D.105199;
  D.105200 = this->pCppObject_;
  if (D.105200 != 0B) goto <D.105201>; else goto <D.105202>;
  <D.105201>:
  D.105200 = this->pCppObject_;
  D.105200 = this->pCppObject_;
  D.105203 = D.105200->D.97883._vptr.Object;
  D.105204 = D.105203 + 18446744073709551592;
  D.105205 = MEM[(long int *)D.105204];
  D.105206 = (sizetype) D.105205;
  D.105207 = D.105200 + D.105206;
  D.105200 = this->pCppObject_;
  D.105200 = this->pCppObject_;
  D.105203 = D.105200->D.97883._vptr.Object;
  D.105204 = D.105203 + 18446744073709551592;
  D.105205 = MEM[(long int *)D.105204];
  D.105206 = (sizetype) D.105205;
  D.105207 = D.105200 + D.105206;
  D.105208 = D.105207->_vptr.ObjectBase;
  D.105209 = D.105208 + 16;
  D.105210 = *D.105209;
  D.105200 = this->pCppObject_;
  D.105200 = this->pCppObject_;
  D.105203 = D.105200->D.97883._vptr.Object;
  D.105204 = D.105203 + 18446744073709551592;
  D.105205 = MEM[(long int *)D.105204];
  D.105206 = (sizetype) D.105205;
  D.105207 = D.105200 + D.105206;
  OBJ_TYPE_REF(D.105210;(const struct ObjectBase)D.105207->2) (D.105207);
  goto <D.105211>;
  <D.105202>:
  <D.105211>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = const Gio::TlsCertificate] (struct RefPtr * const this)
{
  const struct TlsCertificate * D.105214;
  int (*__vtbl_ptr_type) () * D.105217;
  int (*__vtbl_ptr_type) () * D.105218;
  long int D.105219;
  sizetype D.105220;
  const struct ObjectBase * D.105221;
  int (*__vtbl_ptr_type) () * D.105222;
  int (*__vtbl_ptr_type) () * D.105223;
  int (*__vtbl_ptr_type) () D.105224;

  {
    try
      {
        D.105214 = this->pCppObject_;
        if (D.105214 != 0B) goto <D.105215>; else goto <D.105216>;
        <D.105215>:
        D.105214 = this->pCppObject_;
        D.105214 = this->pCppObject_;
        D.105217 = D.105214->D.97883._vptr.Object;
        D.105218 = D.105217 + 18446744073709551592;
        D.105219 = MEM[(long int *)D.105218];
        D.105220 = (sizetype) D.105219;
        D.105221 = D.105214 + D.105220;
        D.105214 = this->pCppObject_;
        D.105214 = this->pCppObject_;
        D.105217 = D.105214->D.97883._vptr.Object;
        D.105218 = D.105217 + 18446744073709551592;
        D.105219 = MEM[(long int *)D.105218];
        D.105220 = (sizetype) D.105219;
        D.105221 = D.105214 + D.105220;
        D.105222 = D.105221->_vptr.ObjectBase;
        D.105223 = D.105222 + 24;
        D.105224 = *D.105223;
        D.105214 = this->pCppObject_;
        D.105214 = this->pCppObject_;
        D.105217 = D.105214->D.97883._vptr.Object;
        D.105218 = D.105217 + 18446744073709551592;
        D.105219 = MEM[(long int *)D.105218];
        D.105220 = (sizetype) D.105219;
        D.105221 = D.105214 + D.105220;
        OBJ_TYPE_REF(D.105224;(const struct ObjectBase)D.105221->3) (D.105221);
        goto <D.105225>;
        <D.105216>:
        <D.105225>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103203>:
}


static GTlsCertificate* Gio::TlsDatabase_Class::lookup_certificate_for_handle_vfunc_callback(GTlsDatabase*, const gchar*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GError**) (struct GTlsDatabase * self, const gchar * handle, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, struct GError * * error)
{
  bool retval.13;
  bool iftmp.14;
  bool D.105232;
  struct CppObjectType * const iftmp.15;
  struct GTlsCertificate * D.105242;
  long unsigned int D.105243;
  struct RefPtr D.100171;
  int (*__vtbl_ptr_type) () * D.105244;
  int (*__vtbl_ptr_type) () * D.105245;
  int (*__vtbl_ptr_type) () D.105246;
  struct RefPtr D.100170;
  struct RefPtr D.100169;
  struct ustring D.100168;
  struct BaseObjectType * D.105247;
  void * D.105248;
  void * D.105249;
  struct GTypeClass * D.105252;
  struct GTlsCertificate * (*<T1125f>) (struct GTlsDatabase *, const gchar *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.105255;
  struct GError * D.105258;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GTlsCertificate * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105231>; else goto <D.105229>;
    <D.105231>:
    D.105232 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105232 != 0) goto <D.105233>; else goto <D.105229>;
    <D.105233>:
    iftmp.14 = 1;
    goto <D.105230>;
    <D.105229>:
    iftmp.14 = 0;
    <D.105230>:
    retval.13 = iftmp.14;
    if (retval.13 != 0) goto <D.105234>; else goto <D.105235>;
    <D.105234>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105237>; else goto <D.105238>;
      <D.105237>:
      iftmp.15 = 0B;
      goto <D.105239>;
      <D.105238>:
      iftmp.15 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105239>:
      obj = iftmp.15;
      if (obj != 0B) goto <D.105240>; else goto <D.105241>;
      <D.105240>:
      try
        {
          D.105243 = g_tls_certificate_get_type ();
          D.105244 = obj->D.97204._vptr.Object;
          D.105245 = D.105244 + 48;
          D.105246 = *D.105245;
          D.100170 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.100169 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.100168 = Glib::convert_const_gchar_ptr_to_ustring (handle); [return slot optimization]
                  try
                    {
                      D.100171 = OBJ_TYPE_REF(D.105246;(struct TlsDatabase)obj->6) (obj, &D.100168, &D.100169, &D.100170, flags); [return slot optimization]
                      try
                        {
                          D.105247 = Glib::unwrap<Gio::TlsCertificate> (&D.100171);
                          D.105248 = g_object_ref (D.105247);
                          D.105242 = g_type_check_instance_cast (D.105248, D.105243);
                          return D.105242;
                        }
                      finally
                        {
                          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100171);
                          D.100171 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::ustring::~ustring (&D.100168);
                      D.100168 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.100169);
                  D.100169 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.100170);
              D.100170 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105249 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105249);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105250>;
      <D.105241>:
      <D.105250>:
    }
    goto <D.105251>;
    <D.105235>:
    <D.105251>:
  }
  D.105252 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105252);
  {
    if (base != 0B) goto <D.105253>; else goto <D.105254>;
    <D.105253>:
    D.105255 = base->lookup_certificate_for_handle;
    if (D.105255 != 0B) goto <D.105256>; else goto <D.105257>;
    <D.105256>:
    {
      struct GTlsCertificate * retval;

      D.105255 = base->lookup_certificate_for_handle;
      retval = D.105255 (self, handle, interaction, flags, cancellable, error);
      D.105258 = *error;
      if (D.105258 != 0B) goto <D.105259>; else goto <D.105260>;
      <D.105259>:
      D.105258 = *error;
      Glib::Error::throw_exception (D.105258);
      <D.105260>:
      D.105242 = retval;
      return D.105242;
    }
    <D.105257>:
    <D.105254>:
  }
  D.105242 = 0B;
  return D.105242;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::TlsCertificate; typename T::BaseObjectType = _GTlsCertificate] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.105281;
  struct BaseObjectType * iftmp.16;
  bool D.105283;
  struct TlsCertificate * D.105286;

  D.105283 = Glib::RefPtr<Gio::TlsCertificate>::operator bool (ptr);
  if (D.105283 != 0) goto <D.105284>; else goto <D.105285>;
  <D.105284>:
  D.105286 = Glib::RefPtr<Gio::TlsCertificate>::operator-> (ptr);
  iftmp.16 = Gio::TlsCertificate::gobj (D.105286);
  goto <D.105287>;
  <D.105285>:
  iftmp.16 = 0B;
  <D.105287>:
  D.105281 = iftmp.16;
  return D.105281;
}


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

  D.105290 = this->pCppObject_;
  D.105289 = D.105290 != 0B;
  return D.105289;
}


GTlsCertificate* Gio::TlsCertificate::gobj() (struct TlsCertificate * const this)
{
  struct GTlsCertificate * D.105292;
  int (*__vtbl_ptr_type) () * D.105293;
  int (*__vtbl_ptr_type) () * D.105294;
  long int D.105295;
  sizetype D.105296;
  struct ObjectBase * D.105297;

  D.105293 = this->D.97883._vptr.Object;
  D.105294 = D.105293 + 18446744073709551592;
  D.105295 = MEM[(long int *)D.105294];
  D.105296 = (sizetype) D.105295;
  D.105297 = this + D.105296;
  D.105292 = D.105297->gobject_;
  return D.105292;
}


static void Gio::TlsDatabase_Class::lookup_certificate_for_handle_async_vfunc_callback(GTlsDatabase*, const gchar*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GAsyncReadyCallback, gpointer) (struct GTlsDatabase * self, const gchar * handle, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *) callback, void * user_data)
{
  bool retval.17;
  bool iftmp.18;
  bool D.105304;
  struct CppObjectType * const iftmp.19;
  int (*__vtbl_ptr_type) () * D.105314;
  int (*__vtbl_ptr_type) () * D.105315;
  int (*__vtbl_ptr_type) () D.105316;
  struct RefPtr D.100192;
  struct RefPtr D.100191;
  struct ustring D.100190;
  void * D.105317;
  struct GTypeClass * D.105320;
  void (*<T11263>) (struct GTlsDatabase *, const gchar *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.105323;
  const struct SlotAsyncReady * slot;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  slot = user_data;
  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105303>; else goto <D.105301>;
    <D.105303>:
    D.105304 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105304 != 0) goto <D.105305>; else goto <D.105301>;
    <D.105305>:
    iftmp.18 = 1;
    goto <D.105302>;
    <D.105301>:
    iftmp.18 = 0;
    <D.105302>:
    retval.17 = iftmp.18;
    if (retval.17 != 0) goto <D.105306>; else goto <D.105307>;
    <D.105306>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105309>; else goto <D.105310>;
      <D.105309>:
      iftmp.19 = 0B;
      goto <D.105311>;
      <D.105310>:
      iftmp.19 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105311>:
      obj = iftmp.19;
      if (obj != 0B) goto <D.105312>; else goto <D.105313>;
      <D.105312>:
      try
        {
          D.105314 = obj->D.97204._vptr.Object;
          D.105315 = D.105314 + 56;
          D.105316 = *D.105315;
          D.100192 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.100191 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.100190 = Glib::convert_const_gchar_ptr_to_ustring (handle); [return slot optimization]
                  try
                    {
                      OBJ_TYPE_REF(D.105316;(struct TlsDatabase)obj->7) (obj, &D.100190, &D.100191, slot, &D.100192, flags);
                    }
                  finally
                    {
                      Glib::ustring::~ustring (&D.100190);
                      D.100190 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.100191);
                  D.100191 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.100192);
              D.100192 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105317 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105317);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105318>;
      <D.105313>:
      <D.105318>:
    }
    goto <D.105319>;
    <D.105307>:
    <D.105319>:
  }
  D.105320 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105320);
  if (base != 0B) goto <D.105321>; else goto <D.105322>;
  <D.105321>:
  D.105323 = base->lookup_certificate_for_handle_async;
  if (D.105323 != 0B) goto <D.105324>; else goto <D.105325>;
  <D.105324>:
  D.105323 = base->lookup_certificate_for_handle_async;
  D.105323 (self, handle, interaction, flags, cancellable, callback, user_data);
  goto <D.105326>;
  <D.105325>:
  <D.105326>:
  <D.105322>:
}


static GTlsCertificate* Gio::TlsDatabase_Class::lookup_certificate_for_handle_finish_vfunc_callback(GTlsDatabase*, GAsyncResult*, GError**) (struct GTlsDatabase * self, struct GAsyncResult * result, struct GError * * error)
{
  bool retval.20;
  bool iftmp.21;
  bool D.105342;
  struct CppObjectType * const iftmp.22;
  struct GTlsCertificate * D.105352;
  long unsigned int D.105353;
  struct RefPtr D.100203;
  int (*__vtbl_ptr_type) () * D.105354;
  int (*__vtbl_ptr_type) () * D.105355;
  int (*__vtbl_ptr_type) () D.105356;
  struct RefPtr D.100202;
  struct BaseObjectType * D.105357;
  void * D.105358;
  void * D.105359;
  struct GTypeClass * D.105362;
  struct GTlsCertificate * (*<T11267>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.105365;
  struct GError * D.105368;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GTlsCertificate * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105341>; else goto <D.105339>;
    <D.105341>:
    D.105342 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105342 != 0) goto <D.105343>; else goto <D.105339>;
    <D.105343>:
    iftmp.21 = 1;
    goto <D.105340>;
    <D.105339>:
    iftmp.21 = 0;
    <D.105340>:
    retval.20 = iftmp.21;
    if (retval.20 != 0) goto <D.105344>; else goto <D.105345>;
    <D.105344>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105347>; else goto <D.105348>;
      <D.105347>:
      iftmp.22 = 0B;
      goto <D.105349>;
      <D.105348>:
      iftmp.22 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105349>:
      obj = iftmp.22;
      if (obj != 0B) goto <D.105350>; else goto <D.105351>;
      <D.105350>:
      try
        {
          D.105353 = g_tls_certificate_get_type ();
          D.105354 = obj->D.97204._vptr.Object;
          D.105355 = D.105354 + 64;
          D.105356 = *D.105355;
          D.100202 = Glib::wrap (result, 1); [return slot optimization]
          try
            {
              D.100203 = OBJ_TYPE_REF(D.105356;(struct TlsDatabase)obj->8) (obj, &D.100202); [return slot optimization]
              try
                {
                  D.105357 = Glib::unwrap<Gio::TlsCertificate> (&D.100203);
                  D.105358 = g_object_ref (D.105357);
                  D.105352 = g_type_check_instance_cast (D.105358, D.105353);
                  return D.105352;
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100203);
                  D.100203 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&D.100202);
              D.100202 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105359 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105359);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105360>;
      <D.105351>:
      <D.105360>:
    }
    goto <D.105361>;
    <D.105345>:
    <D.105361>:
  }
  D.105362 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105362);
  {
    if (base != 0B) goto <D.105363>; else goto <D.105364>;
    <D.105363>:
    D.105365 = base->lookup_certificate_for_handle_finish;
    if (D.105365 != 0B) goto <D.105366>; else goto <D.105367>;
    <D.105366>:
    {
      struct GTlsCertificate * retval;

      D.105365 = base->lookup_certificate_for_handle_finish;
      retval = D.105365 (self, result, error);
      D.105368 = *error;
      if (D.105368 != 0B) goto <D.105369>; else goto <D.105370>;
      <D.105369>:
      D.105368 = *error;
      Glib::Error::throw_exception (D.105368);
      <D.105370>:
      D.105352 = retval;
      return D.105352;
    }
    <D.105367>:
    <D.105364>:
  }
  D.105352 = 0B;
  return D.105352;
}


static GTlsCertificate* Gio::TlsDatabase_Class::lookup_certificate_issuer_vfunc_callback(GTlsDatabase*, GTlsCertificate*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GError**) (struct GTlsDatabase * self, struct GTlsCertificate * certificate, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, struct GError * * error)
{
  bool retval.23;
  bool iftmp.24;
  bool D.105392;
  struct CppObjectType * const iftmp.25;
  struct GTlsCertificate * D.105402;
  long unsigned int D.105403;
  struct RefPtr D.100221;
  int (*__vtbl_ptr_type) () * D.105404;
  int (*__vtbl_ptr_type) () * D.105405;
  int (*__vtbl_ptr_type) () D.105406;
  struct RefPtr D.100220;
  struct RefPtr D.100219;
  struct RefPtr D.100218;
  struct BaseObjectType * D.105407;
  void * D.105408;
  void * D.105409;
  struct GTypeClass * D.105412;
  struct GTlsCertificate * (*<T1126b>) (struct GTlsDatabase *, struct GTlsCertificate *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.105415;
  struct GError * D.105418;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GTlsCertificate * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105391>; else goto <D.105389>;
    <D.105391>:
    D.105392 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105392 != 0) goto <D.105393>; else goto <D.105389>;
    <D.105393>:
    iftmp.24 = 1;
    goto <D.105390>;
    <D.105389>:
    iftmp.24 = 0;
    <D.105390>:
    retval.23 = iftmp.24;
    if (retval.23 != 0) goto <D.105394>; else goto <D.105395>;
    <D.105394>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105397>; else goto <D.105398>;
      <D.105397>:
      iftmp.25 = 0B;
      goto <D.105399>;
      <D.105398>:
      iftmp.25 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105399>:
      obj = iftmp.25;
      if (obj != 0B) goto <D.105400>; else goto <D.105401>;
      <D.105400>:
      try
        {
          D.105403 = g_tls_certificate_get_type ();
          D.105404 = obj->D.97204._vptr.Object;
          D.105405 = D.105404 + 72;
          D.105406 = *D.105405;
          D.100220 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.100219 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.100218 = Glib::wrap (certificate, 1); [return slot optimization]
                  try
                    {
                      D.100221 = OBJ_TYPE_REF(D.105406;(struct TlsDatabase)obj->9) (obj, &D.100218, &D.100219, &D.100220, flags); [return slot optimization]
                      try
                        {
                          D.105407 = Glib::unwrap<Gio::TlsCertificate> (&D.100221);
                          D.105408 = g_object_ref (D.105407);
                          D.105402 = g_type_check_instance_cast (D.105408, D.105403);
                          return D.105402;
                        }
                      finally
                        {
                          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100221);
                          D.100221 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100218);
                      D.100218 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.100219);
                  D.100219 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.100220);
              D.100220 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105409 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105409);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105410>;
      <D.105401>:
      <D.105410>:
    }
    goto <D.105411>;
    <D.105395>:
    <D.105411>:
  }
  D.105412 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105412);
  {
    if (base != 0B) goto <D.105413>; else goto <D.105414>;
    <D.105413>:
    D.105415 = base->lookup_certificate_issuer;
    if (D.105415 != 0B) goto <D.105416>; else goto <D.105417>;
    <D.105416>:
    {
      struct GTlsCertificate * retval;

      D.105415 = base->lookup_certificate_issuer;
      retval = D.105415 (self, certificate, interaction, flags, cancellable, error);
      D.105418 = *error;
      if (D.105418 != 0B) goto <D.105419>; else goto <D.105420>;
      <D.105419>:
      D.105418 = *error;
      Glib::Error::throw_exception (D.105418);
      <D.105420>:
      D.105402 = retval;
      return D.105402;
    }
    <D.105417>:
    <D.105414>:
  }
  D.105402 = 0B;
  return D.105402;
}


static void Gio::TlsDatabase_Class::lookup_certificate_issuer_async_vfunc_callback(GTlsDatabase*, GTlsCertificate*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GAsyncReadyCallback, gpointer) (struct GTlsDatabase * self, struct GTlsCertificate * certificate, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *) callback, void * user_data)
{
  bool retval.26;
  bool iftmp.27;
  bool D.105446;
  struct CppObjectType * const iftmp.28;
  int (*__vtbl_ptr_type) () * D.105456;
  int (*__vtbl_ptr_type) () * D.105457;
  int (*__vtbl_ptr_type) () D.105458;
  struct RefPtr D.100240;
  struct RefPtr D.100239;
  struct RefPtr D.100238;
  void * D.105459;
  struct GTypeClass * D.105462;
  void (*<T1126f>) (struct GTlsDatabase *, struct GTlsCertificate *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.105465;
  const struct SlotAsyncReady * slot;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  slot = user_data;
  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105445>; else goto <D.105443>;
    <D.105445>:
    D.105446 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105446 != 0) goto <D.105447>; else goto <D.105443>;
    <D.105447>:
    iftmp.27 = 1;
    goto <D.105444>;
    <D.105443>:
    iftmp.27 = 0;
    <D.105444>:
    retval.26 = iftmp.27;
    if (retval.26 != 0) goto <D.105448>; else goto <D.105449>;
    <D.105448>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105451>; else goto <D.105452>;
      <D.105451>:
      iftmp.28 = 0B;
      goto <D.105453>;
      <D.105452>:
      iftmp.28 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105453>:
      obj = iftmp.28;
      if (obj != 0B) goto <D.105454>; else goto <D.105455>;
      <D.105454>:
      try
        {
          D.105456 = obj->D.97204._vptr.Object;
          D.105457 = D.105456 + 80;
          D.105458 = *D.105457;
          D.100240 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.100239 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.100238 = Glib::wrap (certificate, 1); [return slot optimization]
                  try
                    {
                      OBJ_TYPE_REF(D.105458;(struct TlsDatabase)obj->10) (obj, &D.100238, &D.100239, slot, &D.100240, flags);
                    }
                  finally
                    {
                      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100238);
                      D.100238 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.100239);
                  D.100239 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.100240);
              D.100240 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105459 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105459);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105460>;
      <D.105455>:
      <D.105460>:
    }
    goto <D.105461>;
    <D.105449>:
    <D.105461>:
  }
  D.105462 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105462);
  if (base != 0B) goto <D.105463>; else goto <D.105464>;
  <D.105463>:
  D.105465 = base->lookup_certificate_issuer_async;
  if (D.105465 != 0B) goto <D.105466>; else goto <D.105467>;
  <D.105466>:
  D.105465 = base->lookup_certificate_issuer_async;
  D.105465 (self, certificate, interaction, flags, cancellable, callback, user_data);
  goto <D.105468>;
  <D.105467>:
  <D.105468>:
  <D.105464>:
}


static GTlsCertificate* Gio::TlsDatabase_Class::lookup_certificate_issuer_finish_vfunc_callback(GTlsDatabase*, GAsyncResult*, GError**) (struct GTlsDatabase * self, struct GAsyncResult * result, struct GError * * error)
{
  bool retval.29;
  bool iftmp.30;
  bool D.105484;
  struct CppObjectType * const iftmp.31;
  struct GTlsCertificate * D.105494;
  long unsigned int D.105495;
  struct RefPtr D.100251;
  int (*__vtbl_ptr_type) () * D.105496;
  int (*__vtbl_ptr_type) () * D.105497;
  int (*__vtbl_ptr_type) () D.105498;
  struct RefPtr D.100250;
  struct BaseObjectType * D.105499;
  void * D.105500;
  void * D.105501;
  struct GTypeClass * D.105504;
  struct GTlsCertificate * (*<T11267>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.105507;
  struct GError * D.105510;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GTlsCertificate * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105483>; else goto <D.105481>;
    <D.105483>:
    D.105484 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105484 != 0) goto <D.105485>; else goto <D.105481>;
    <D.105485>:
    iftmp.30 = 1;
    goto <D.105482>;
    <D.105481>:
    iftmp.30 = 0;
    <D.105482>:
    retval.29 = iftmp.30;
    if (retval.29 != 0) goto <D.105486>; else goto <D.105487>;
    <D.105486>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105489>; else goto <D.105490>;
      <D.105489>:
      iftmp.31 = 0B;
      goto <D.105491>;
      <D.105490>:
      iftmp.31 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105491>:
      obj = iftmp.31;
      if (obj != 0B) goto <D.105492>; else goto <D.105493>;
      <D.105492>:
      try
        {
          D.105495 = g_tls_certificate_get_type ();
          D.105496 = obj->D.97204._vptr.Object;
          D.105497 = D.105496 + 88;
          D.105498 = *D.105497;
          D.100250 = Glib::wrap (result, 1); [return slot optimization]
          try
            {
              D.100251 = OBJ_TYPE_REF(D.105498;(struct TlsDatabase)obj->11) (obj, &D.100250); [return slot optimization]
              try
                {
                  D.105499 = Glib::unwrap<Gio::TlsCertificate> (&D.100251);
                  D.105500 = g_object_ref (D.105499);
                  D.105494 = g_type_check_instance_cast (D.105500, D.105495);
                  return D.105494;
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.100251);
                  D.100251 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&D.100250);
              D.100250 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105501 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105501);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105502>;
      <D.105493>:
      <D.105502>:
    }
    goto <D.105503>;
    <D.105487>:
    <D.105503>:
  }
  D.105504 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105504);
  {
    if (base != 0B) goto <D.105505>; else goto <D.105506>;
    <D.105505>:
    D.105507 = base->lookup_certificate_issuer_finish;
    if (D.105507 != 0B) goto <D.105508>; else goto <D.105509>;
    <D.105508>:
    {
      struct GTlsCertificate * retval;

      D.105507 = base->lookup_certificate_issuer_finish;
      retval = D.105507 (self, result, error);
      D.105510 = *error;
      if (D.105510 != 0B) goto <D.105511>; else goto <D.105512>;
      <D.105511>:
      D.105510 = *error;
      Glib::Error::throw_exception (D.105510);
      <D.105512>:
      D.105494 = retval;
      return D.105494;
    }
    <D.105509>:
    <D.105506>:
  }
  D.105494 = 0B;
  return D.105494;
}


static GList* Gio::TlsDatabase_Class::lookup_certificates_issued_by_vfunc_callback(GTlsDatabase*, GByteArray*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GError**) (struct GTlsDatabase * self, struct GByteArray * issuer_raw_dn, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, struct GError * * error)
{
  bool retval.32;
  bool iftmp.33;
  bool D.105534;
  struct CppObjectType * const iftmp.34;
  struct GList * D.105544;
  struct GListKeeperType D.101082;
  struct vector D.101042;
  int (*__vtbl_ptr_type) () * D.105545;
  int (*__vtbl_ptr_type) () * D.105546;
  int (*__vtbl_ptr_type) () D.105547;
  struct RefPtr D.100297;
  struct RefPtr D.100296;
  struct RefPtr D.100295;
  struct GList * D.105548;
  void * D.105549;
  struct GTypeClass * D.105552;
  struct GList * (*<T11275>) (struct GTlsDatabase *, struct GByteArray *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.105555;
  struct GError * D.105558;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GList * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105533>; else goto <D.105531>;
    <D.105533>:
    D.105534 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105534 != 0) goto <D.105535>; else goto <D.105531>;
    <D.105535>:
    iftmp.33 = 1;
    goto <D.105532>;
    <D.105531>:
    iftmp.33 = 0;
    <D.105532>:
    retval.32 = iftmp.33;
    if (retval.32 != 0) goto <D.105536>; else goto <D.105537>;
    <D.105536>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105539>; else goto <D.105540>;
      <D.105539>:
      iftmp.34 = 0B;
      goto <D.105541>;
      <D.105540>:
      iftmp.34 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105541>:
      obj = iftmp.34;
      if (obj != 0B) goto <D.105542>; else goto <D.105543>;
      <D.105542>:
      try
        {
          D.105545 = obj->D.97204._vptr.Object;
          D.105546 = D.105545 + 96;
          D.105547 = *D.105546;
          D.100297 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.100296 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.100295 = Glib::wrap (issuer_raw_dn, 1); [return slot optimization]
                  try
                    {
                      D.101042 = OBJ_TYPE_REF(D.105547;(struct TlsDatabase)obj->12) (obj, &D.100295, &D.100296, &D.100297, flags); [return slot optimization]
                      try
                        {
                          D.101082 = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::vector_to_list (&D.101042); [return slot optimization]
                          try
                            {
                              D.105548 = Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::data (&D.101082);
                              D.105544 = g_list_copy (D.105548);
                              return D.105544;
                            }
                          finally
                            {
                              Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::~GListKeeper (&D.101082);
                              D.101082 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (&D.101042);
                          D.101042 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::RefPtr<Glib::ByteArray>::~RefPtr (&D.100295);
                      D.100295 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.100296);
                  D.100296 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.100297);
              D.100297 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105549 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105549);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105550>;
      <D.105543>:
      <D.105550>:
    }
    goto <D.105551>;
    <D.105537>:
    <D.105551>:
  }
  D.105552 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105552);
  {
    if (base != 0B) goto <D.105553>; else goto <D.105554>;
    <D.105553>:
    D.105555 = base->lookup_certificates_issued_by;
    if (D.105555 != 0B) goto <D.105556>; else goto <D.105557>;
    <D.105556>:
    {
      struct GList * retval;

      D.105555 = base->lookup_certificates_issued_by;
      retval = D.105555 (self, issuer_raw_dn, interaction, flags, cancellable, error);
      D.105558 = *error;
      if (D.105558 != 0B) goto <D.105559>; else goto <D.105560>;
      <D.105559>:
      D.105558 = *error;
      Glib::Error::throw_exception (D.105558);
      <D.105560>:
      D.105544 = retval;
      return D.105544;
    }
    <D.105557>:
    <D.105554>:
  }
  D.105544 = 0B;
  return D.105544;
}


static Glib::ListHandler<T, Tr>::GListKeeperType Glib::ListHandler<T, Tr>::vector_to_list(const VectorType&) [with T = Glib::RefPtr<Gio::TlsCertificate>; Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >; Glib::ListHandler<T, Tr>::GListKeeperType = Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >; Glib::ListHandler<T, Tr>::VectorType = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (const struct VectorType & vector)
{
  struct __normal_iterator D.105581;
  struct __normal_iterator D.105582;
  struct GList * D.105583;

  D.105581 = std::vector<Glib::RefPtr<Gio::TlsCertificate> >::end (vector);
  D.105582 = std::vector<Glib::RefPtr<Gio::TlsCertificate> >::begin (vector);
  D.105583 = Glib::Container_Helpers::create_glist<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > (D.105582, D.105581);
  Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::GListKeeper (<retval>, D.105583, 1);
  return <retval>;
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::end() const [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::RefPtr<Gio::TlsCertificate>*] (const struct vector * const this)
{
  struct const_iterator D.105586;
  struct const_iterator D.103906;
  const struct RefPtr * const D.103905;
  struct RefPtr * D.105587;

  D.105587 = this->D.101040._M_impl._M_finish;
  D.103905 = D.105587;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::__normal_iterator (&D.103906, &D.103905);
      try
        {
          D.105586 = D.103906;
          return D.105586;
        }
      finally
        {
          D.103906 = {CLOBBER};
        }
    }
  finally
    {
      D.103905 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (struct __normal_iterator * const this, const struct RefPtr * const & __i)
{
  const struct RefPtr * D.105591;

  D.105591 = *__i;
  this->_M_current = D.105591;
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::begin() const [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::RefPtr<Gio::TlsCertificate>*] (const struct vector * const this)
{
  struct const_iterator D.105592;
  struct const_iterator D.103903;
  const struct RefPtr * const D.103902;
  struct RefPtr * D.105593;

  D.105593 = this->D.101040._M_impl._M_start;
  D.103902 = D.105593;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::__normal_iterator (&D.103903, &D.103902);
      try
        {
          D.105592 = D.103903;
          return D.105592;
        }
      finally
        {
          D.103903 = {CLOBBER};
        }
    }
  finally
    {
      D.103902 = {CLOBBER};
    }
}


GList* Glib::Container_Helpers::create_glist(typename std::vector<typename Tr::CppType>::const_iterator, typename std::vector<typename Tr::CppType>::const_iterator) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >; GList = _GList; typename std::vector<typename Tr::CppType>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >] (const struct const_iterator pbegin, struct const_iterator pend)
{
  struct __normal_iterator & D.105597;
  const struct RefPtr & D.105598;
  bool retval.35;
  struct GList * D.105600;
  struct GList * head;

  head = 0B;
  goto <D.103917>;
  <D.103918>:
  {
    const void * const item;

    D.105597 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::operator-- (&pend);
    D.105598 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::operator* (D.105597);
    item = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >::to_c_type (D.105598);
    head = g_list_prepend (head, item);
  }
  <D.103917>:
  retval.35 = __gnu_cxx::operator!=<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > > (&pend, &pbegin);
  if (retval.35 != 0) goto <D.103918>; else goto <D.103916>;
  <D.103916>:
  D.105600 = head;
  return D.105600;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator--() [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (struct __normal_iterator * const this)
{
  const struct RefPtr * D.105605;
  const struct RefPtr * D.105606;
  struct __normal_iterator & D.105607;

  D.105605 = this->_M_current;
  D.105606 = D.105605 + 18446744073709551608;
  this->_M_current = D.105606;
  D.105607 = this;
  return D.105607;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::reference __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator*() const [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >; __gnu_cxx::__normal_iterator<_Iterator, _Container>::reference = const Glib::RefPtr<Gio::TlsCertificate>&] (const struct __normal_iterator * const this)
{
  const struct RefPtr & D.105609;

  D.105609 = this->_M_current;
  return D.105609;
}


static typename T::BaseObjectType* Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::to_c_type(const CppType&) [with T = Gio::TlsCertificate; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CType = _GTlsCertificate*; typename T::BaseObjectType = _GTlsCertificate; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<T_CppObject> >::CppType = Glib::RefPtr<Gio::TlsCertificate>] (const struct CppType & ptr)
{
  struct BaseObjectType * D.105611;

  D.105611 = Glib::unwrap<Gio::TlsCertificate> (ptr);
  return D.105611;
}


bool __gnu_cxx::operator!=(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  bool D.105614;
  const struct RefPtr * const & D.105615;
  const struct RefPtr * D.105616;
  const struct RefPtr * const & D.105617;
  const struct RefPtr * D.105618;

  D.105615 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::base (__lhs);
  D.105616 = *D.105615;
  D.105617 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::base (__rhs);
  D.105618 = *D.105617;
  D.105614 = D.105616 != D.105618;
  return D.105614;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (const struct __normal_iterator * const this)
{
  const struct RefPtr * const & D.105620;

  D.105620 = &this->_M_current;
  return D.105620;
}


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;
}


GList* Glib::Container_Helpers::GListKeeper<Tr>::data() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >; GList = _GList] (const struct GListKeeper * const this)
{
  struct GList * D.105622;

  D.105622 = this->glist_;
  return D.105622;
}


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

  {
    try
      {
        {
          typedef struct BaseObjectType * CTypeNonConst;

          {
            D.105624 = this->glist_;
            if (D.105624 != 0B) goto <D.105625>; else goto <D.105626>;
            <D.105625>:
            D.105627 = this->ownership_;
            if (D.105627 != 0) goto <D.105628>; else goto <D.105629>;
            <D.105628>:
            {
              {
                D.105627 = this->ownership_;
                if (D.105627 != 1) goto <D.105630>; else goto <D.105631>;
                <D.105630>:
                {
                  {
                    struct GList * node;

                    node = this->glist_;
                    goto <D.103352>;
                    <D.103353>:
                    D.105632 = node->data;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >::release_c_type (D.105632);
                    node = node->next;
                    <D.103352>:
                    if (node != 0B) goto <D.103353>; else goto <D.103354>;
                    <D.103354>:
                  }
                }
                goto <D.105633>;
                <D.105631>:
                <D.105633>:
              }
              D.105624 = this->glist_;
              g_list_free (D.105624);
            }
            goto <D.105634>;
            <D.105629>:
            <D.105634>:
            <D.105626>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103355>:
}


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.105636;
  struct _Tp_alloc_type & D.105637;
  struct RefPtr * D.105638;
  struct RefPtr * D.105639;

  {
    try
      {
        try
          {
            D.105636 = &this->D.101040;
            D.105637 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.105636);
            D.105638 = this->D.101040._M_impl._M_finish;
            D.105639 = this->D.101040._M_impl._M_start;
            std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*, Glib::RefPtr<Gio::TlsCertificate> > (D.105639, D.105638, D.105637);
          }
        finally
          {
            D.105636 = &this->D.101040;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::~_Vector_base (D.105636);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103337>:
}


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.105642;

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


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.103330)
{
  std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*> (__first, __last);
}


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.105644;

  goto <D.104576>;
  <D.104575>:
  D.105644 = std::__addressof<Glib::RefPtr<Gio::TlsCertificate> > (__first);
  std::_Destroy<Glib::RefPtr<Gio::TlsCertificate> > (D.105644);
  __first = __first + 8;
  <D.104576>:
  if (__first != __last) goto <D.104575>; else goto <D.104573>;
  <D.104573>:
}


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

  D.105645 = __r;
  return D.105645;
}


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.105647;
  long int D.105648;
  struct RefPtr * D.105649;
  long int D.105650;
  long int D.105651;
  long int D.105652;
  long unsigned int D.105653;
  struct _Vector_impl * D.105654;

  {
    try
      {
        try
          {
            D.105647 = this->_M_impl._M_end_of_storage;
            D.105648 = (long int) D.105647;
            D.105649 = this->_M_impl._M_start;
            D.105650 = (long int) D.105649;
            D.105651 = D.105648 - D.105650;
            D.105652 = D.105651 /[ex] 8;
            D.105653 = (long unsigned int) D.105652;
            D.105649 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_deallocate (this, D.105649, D.105653);
          }
        finally
          {
            D.105654 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_impl::~_Vector_impl (D.105654);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103936>:
}


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.105659;
  typedef struct _Tr _Tr;

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


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.100357)
{
  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.103931>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        D.105663 = this->pCppObject_;
        if (D.105663 != 0B) goto <D.105664>; else goto <D.105665>;
        <D.105664>:
        D.105663 = this->pCppObject_;
        Glib::ByteArray::unreference (D.105663);
        goto <D.105666>;
        <D.105665>:
        <D.105666>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103105>:
}


static void Gio::TlsDatabase_Class::lookup_certificates_issued_by_async_vfunc_callback(GTlsDatabase*, GByteArray*, GTlsInteraction*, GTlsDatabaseLookupFlags, GCancellable*, GAsyncReadyCallback, gpointer) (struct GTlsDatabase * self, struct GByteArray * issuer_raw_dn, struct GTlsInteraction * interaction, GTlsDatabaseLookupFlags flags, struct GCancellable * cancellable, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *) callback, void * user_data)
{
  bool retval.36;
  bool iftmp.37;
  bool D.105673;
  struct CppObjectType * const iftmp.38;
  int (*__vtbl_ptr_type) () * D.105683;
  int (*__vtbl_ptr_type) () * D.105684;
  int (*__vtbl_ptr_type) () D.105685;
  struct RefPtr D.101101;
  struct RefPtr D.101100;
  struct RefPtr D.101099;
  void * D.105686;
  struct GTypeClass * D.105689;
  void (*<T11279>) (struct GTlsDatabase *, struct GByteArray *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.105692;
  const struct SlotAsyncReady * slot;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  slot = user_data;
  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105672>; else goto <D.105670>;
    <D.105672>:
    D.105673 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105673 != 0) goto <D.105674>; else goto <D.105670>;
    <D.105674>:
    iftmp.37 = 1;
    goto <D.105671>;
    <D.105670>:
    iftmp.37 = 0;
    <D.105671>:
    retval.36 = iftmp.37;
    if (retval.36 != 0) goto <D.105675>; else goto <D.105676>;
    <D.105675>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105678>; else goto <D.105679>;
      <D.105678>:
      iftmp.38 = 0B;
      goto <D.105680>;
      <D.105679>:
      iftmp.38 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105680>:
      obj = iftmp.38;
      if (obj != 0B) goto <D.105681>; else goto <D.105682>;
      <D.105681>:
      try
        {
          D.105683 = obj->D.97204._vptr.Object;
          D.105684 = D.105683 + 104;
          D.105685 = *D.105684;
          D.101101 = Glib::wrap (cancellable, 0); [return slot optimization]
          try
            {
              D.101100 = Glib::wrap (interaction, 1); [return slot optimization]
              try
                {
                  D.101099 = Glib::wrap (issuer_raw_dn, 1); [return slot optimization]
                  try
                    {
                      OBJ_TYPE_REF(D.105685;(struct TlsDatabase)obj->13) (obj, &D.101099, &D.101100, slot, &D.101101, flags);
                    }
                  finally
                    {
                      Glib::RefPtr<Glib::ByteArray>::~RefPtr (&D.101099);
                      D.101099 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::RefPtr<Gio::TlsInteraction>::~RefPtr (&D.101100);
                  D.101100 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::Cancellable>::~RefPtr (&D.101101);
              D.101101 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105686 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105686);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105687>;
      <D.105682>:
      <D.105687>:
    }
    goto <D.105688>;
    <D.105676>:
    <D.105688>:
  }
  D.105689 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105689);
  if (base != 0B) goto <D.105690>; else goto <D.105691>;
  <D.105690>:
  D.105692 = base->lookup_certificates_issued_by_async;
  if (D.105692 != 0B) goto <D.105693>; else goto <D.105694>;
  <D.105693>:
  D.105692 = base->lookup_certificates_issued_by_async;
  D.105692 (self, issuer_raw_dn, interaction, flags, cancellable, callback, user_data);
  goto <D.105695>;
  <D.105694>:
  <D.105695>:
  <D.105691>:
}


static GList* Gio::TlsDatabase_Class::lookup_certificates_issued_by_finish_vfunc_callback(GTlsDatabase*, GAsyncResult*, GError**) (struct GTlsDatabase * self, struct GAsyncResult * result, struct GError * * error)
{
  bool retval.39;
  bool iftmp.40;
  bool D.105711;
  struct CppObjectType * const iftmp.41;
  struct GList * D.105721;
  struct GListKeeperType D.101113;
  struct vector D.101112;
  int (*__vtbl_ptr_type) () * D.105722;
  int (*__vtbl_ptr_type) () * D.105723;
  int (*__vtbl_ptr_type) () D.105724;
  struct RefPtr D.101111;
  struct GList * D.105725;
  void * D.105726;
  struct GTypeClass * D.105729;
  struct GList * (*<T1127d>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.105732;
  struct GError * D.105735;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GList * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.105710>; else goto <D.105708>;
    <D.105710>:
    D.105711 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.105711 != 0) goto <D.105712>; else goto <D.105708>;
    <D.105712>:
    iftmp.40 = 1;
    goto <D.105709>;
    <D.105708>:
    iftmp.40 = 0;
    <D.105709>:
    retval.39 = iftmp.40;
    if (retval.39 != 0) goto <D.105713>; else goto <D.105714>;
    <D.105713>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.105716>; else goto <D.105717>;
      <D.105716>:
      iftmp.41 = 0B;
      goto <D.105718>;
      <D.105717>:
      iftmp.41 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsDatabaseE, -1);
      <D.105718>:
      obj = iftmp.41;
      if (obj != 0B) goto <D.105719>; else goto <D.105720>;
      <D.105719>:
      try
        {
          D.105722 = obj->D.97204._vptr.Object;
          D.105723 = D.105722 + 112;
          D.105724 = *D.105723;
          D.101111 = Glib::wrap (result, 1); [return slot optimization]
          try
            {
              D.101112 = OBJ_TYPE_REF(D.105724;(struct TlsDatabase)obj->14) (obj, &D.101111); [return slot optimization]
              try
                {
                  D.101113 = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::vector_to_list (&D.101112); [return slot optimization]
                  try
                    {
                      D.105725 = Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::data (&D.101113);
                      D.105721 = g_list_copy (D.105725);
                      return D.105721;
                    }
                  finally
                    {
                      Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::~GListKeeper (&D.101113);
                      D.101113 = {CLOBBER};
                    }
                }
              finally
                {
                  std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (&D.101112);
                  D.101112 = {CLOBBER};
                }
            }
          finally
            {
              Glib::RefPtr<Gio::AsyncResult>::~RefPtr (&D.101111);
              D.101111 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.105726 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.105726);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.105727>;
      <D.105720>:
      <D.105727>:
    }
    goto <D.105728>;
    <D.105714>:
    <D.105728>:
  }
  D.105729 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.105729);
  {
    if (base != 0B) goto <D.105730>; else goto <D.105731>;
    <D.105730>:
    D.105732 = base->lookup_certificates_issued_by_finish;
    if (D.105732 != 0B) goto <D.105733>; else goto <D.105734>;
    <D.105733>:
    {
      struct GList * retval;

      D.105732 = base->lookup_certificates_issued_by_finish;
      retval = D.105732 (self, result, error);
      D.105735 = *error;
      if (D.105735 != 0B) goto <D.105736>; else goto <D.105737>;
      <D.105736>:
      D.105735 = *error;
      Glib::Error::throw_exception (D.105735);
      <D.105737>:
      D.105721 = retval;
      return D.105721;
    }
    <D.105734>:
    <D.105731>:
  }
  D.105721 = 0B;
  return D.105721;
}


static Glib::ObjectBase* Gio::TlsDatabase_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.105753;
  struct ObjectBase * iftmp.42;
  void * D.101121;
  void * D.105755;
  int (*__vtbl_ptr_type) () * D.105758;
  int (*__vtbl_ptr_type) () * D.105759;
  long int D.105760;
  sizetype D.105761;

  D.101121 = operator new (48);
  try
    {
      Gio::TlsDatabase::TlsDatabase (D.101121, object);
    }
  catch
    {
      operator delete (D.101121);
    }
  D.105755 = D.101121;
  if (D.105755 != 0B) goto <D.105756>; else goto <D.105757>;
  <D.105756>:
  D.105758 = MEM[(struct TlsDatabase *)D.105755].D.97204._vptr.Object;
  D.105759 = D.105758 + 18446744073709551592;
  D.105760 = MEM[(long int *)D.105759];
  D.105761 = (sizetype) D.105760;
  iftmp.42 = D.105755 + D.105761;
  goto <D.105762>;
  <D.105757>:
  iftmp.42 = 0B;
  <D.105762>:
  D.105753 = iftmp.42;
  return D.105753;
}


GTlsDatabase* Gio::TlsDatabase::gobj_copy() (struct TlsDatabase * const this)
{
  int (*__vtbl_ptr_type) () * D.105766;
  int (*__vtbl_ptr_type) () * D.105767;
  long int D.105768;
  sizetype D.105769;
  struct ObjectBase * D.105770;
  int (*__vtbl_ptr_type) () * D.105771;
  int (*__vtbl_ptr_type) () * D.105772;
  int (*__vtbl_ptr_type) () D.105773;
  struct GTlsDatabase * D.105774;

  D.105766 = this->D.97204._vptr.Object;
  D.105767 = D.105766 + 18446744073709551592;
  D.105768 = MEM[(long int *)D.105767];
  D.105769 = (sizetype) D.105768;
  D.105770 = this + D.105769;
  D.105766 = this->D.97204._vptr.Object;
  D.105767 = D.105766 + 18446744073709551592;
  D.105768 = MEM[(long int *)D.105767];
  D.105769 = (sizetype) D.105768;
  D.105770 = this + D.105769;
  D.105771 = D.105770->_vptr.ObjectBase;
  D.105772 = D.105771 + 16;
  D.105773 = *D.105772;
  D.105766 = this->D.97204._vptr.Object;
  D.105767 = D.105766 + 18446744073709551592;
  D.105768 = MEM[(long int *)D.105767];
  D.105769 = (sizetype) D.105768;
  D.105770 = this + D.105769;
  OBJ_TYPE_REF(D.105773;(const struct ObjectBase)D.105770->2) (D.105770);
  D.105774 = Gio::TlsDatabase::gobj (this);
  return D.105774;
}


GTlsDatabase* Gio::TlsDatabase::gobj() (struct TlsDatabase * const this)
{
  struct GTlsDatabase * D.105776;
  int (*__vtbl_ptr_type) () * D.105777;
  int (*__vtbl_ptr_type) () * D.105778;
  long int D.105779;
  sizetype D.105780;
  struct ObjectBase * D.105781;

  D.105777 = this->D.97204._vptr.Object;
  D.105778 = D.105777 + 18446744073709551592;
  D.105779 = MEM[(long int *)D.105778];
  D.105780 = (sizetype) D.105779;
  D.105781 = this + D.105780;
  D.105776 = D.105781->gobject_;
  return D.105776;
}


Gio::TlsDatabase::TlsDatabase(const Glib::ConstructParams&) (struct TlsDatabase * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.105785;
  const void * * iftmp.43;
  struct ObjectBase * D.105793;
  const void * * iftmp.44;
  struct Object * D.105799;
  int (*__vtbl_ptr_type) () * iftmp.45;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.105807;
  int (*__vtbl_ptr_type) () * D.105808;
  long int D.105809;
  struct ObjectBase * D.105811;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  const void * * iftmp.49;

  if (0 != 0) goto <D.105783>; else goto <D.105784>;
  <D.105783>:
  D.105785 = &this->D.97207;
  sigc::trackable::trackable (D.105785);
  goto <D.105786>;
  <D.105784>:
  <D.105786>:
  try
    {
      if (0 != 0) goto <D.105787>; else goto <D.105788>;
      <D.105787>:
      if (0 == 0) goto <D.105790>; else goto <D.105791>;
      <D.105790>:
      iftmp.43 = __vtt_parm + 32;
      goto <D.105792>;
      <D.105791>:
      iftmp.43 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.105792>:
      D.105793 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.105793, iftmp.43);
      goto <D.105794>;
      <D.105788>:
      <D.105794>:
      try
        {
          if (0 == 0) goto <D.105796>; else goto <D.105797>;
          <D.105796>:
          iftmp.44 = __vtt_parm + 8;
          goto <D.105798>;
          <D.105797>:
          iftmp.44 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
          <D.105798>:
          D.105799 = &this->D.97204;
          Glib::Object::Object (D.105799, iftmp.44, construct_params);
          try
            {
              if (0 == 0) goto <D.105801>; else goto <D.105802>;
              <D.105801>:
              iftmp.45 = *__vtt_parm;
              goto <D.105803>;
              <D.105802>:
              iftmp.45 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.105803>:
              this->D.97204._vptr.Object = iftmp.45;
              if (0 == 0) goto <D.105805>; else goto <D.105806>;
              <D.105805>:
              D.105807 = this->D.97204._vptr.Object;
              D.105808 = D.105807 + 18446744073709551592;
              D.105809 = MEM[(long int *)D.105808];
              iftmp.46 = (sizetype) D.105809;
              goto <D.105810>;
              <D.105806>:
              iftmp.46 = 8;
              <D.105810>:
              D.105811 = this + iftmp.46;
              if (0 == 0) goto <D.105813>; else goto <D.105814>;
              <D.105813>:
              iftmp.47 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105815>;
              <D.105814>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.105815>:
              D.105811->_vptr.ObjectBase = iftmp.47;
            }
          catch
            {
              if (0 == 0) goto <D.105817>; else goto <D.105818>;
              <D.105817>:
              iftmp.48 = __vtt_parm + 8;
              goto <D.105819>;
              <D.105818>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.105819>:
              D.105799 = &this->D.97204;
              Glib::Object::~Object (D.105799, iftmp.48);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105820>; else goto <D.105821>;
          <D.105820>:
          if (0 == 0) goto <D.105823>; else goto <D.105824>;
          <D.105823>:
          iftmp.49 = __vtt_parm + 32;
          goto <D.105825>;
          <D.105824>:
          iftmp.49 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.105825>:
          D.105793 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.105793, iftmp.49);
          goto <D.105826>;
          <D.105821>:
          <D.105826>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105827>; else goto <D.105828>;
      <D.105827>:
      D.105785 = &this->D.97207;
      sigc::trackable::~trackable (D.105785);
      goto <D.105829>;
      <D.105828>:
      <D.105829>:
    }
}


Gio::TlsDatabase::TlsDatabase(const Glib::ConstructParams&) (struct TlsDatabase * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.105834;
  const void * * iftmp.50;
  struct ObjectBase * D.105842;
  const void * * iftmp.51;
  struct Object * D.105848;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * D.105852;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.105857;
  int (*__vtbl_ptr_type) () * D.105858;
  long int D.105859;
  struct ObjectBase * D.105861;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * iftmp.55;
  const void * * iftmp.56;

  if (1 != 0) goto <D.105832>; else goto <D.105833>;
  <D.105832>:
  D.105834 = &this->D.97207;
  sigc::trackable::trackable (D.105834);
  goto <D.105835>;
  <D.105833>:
  <D.105835>:
  try
    {
      if (1 != 0) goto <D.105836>; else goto <D.105837>;
      <D.105836>:
      if (1 == 0) goto <D.105839>; else goto <D.105840>;
      <D.105839>:
      iftmp.50 = 32B;
      goto <D.105841>;
      <D.105840>:
      iftmp.50 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.105841>:
      D.105842 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.105842, iftmp.50);
      goto <D.105843>;
      <D.105837>:
      <D.105843>:
      try
        {
          if (1 == 0) goto <D.105845>; else goto <D.105846>;
          <D.105845>:
          iftmp.51 = 8B;
          goto <D.105847>;
          <D.105846>:
          iftmp.51 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
          <D.105847>:
          D.105848 = &this->D.97204;
          Glib::Object::Object (D.105848, iftmp.51, construct_params);
          try
            {
              if (1 == 0) goto <D.105850>; else goto <D.105851>;
              <D.105850>:
              D.105852 = 0B;
              iftmp.52 = *D.105852;
              goto <D.105853>;
              <D.105851>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.105853>:
              this->D.97204._vptr.Object = iftmp.52;
              if (1 == 0) goto <D.105855>; else goto <D.105856>;
              <D.105855>:
              D.105857 = this->D.97204._vptr.Object;
              D.105858 = D.105857 + 18446744073709551592;
              D.105859 = MEM[(long int *)D.105858];
              iftmp.53 = (sizetype) D.105859;
              goto <D.105860>;
              <D.105856>:
              iftmp.53 = 8;
              <D.105860>:
              D.105861 = this + iftmp.53;
              if (1 == 0) goto <D.105863>; else goto <D.105864>;
              <D.105863>:
              iftmp.54 = MEM[(const void * *)0B + 24B];
              goto <D.105865>;
              <D.105864>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.105865>:
              D.105861->_vptr.ObjectBase = iftmp.54;
            }
          catch
            {
              if (1 == 0) goto <D.105867>; else goto <D.105868>;
              <D.105867>:
              iftmp.55 = 8B;
              goto <D.105869>;
              <D.105868>:
              iftmp.55 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.105869>:
              D.105848 = &this->D.97204;
              Glib::Object::~Object (D.105848, iftmp.55);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105870>; else goto <D.105871>;
          <D.105870>:
          if (1 == 0) goto <D.105873>; else goto <D.105874>;
          <D.105873>:
          iftmp.56 = 32B;
          goto <D.105875>;
          <D.105874>:
          iftmp.56 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.105875>:
          D.105842 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.105842, iftmp.56);
          goto <D.105876>;
          <D.105871>:
          <D.105876>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105877>; else goto <D.105878>;
      <D.105877>:
      D.105834 = &this->D.97207;
      sigc::trackable::~trackable (D.105834);
      goto <D.105879>;
      <D.105878>:
      <D.105879>:
    }
}


Gio::TlsDatabase::TlsDatabase(GTlsDatabase*) (struct TlsDatabase * const this, const void * * __vtt_parm, struct GTlsDatabase * castitem)
{
  struct trackable * D.105884;
  const void * * iftmp.57;
  struct ObjectBase * D.105892;
  const void * * iftmp.58;
  struct Object * D.105898;
  int (*__vtbl_ptr_type) () * iftmp.59;
  sizetype iftmp.60;
  int (*__vtbl_ptr_type) () * D.105906;
  int (*__vtbl_ptr_type) () * D.105907;
  long int D.105908;
  struct ObjectBase * D.105910;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * iftmp.62;
  const void * * iftmp.63;

  if (0 != 0) goto <D.105882>; else goto <D.105883>;
  <D.105882>:
  D.105884 = &this->D.97207;
  sigc::trackable::trackable (D.105884);
  goto <D.105885>;
  <D.105883>:
  <D.105885>:
  try
    {
      if (0 != 0) goto <D.105886>; else goto <D.105887>;
      <D.105886>:
      if (0 == 0) goto <D.105889>; else goto <D.105890>;
      <D.105889>:
      iftmp.57 = __vtt_parm + 32;
      goto <D.105891>;
      <D.105890>:
      iftmp.57 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.105891>:
      D.105892 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.105892, iftmp.57);
      goto <D.105893>;
      <D.105887>:
      <D.105893>:
      try
        {
          if (0 == 0) goto <D.105895>; else goto <D.105896>;
          <D.105895>:
          iftmp.58 = __vtt_parm + 8;
          goto <D.105897>;
          <D.105896>:
          iftmp.58 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
          <D.105897>:
          D.105898 = &this->D.97204;
          Glib::Object::Object (D.105898, iftmp.58, castitem);
          try
            {
              if (0 == 0) goto <D.105900>; else goto <D.105901>;
              <D.105900>:
              iftmp.59 = *__vtt_parm;
              goto <D.105902>;
              <D.105901>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.105902>:
              this->D.97204._vptr.Object = iftmp.59;
              if (0 == 0) goto <D.105904>; else goto <D.105905>;
              <D.105904>:
              D.105906 = this->D.97204._vptr.Object;
              D.105907 = D.105906 + 18446744073709551592;
              D.105908 = MEM[(long int *)D.105907];
              iftmp.60 = (sizetype) D.105908;
              goto <D.105909>;
              <D.105905>:
              iftmp.60 = 8;
              <D.105909>:
              D.105910 = this + iftmp.60;
              if (0 == 0) goto <D.105912>; else goto <D.105913>;
              <D.105912>:
              iftmp.61 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105914>;
              <D.105913>:
              iftmp.61 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.105914>:
              D.105910->_vptr.ObjectBase = iftmp.61;
            }
          catch
            {
              if (0 == 0) goto <D.105916>; else goto <D.105917>;
              <D.105916>:
              iftmp.62 = __vtt_parm + 8;
              goto <D.105918>;
              <D.105917>:
              iftmp.62 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.105918>:
              D.105898 = &this->D.97204;
              Glib::Object::~Object (D.105898, iftmp.62);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105919>; else goto <D.105920>;
          <D.105919>:
          if (0 == 0) goto <D.105922>; else goto <D.105923>;
          <D.105922>:
          iftmp.63 = __vtt_parm + 32;
          goto <D.105924>;
          <D.105923>:
          iftmp.63 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.105924>:
          D.105892 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.105892, iftmp.63);
          goto <D.105925>;
          <D.105920>:
          <D.105925>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105926>; else goto <D.105927>;
      <D.105926>:
      D.105884 = &this->D.97207;
      sigc::trackable::~trackable (D.105884);
      goto <D.105928>;
      <D.105927>:
      <D.105928>:
    }
}


Gio::TlsDatabase::TlsDatabase(GTlsDatabase*) (struct TlsDatabase * const this, struct GTlsDatabase * castitem)
{
  struct trackable * D.105933;
  const void * * iftmp.64;
  struct ObjectBase * D.105941;
  const void * * iftmp.65;
  struct Object * D.105947;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * D.105951;
  sizetype iftmp.67;
  int (*__vtbl_ptr_type) () * D.105956;
  int (*__vtbl_ptr_type) () * D.105957;
  long int D.105958;
  struct ObjectBase * D.105960;
  int (*__vtbl_ptr_type) () * iftmp.68;
  const void * * iftmp.69;
  const void * * iftmp.70;

  if (1 != 0) goto <D.105931>; else goto <D.105932>;
  <D.105931>:
  D.105933 = &this->D.97207;
  sigc::trackable::trackable (D.105933);
  goto <D.105934>;
  <D.105932>:
  <D.105934>:
  try
    {
      if (1 != 0) goto <D.105935>; else goto <D.105936>;
      <D.105935>:
      if (1 == 0) goto <D.105938>; else goto <D.105939>;
      <D.105938>:
      iftmp.64 = 32B;
      goto <D.105940>;
      <D.105939>:
      iftmp.64 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.105940>:
      D.105941 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.105941, iftmp.64);
      goto <D.105942>;
      <D.105936>:
      <D.105942>:
      try
        {
          if (1 == 0) goto <D.105944>; else goto <D.105945>;
          <D.105944>:
          iftmp.65 = 8B;
          goto <D.105946>;
          <D.105945>:
          iftmp.65 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
          <D.105946>:
          D.105947 = &this->D.97204;
          Glib::Object::Object (D.105947, iftmp.65, castitem);
          try
            {
              if (1 == 0) goto <D.105949>; else goto <D.105950>;
              <D.105949>:
              D.105951 = 0B;
              iftmp.66 = *D.105951;
              goto <D.105952>;
              <D.105950>:
              iftmp.66 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.105952>:
              this->D.97204._vptr.Object = iftmp.66;
              if (1 == 0) goto <D.105954>; else goto <D.105955>;
              <D.105954>:
              D.105956 = this->D.97204._vptr.Object;
              D.105957 = D.105956 + 18446744073709551592;
              D.105958 = MEM[(long int *)D.105957];
              iftmp.67 = (sizetype) D.105958;
              goto <D.105959>;
              <D.105955>:
              iftmp.67 = 8;
              <D.105959>:
              D.105960 = this + iftmp.67;
              if (1 == 0) goto <D.105962>; else goto <D.105963>;
              <D.105962>:
              iftmp.68 = MEM[(const void * *)0B + 24B];
              goto <D.105964>;
              <D.105963>:
              iftmp.68 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.105964>:
              D.105960->_vptr.ObjectBase = iftmp.68;
            }
          catch
            {
              if (1 == 0) goto <D.105966>; else goto <D.105967>;
              <D.105966>:
              iftmp.69 = 8B;
              goto <D.105968>;
              <D.105967>:
              iftmp.69 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.105968>:
              D.105947 = &this->D.97204;
              Glib::Object::~Object (D.105947, iftmp.69);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105969>; else goto <D.105970>;
          <D.105969>:
          if (1 == 0) goto <D.105972>; else goto <D.105973>;
          <D.105972>:
          iftmp.70 = 32B;
          goto <D.105974>;
          <D.105973>:
          iftmp.70 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.105974>:
          D.105941 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.105941, iftmp.70);
          goto <D.105975>;
          <D.105970>:
          <D.105975>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105976>; else goto <D.105977>;
      <D.105976>:
      D.105933 = &this->D.97207;
      sigc::trackable::~trackable (D.105933);
      goto <D.105978>;
      <D.105977>:
      <D.105978>:
    }
}


Gio::TlsDatabase::~TlsDatabase() (struct TlsDatabase * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.71;
  sizetype iftmp.72;
  int (*__vtbl_ptr_type) () * D.105988;
  int (*__vtbl_ptr_type) () * D.105989;
  long int D.105990;
  struct ObjectBase * D.105992;
  int (*__vtbl_ptr_type) () * iftmp.73;
  const void * * iftmp.74;
  struct Object * D.106001;
  int D.106002;
  const void * * iftmp.75;
  struct ObjectBase * D.106009;
  struct trackable * D.106013;
  int D.106015;

  {
    if (0 == 0) goto <D.105982>; else goto <D.105983>;
    <D.105982>:
    iftmp.71 = *__vtt_parm;
    goto <D.105984>;
    <D.105983>:
    iftmp.71 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
    <D.105984>:
    this->D.97204._vptr.Object = iftmp.71;
    if (0 == 0) goto <D.105986>; else goto <D.105987>;
    <D.105986>:
    D.105988 = this->D.97204._vptr.Object;
    D.105989 = D.105988 + 18446744073709551592;
    D.105990 = MEM[(long int *)D.105989];
    iftmp.72 = (sizetype) D.105990;
    goto <D.105991>;
    <D.105987>:
    iftmp.72 = 8;
    <D.105991>:
    D.105992 = this + iftmp.72;
    if (0 == 0) goto <D.105994>; else goto <D.105995>;
    <D.105994>:
    iftmp.73 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.105996>;
    <D.105995>:
    iftmp.73 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
    <D.105996>:
    D.105992->_vptr.ObjectBase = iftmp.73;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.105998>; else goto <D.105999>;
                    <D.105998>:
                    iftmp.74 = __vtt_parm + 8;
                    goto <D.106000>;
                    <D.105999>:
                    iftmp.74 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
                    <D.106000>:
                    D.106001 = &this->D.97204;
                    Glib::Object::~Object (D.106001, iftmp.74);
                  }
              }
            finally
              {
                D.106002 = 0;
                if (D.106002 != 0) goto <D.106003>; else goto <D.106004>;
                <D.106003>:
                if (0 == 0) goto <D.106006>; else goto <D.106007>;
                <D.106006>:
                iftmp.75 = __vtt_parm + 32;
                goto <D.106008>;
                <D.106007>:
                iftmp.75 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
                <D.106008>:
                D.106009 = &this->D.97206;
                Glib::ObjectBase::~ObjectBase (D.106009, iftmp.75);
                goto <D.106010>;
                <D.106004>:
                <D.106010>:
              }
          }
        finally
          {
            D.106002 = 0;
            if (D.106002 != 0) goto <D.106011>; else goto <D.106012>;
            <D.106011>:
            D.106013 = &this->D.97207;
            sigc::trackable::~trackable (D.106013);
            goto <D.106014>;
            <D.106012>:
            <D.106014>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101149>:
  D.106015 = 0;
  if (D.106015 != 0) goto <D.106016>; else goto <D.106017>;
  <D.106016>:
  operator delete (this);
  goto <D.106018>;
  <D.106017>:
  <D.106018>:
}


virtual Gio::TlsDatabase::~TlsDatabase() (struct TlsDatabase * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.76;
  const void * * D.106034;
  sizetype iftmp.77;
  int (*__vtbl_ptr_type) () * D.106039;
  int (*__vtbl_ptr_type) () * D.106040;
  long int D.106041;
  struct ObjectBase * D.106043;
  int (*__vtbl_ptr_type) () * iftmp.78;
  const void * * iftmp.79;
  struct Object * D.106052;
  int D.106053;
  const void * * iftmp.80;
  struct ObjectBase * D.106060;
  struct trackable * D.106064;
  int D.106066;

  {
    if (2 == 0) goto <D.106032>; else goto <D.106033>;
    <D.106032>:
    D.106034 = 0B;
    iftmp.76 = *D.106034;
    goto <D.106035>;
    <D.106033>:
    iftmp.76 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
    <D.106035>:
    this->D.97204._vptr.Object = iftmp.76;
    if (2 == 0) goto <D.106037>; else goto <D.106038>;
    <D.106037>:
    D.106039 = this->D.97204._vptr.Object;
    D.106040 = D.106039 + 18446744073709551592;
    D.106041 = MEM[(long int *)D.106040];
    iftmp.77 = (sizetype) D.106041;
    goto <D.106042>;
    <D.106038>:
    iftmp.77 = 8;
    <D.106042>:
    D.106043 = this + iftmp.77;
    if (2 == 0) goto <D.106045>; else goto <D.106046>;
    <D.106045>:
    iftmp.78 = MEM[(const void * *)0B + 24B];
    goto <D.106047>;
    <D.106046>:
    iftmp.78 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
    <D.106047>:
    D.106043->_vptr.ObjectBase = iftmp.78;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.106049>; else goto <D.106050>;
                    <D.106049>:
                    iftmp.79 = 8B;
                    goto <D.106051>;
                    <D.106050>:
                    iftmp.79 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
                    <D.106051>:
                    D.106052 = &this->D.97204;
                    Glib::Object::~Object (D.106052, iftmp.79);
                  }
              }
            finally
              {
                D.106053 = 2;
                if (D.106053 != 0) goto <D.106054>; else goto <D.106055>;
                <D.106054>:
                if (2 == 0) goto <D.106057>; else goto <D.106058>;
                <D.106057>:
                iftmp.80 = 32B;
                goto <D.106059>;
                <D.106058>:
                iftmp.80 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
                <D.106059>:
                D.106060 = &this->D.97206;
                Glib::ObjectBase::~ObjectBase (D.106060, iftmp.80);
                goto <D.106061>;
                <D.106055>:
                <D.106061>:
              }
          }
        finally
          {
            D.106053 = 2;
            if (D.106053 != 0) goto <D.106062>; else goto <D.106063>;
            <D.106062>:
            D.106064 = &this->D.97207;
            sigc::trackable::~trackable (D.106064);
            goto <D.106065>;
            <D.106063>:
            <D.106065>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.101152>:
  D.106066 = 0;
  if (D.106066 != 0) goto <D.106067>; else goto <D.106068>;
  <D.106067>:
  operator delete (this);
  goto <D.106069>;
  <D.106068>:
  <D.106069>:
}


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


static GType Gio::TlsDatabase::get_type() ()
{
  GType D.106082;
  const struct Class & D.106083;

  D.106083 = Gio::TlsDatabase_Class::init (&tlsdatabase_class_);
  D.106082 = Glib::Class::get_type (D.106083);
  return D.106082;
}


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

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


static GType Gio::TlsDatabase::get_base_type() ()
{
  GType D.106088;

  D.106088 = g_tls_database_get_type ();
  return D.106088;
}


Gio::TlsDatabase::TlsDatabase() (struct TlsDatabase * const this, const void * * __vtt_parm)
{
  struct trackable * D.106093;
  const void * * iftmp.81;
  struct ObjectBase * D.106101;
  struct ConstructParams D.101175;
  const struct Class & D.106103;
  const void * * iftmp.82;
  struct Object * D.106108;
  int (*__vtbl_ptr_type) () * iftmp.83;
  sizetype iftmp.84;
  int (*__vtbl_ptr_type) () * D.106116;
  int (*__vtbl_ptr_type) () * D.106117;
  long int D.106118;
  struct ObjectBase * D.106120;
  int (*__vtbl_ptr_type) () * iftmp.85;
  const void * * iftmp.86;
  const void * * iftmp.87;

  if (0 != 0) goto <D.106091>; else goto <D.106092>;
  <D.106091>:
  D.106093 = &this->D.97207;
  sigc::trackable::trackable (D.106093);
  goto <D.106094>;
  <D.106092>:
  <D.106094>:
  try
    {
      if (0 != 0) goto <D.106095>; else goto <D.106096>;
      <D.106095>:
      if (0 == 0) goto <D.106098>; else goto <D.106099>;
      <D.106098>:
      iftmp.81 = __vtt_parm + 32;
      goto <D.106100>;
      <D.106099>:
      iftmp.81 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.106100>:
      D.106101 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.106101, iftmp.81, 0B);
      goto <D.106102>;
      <D.106096>:
      <D.106102>:
      try
        {
          D.106103 = Gio::TlsDatabase_Class::init (&tlsdatabase_class_);
          Glib::ConstructParams::ConstructParams (&D.101175, D.106103);
          try
            {
              if (0 == 0) goto <D.106105>; else goto <D.106106>;
              <D.106105>:
              iftmp.82 = __vtt_parm + 8;
              goto <D.106107>;
              <D.106106>:
              iftmp.82 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.106107>:
              D.106108 = &this->D.97204;
              Glib::Object::Object (D.106108, iftmp.82, &D.101175);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101175);
              D.101175 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.106110>; else goto <D.106111>;
              <D.106110>:
              iftmp.83 = *__vtt_parm;
              goto <D.106112>;
              <D.106111>:
              iftmp.83 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.106112>:
              this->D.97204._vptr.Object = iftmp.83;
              if (0 == 0) goto <D.106114>; else goto <D.106115>;
              <D.106114>:
              D.106116 = this->D.97204._vptr.Object;
              D.106117 = D.106116 + 18446744073709551592;
              D.106118 = MEM[(long int *)D.106117];
              iftmp.84 = (sizetype) D.106118;
              goto <D.106119>;
              <D.106115>:
              iftmp.84 = 8;
              <D.106119>:
              D.106120 = this + iftmp.84;
              if (0 == 0) goto <D.106122>; else goto <D.106123>;
              <D.106122>:
              iftmp.85 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.106124>;
              <D.106123>:
              iftmp.85 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.106124>:
              D.106120->_vptr.ObjectBase = iftmp.85;
            }
          catch
            {
              if (0 == 0) goto <D.106126>; else goto <D.106127>;
              <D.106126>:
              iftmp.86 = __vtt_parm + 8;
              goto <D.106128>;
              <D.106127>:
              iftmp.86 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.106128>:
              D.106108 = &this->D.97204;
              Glib::Object::~Object (D.106108, iftmp.86);
            }
        }
      catch
        {
          if (0 != 0) goto <D.106129>; else goto <D.106130>;
          <D.106129>:
          if (0 == 0) goto <D.106132>; else goto <D.106133>;
          <D.106132>:
          iftmp.87 = __vtt_parm + 32;
          goto <D.106134>;
          <D.106133>:
          iftmp.87 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.106134>:
          D.106101 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.106101, iftmp.87);
          goto <D.106135>;
          <D.106130>:
          <D.106135>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.106136>; else goto <D.106137>;
      <D.106136>:
      D.106093 = &this->D.97207;
      sigc::trackable::~trackable (D.106093);
      goto <D.106138>;
      <D.106137>:
      <D.106138>:
    }
}


Gio::TlsDatabase::TlsDatabase() (struct TlsDatabase * const this)
{
  struct trackable * D.106145;
  const void * * iftmp.88;
  struct ObjectBase * D.106153;
  struct ConstructParams D.101177;
  const struct Class & D.106155;
  const void * * iftmp.89;
  struct Object * D.106160;
  int (*__vtbl_ptr_type) () * iftmp.90;
  const void * * D.106164;
  sizetype iftmp.91;
  int (*__vtbl_ptr_type) () * D.106169;
  int (*__vtbl_ptr_type) () * D.106170;
  long int D.106171;
  struct ObjectBase * D.106173;
  int (*__vtbl_ptr_type) () * iftmp.92;
  const void * * iftmp.93;
  const void * * iftmp.94;

  if (1 != 0) goto <D.106143>; else goto <D.106144>;
  <D.106143>:
  D.106145 = &this->D.97207;
  sigc::trackable::trackable (D.106145);
  goto <D.106146>;
  <D.106144>:
  <D.106146>:
  try
    {
      if (1 != 0) goto <D.106147>; else goto <D.106148>;
      <D.106147>:
      if (1 == 0) goto <D.106150>; else goto <D.106151>;
      <D.106150>:
      iftmp.88 = 32B;
      goto <D.106152>;
      <D.106151>:
      iftmp.88 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
      <D.106152>:
      D.106153 = &this->D.97206;
      Glib::ObjectBase::ObjectBase (D.106153, iftmp.88, 0B);
      goto <D.106154>;
      <D.106148>:
      <D.106154>:
      try
        {
          D.106155 = Gio::TlsDatabase_Class::init (&tlsdatabase_class_);
          Glib::ConstructParams::ConstructParams (&D.101177, D.106155);
          try
            {
              if (1 == 0) goto <D.106157>; else goto <D.106158>;
              <D.106157>:
              iftmp.89 = 8B;
              goto <D.106159>;
              <D.106158>:
              iftmp.89 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.106159>:
              D.106160 = &this->D.97204;
              Glib::Object::Object (D.106160, iftmp.89, &D.101177);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101177);
              D.101177 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.106162>; else goto <D.106163>;
              <D.106162>:
              D.106164 = 0B;
              iftmp.90 = *D.106164;
              goto <D.106165>;
              <D.106163>:
              iftmp.90 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 32B];
              <D.106165>:
              this->D.97204._vptr.Object = iftmp.90;
              if (1 == 0) goto <D.106167>; else goto <D.106168>;
              <D.106167>:
              D.106169 = this->D.97204._vptr.Object;
              D.106170 = D.106169 + 18446744073709551592;
              D.106171 = MEM[(long int *)D.106170];
              iftmp.91 = (sizetype) D.106171;
              goto <D.106172>;
              <D.106168>:
              iftmp.91 = 8;
              <D.106172>:
              D.106173 = this + iftmp.91;
              if (1 == 0) goto <D.106175>; else goto <D.106176>;
              <D.106175>:
              iftmp.92 = MEM[(const void * *)0B + 24B];
              goto <D.106177>;
              <D.106176>:
              iftmp.92 = &MEM[(void *)&_ZTVN3Gio11TlsDatabaseE + 216B];
              <D.106177>:
              D.106173->_vptr.ObjectBase = iftmp.92;
            }
          catch
            {
              if (1 == 0) goto <D.106179>; else goto <D.106180>;
              <D.106179>:
              iftmp.93 = 8B;
              goto <D.106181>;
              <D.106180>:
              iftmp.93 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 8B];
              <D.106181>:
              D.106160 = &this->D.97204;
              Glib::Object::~Object (D.106160, iftmp.93);
            }
        }
      catch
        {
          if (1 != 0) goto <D.106182>; else goto <D.106183>;
          <D.106182>:
          if (1 == 0) goto <D.106185>; else goto <D.106186>;
          <D.106185>:
          iftmp.94 = 32B;
          goto <D.106187>;
          <D.106186>:
          iftmp.94 = &MEM[(void *)&_ZTTN3Gio11TlsDatabaseE + 32B];
          <D.106187>:
          D.106153 = &this->D.97206;
          Glib::ObjectBase::~ObjectBase (D.106153, iftmp.94);
          goto <D.106188>;
          <D.106183>:
          <D.106188>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.106189>; else goto <D.106190>;
      <D.106189>:
      D.106145 = &this->D.97207;
      sigc::trackable::~trackable (D.106145);
      goto <D.106191>;
      <D.106190>:
      <D.106191>:
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106196;
  struct BaseObjectType * D.106197;
  const struct BaseObjectType * D.106198;
  const char * D.106199;
  struct BaseObjectType * D.106200;
  const struct GTlsDatabase * D.106201;
  struct GError * gerror.95;
  TlsCertificateFlags D.106205;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106196 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106197 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106198 = Glib::unwrap<Gio::SocketConnectable> (identity);
      D.106199 = Glib::ustring::c_str (purpose);
      D.106200 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106201 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106201, D.106200, D.106199, D.106198, D.106197, flags, D.106196, &gerror);
      gerror.95 = gerror;
      if (gerror.95 != 0B) goto <D.106203>; else goto <D.106204>;
      <D.106203>:
      gerror.95 = gerror;
      Glib::Error::throw_exception (gerror.95);
      <D.106204>:
      D.106205 = retvalue;
      return D.106205;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.106215;
  struct BaseObjectType * iftmp.96;
  bool D.106217;
  struct Cancellable * D.106220;

  D.106217 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.106217 != 0) goto <D.106218>; else goto <D.106219>;
  <D.106218>:
  D.106220 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.96 = Gio::Cancellable::gobj (D.106220);
  goto <D.106221>;
  <D.106219>:
  iftmp.96 = 0B;
  <D.106221>:
  D.106215 = iftmp.96;
  return D.106215;
}


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

  D.106224 = this->pCppObject_;
  D.106223 = D.106224 != 0B;
  return D.106223;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.106228;
  int (*__vtbl_ptr_type) () * D.106229;
  int (*__vtbl_ptr_type) () * D.106230;
  long int D.106231;
  sizetype D.106232;
  struct ObjectBase * D.106233;

  D.106229 = this->D.97456._vptr.Object;
  D.106230 = D.106229 + 18446744073709551592;
  D.106231 = MEM[(long int *)D.106230];
  D.106232 = (sizetype) D.106231;
  D.106233 = this + D.106232;
  D.106228 = D.106233->gobject_;
  return D.106228;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::TlsInteraction; typename T::BaseObjectType = _GTlsInteraction] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.106235;
  struct BaseObjectType * iftmp.97;
  bool D.106237;
  struct TlsInteraction * D.106240;

  D.106237 = Glib::RefPtr<Gio::TlsInteraction>::operator bool (ptr);
  if (D.106237 != 0) goto <D.106238>; else goto <D.106239>;
  <D.106238>:
  D.106240 = Glib::RefPtr<Gio::TlsInteraction>::operator-> (ptr);
  iftmp.97 = Gio::TlsInteraction::gobj (D.106240);
  goto <D.106241>;
  <D.106239>:
  iftmp.97 = 0B;
  <D.106241>:
  D.106235 = iftmp.97;
  return D.106235;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::TlsInteraction] (const struct RefPtr * const this)
{
  bool D.106243;
  struct TlsInteraction * D.106244;

  D.106244 = this->pCppObject_;
  D.106243 = D.106244 != 0B;
  return D.106243;
}


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

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


GTlsInteraction* Gio::TlsInteraction::gobj() (struct TlsInteraction * const this)
{
  struct GTlsInteraction * D.106248;
  int (*__vtbl_ptr_type) () * D.106249;
  int (*__vtbl_ptr_type) () * D.106250;
  long int D.106251;
  sizetype D.106252;
  struct ObjectBase * D.106253;

  D.106249 = this->D.99027._vptr.Object;
  D.106250 = D.106249 + 18446744073709551592;
  D.106251 = MEM[(long int *)D.106250];
  D.106252 = (sizetype) D.106251;
  D.106253 = this + D.106252;
  D.106248 = D.106253->gobject_;
  return D.106248;
}


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.106255;
  const struct BaseObjectType * iftmp.98;
  bool D.106257;
  const struct SocketConnectable * D.106260;

  D.106257 = Glib::RefPtr<const Gio::SocketConnectable>::operator bool (ptr);
  if (D.106257 != 0) goto <D.106258>; else goto <D.106259>;
  <D.106258>:
  D.106260 = Glib::RefPtr<const Gio::SocketConnectable>::operator-> (ptr);
  iftmp.98 = Gio::SocketConnectable::gobj (D.106260);
  goto <D.106261>;
  <D.106259>:
  iftmp.98 = 0B;
  <D.106261>:
  D.106255 = iftmp.98;
  return D.106255;
}


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

  D.106264 = this->pCppObject_;
  D.106263 = D.106264 != 0B;
  return D.106263;
}


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

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


const GSocketConnectable* Gio::SocketConnectable::gobj() const (const struct SocketConnectable * const this)
{
  const struct GSocketConnectable * D.106268;
  int (*__vtbl_ptr_type) () * D.106269;
  int (*__vtbl_ptr_type) () * D.106270;
  long int D.106271;
  sizetype D.106272;
  const struct ObjectBase * D.106273;

  D.106269 = this->D.97692._vptr.Interface;
  D.106270 = D.106269 + 18446744073709551592;
  D.106271 = MEM[(long int *)D.106270];
  D.106272 = (sizetype) D.106271;
  D.106273 = this + D.106272;
  D.106268 = D.106273->gobject_;
  return D.106268;
}


const GTlsDatabase* Gio::TlsDatabase::gobj() const (const struct TlsDatabase * const this)
{
  const struct GTlsDatabase * D.106275;
  int (*__vtbl_ptr_type) () * D.106276;
  int (*__vtbl_ptr_type) () * D.106277;
  long int D.106278;
  sizetype D.106279;
  const struct ObjectBase * D.106280;

  D.106276 = this->D.97204._vptr.Object;
  D.106277 = D.106276 + 18446744073709551592;
  D.106278 = MEM[(long int *)D.106277];
  D.106279 = (sizetype) D.106278;
  D.106280 = this + D.106279;
  D.106275 = D.106280->gobject_;
  return D.106275;
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106282;
  const struct BaseObjectType * D.106283;
  const char * D.106284;
  struct BaseObjectType * D.106285;
  const struct GTlsDatabase * D.106286;
  struct GError * gerror.99;
  TlsCertificateFlags D.106290;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106282 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106283 = Glib::unwrap<Gio::SocketConnectable> (identity);
      D.106284 = Glib::ustring::c_str (purpose);
      D.106285 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106286 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106286, D.106285, D.106284, D.106283, D.106282, flags, 0B, &gerror);
      gerror.99 = gerror;
      if (gerror.99 != 0B) goto <D.106288>; else goto <D.106289>;
      <D.106288>:
      gerror.99 = gerror;
      Glib::Error::throw_exception (gerror.99);
      <D.106289>:
      D.106290 = retvalue;
      return D.106290;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106299;
  const struct BaseObjectType * D.106300;
  const char * D.106301;
  struct BaseObjectType * D.106302;
  const struct GTlsDatabase * D.106303;
  struct GError * gerror.100;
  TlsCertificateFlags D.106307;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106299 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106300 = Glib::unwrap<Gio::SocketConnectable> (identity);
      D.106301 = Glib::ustring::c_str (purpose);
      D.106302 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106303 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106303, D.106302, D.106301, D.106300, 0B, flags, D.106299, &gerror);
      gerror.100 = gerror;
      if (gerror.100 != 0B) goto <D.106305>; else goto <D.106306>;
      <D.106305>:
      gerror.100 = gerror;
      Glib::Error::throw_exception (gerror.100);
      <D.106306>:
      D.106307 = retvalue;
      return D.106307;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, TlsDatabaseVerifyFlags flags)
{
  const struct BaseObjectType * D.106316;
  const char * D.106317;
  struct BaseObjectType * D.106318;
  const struct GTlsDatabase * D.106319;
  struct GError * gerror.101;
  TlsCertificateFlags D.106323;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106316 = Glib::unwrap<Gio::SocketConnectable> (identity);
      D.106317 = Glib::ustring::c_str (purpose);
      D.106318 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106319 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106319, D.106318, D.106317, D.106316, 0B, flags, 0B, &gerror);
      gerror.101 = gerror;
      if (gerror.101 != 0B) goto <D.106321>; else goto <D.106322>;
      <D.106321>:
      gerror.101 = gerror;
      Glib::Error::throw_exception (gerror.101);
      <D.106322>:
      D.106323 = retvalue;
      return D.106323;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106331;
  struct BaseObjectType * D.106332;
  const char * D.106333;
  struct BaseObjectType * D.106334;
  const struct GTlsDatabase * D.106335;
  struct GError * gerror.102;
  TlsCertificateFlags D.106339;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106331 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106332 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106333 = Glib::ustring::c_str (purpose);
      D.106334 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106335 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106335, D.106334, D.106333, 0B, D.106332, flags, D.106331, &gerror);
      gerror.102 = gerror;
      if (gerror.102 != 0B) goto <D.106337>; else goto <D.106338>;
      <D.106337>:
      gerror.102 = gerror;
      Glib::Error::throw_exception (gerror.102);
      <D.106338>:
      D.106339 = retvalue;
      return D.106339;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & interaction, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106348;
  const char * D.106349;
  struct BaseObjectType * D.106350;
  const struct GTlsDatabase * D.106351;
  struct GError * gerror.103;
  TlsCertificateFlags D.106355;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106348 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106349 = Glib::ustring::c_str (purpose);
      D.106350 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106351 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106351, D.106350, D.106349, 0B, D.106348, flags, 0B, &gerror);
      gerror.103 = gerror;
      if (gerror.103 != 0B) goto <D.106353>; else goto <D.106354>;
      <D.106353>:
      gerror.103 = gerror;
      Glib::Error::throw_exception (gerror.103);
      <D.106354>:
      D.106355 = retvalue;
      return D.106355;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  struct BaseObjectType * D.106363;
  const char * D.106364;
  struct BaseObjectType * D.106365;
  const struct GTlsDatabase * D.106366;
  struct GError * gerror.104;
  TlsCertificateFlags D.106370;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106363 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106364 = Glib::ustring::c_str (purpose);
      D.106365 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106366 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106366, D.106365, D.106364, 0B, 0B, flags, D.106363, &gerror);
      gerror.104 = gerror;
      if (gerror.104 != 0B) goto <D.106368>; else goto <D.106369>;
      <D.106368>:
      gerror.104 = gerror;
      Glib::Error::throw_exception (gerror.104);
      <D.106369>:
      D.106370 = retvalue;
      return D.106370;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, TlsDatabaseVerifyFlags flags)
{
  const char * D.106378;
  struct BaseObjectType * D.106379;
  const struct GTlsDatabase * D.106380;
  struct GError * gerror.105;
  TlsCertificateFlags D.106384;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106378 = Glib::ustring::c_str (purpose);
      D.106379 = Glib::unwrap<Gio::TlsCertificate> (chain);
      D.106380 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain (D.106380, D.106379, D.106378, 0B, 0B, flags, 0B, &gerror);
      gerror.105 = gerror;
      if (gerror.105 != 0B) goto <D.106382>; else goto <D.106383>;
      <D.106382>:
      gerror.105 = gerror;
      Glib::Error::throw_exception (gerror.105);
      <D.106383>:
      D.106384 = retvalue;
      return D.106384;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.106;
  struct BaseObjectType * D.106391;
  struct BaseObjectType * D.106392;
  const struct BaseObjectType * D.106393;
  const char * D.106394;
  struct BaseObjectType * D.106395;
  const struct GTlsDatabase * D.106396;
  struct SlotAsyncReady * slot_copy;

  slot_copy.106 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.106, slot);
    }
  catch
    {
      operator delete (slot_copy.106);
    }
  slot_copy = slot_copy.106;
  D.106391 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106392 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106393 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.106394 = Glib::ustring::c_str (purpose);
  D.106395 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106396 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106396, D.106395, D.106394, D.106393, D.106392, flags, D.106391, SignalProxy_async_callback, slot_copy);
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.106404;

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

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


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.106405;
  struct slot_base * D.106406;

  D.106405 = &src->D.101330;
  D.106406 = &this->D.101330;
  sigc::slot_base::slot_base (D.106406, D.106405);
  try
    {

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


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.107;
  struct BaseObjectType * D.106407;
  const struct BaseObjectType * D.106408;
  const char * D.106409;
  struct BaseObjectType * D.106410;
  const struct GTlsDatabase * D.106411;
  struct SlotAsyncReady * slot_copy;

  slot_copy.107 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.107, slot);
    }
  catch
    {
      operator delete (slot_copy.107);
    }
  slot_copy = slot_copy.107;
  D.106407 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106408 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.106409 = Glib::ustring::c_str (purpose);
  D.106410 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106411 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106411, D.106410, D.106409, D.106408, D.106407, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.108;
  struct BaseObjectType * D.106418;
  const struct BaseObjectType * D.106419;
  const char * D.106420;
  struct BaseObjectType * D.106421;
  const struct GTlsDatabase * D.106422;
  struct SlotAsyncReady * slot_copy;

  slot_copy.108 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.108, slot);
    }
  catch
    {
      operator delete (slot_copy.108);
    }
  slot_copy = slot_copy.108;
  D.106418 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106419 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.106420 = Glib::ustring::c_str (purpose);
  D.106421 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106422 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106422, D.106421, D.106420, D.106419, 0B, flags, D.106418, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const SlotAsyncReady&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct SlotAsyncReady & slot, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.109;
  const struct BaseObjectType * D.106429;
  const char * D.106430;
  struct BaseObjectType * D.106431;
  const struct GTlsDatabase * D.106432;
  struct SlotAsyncReady * slot_copy;

  slot_copy.109 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.109, slot);
    }
  catch
    {
      operator delete (slot_copy.109);
    }
  slot_copy = slot_copy.109;
  D.106429 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.106430 = Glib::ustring::c_str (purpose);
  D.106431 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106432 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106432, D.106431, D.106430, D.106429, 0B, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.110;
  struct BaseObjectType * D.106438;
  struct BaseObjectType * D.106439;
  const char * D.106440;
  struct BaseObjectType * D.106441;
  const struct GTlsDatabase * D.106442;
  struct SlotAsyncReady * slot_copy;

  slot_copy.110 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.110, slot);
    }
  catch
    {
      operator delete (slot_copy.110);
    }
  slot_copy = slot_copy.110;
  D.106438 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106439 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106440 = Glib::ustring::c_str (purpose);
  D.106441 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106442 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106442, D.106441, D.106440, 0B, D.106439, flags, D.106438, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.111;
  struct BaseObjectType * D.106449;
  const char * D.106450;
  struct BaseObjectType * D.106451;
  const struct GTlsDatabase * D.106452;
  struct SlotAsyncReady * slot_copy;

  slot_copy.111 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.111, slot);
    }
  catch
    {
      operator delete (slot_copy.111);
    }
  slot_copy = slot_copy.111;
  D.106449 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106450 = Glib::ustring::c_str (purpose);
  D.106451 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106452 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106452, D.106451, D.106450, 0B, D.106449, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.112;
  struct BaseObjectType * D.106458;
  const char * D.106459;
  struct BaseObjectType * D.106460;
  const struct GTlsDatabase * D.106461;
  struct SlotAsyncReady * slot_copy;

  slot_copy.112 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.112, slot);
    }
  catch
    {
      operator delete (slot_copy.112);
    }
  slot_copy = slot_copy.112;
  D.106458 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106459 = Glib::ustring::c_str (purpose);
  D.106460 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106461 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106461, D.106460, D.106459, 0B, 0B, flags, D.106458, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::verify_chain_async(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const SlotAsyncReady&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct SlotAsyncReady & slot, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.113;
  const char * D.106467;
  struct BaseObjectType * D.106468;
  const struct GTlsDatabase * D.106469;
  struct SlotAsyncReady * slot_copy;

  slot_copy.113 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.113, slot);
    }
  catch
    {
      operator delete (slot_copy.113);
    }
  slot_copy = slot_copy.113;
  D.106467 = Glib::ustring::c_str (purpose);
  D.106468 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.106469 = Gio::TlsDatabase::gobj (this);
  g_tls_database_verify_chain_async (D.106469, D.106468, D.106467, 0B, 0B, flags, 0B, SignalProxy_async_callback, slot_copy);
}


Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.106474;
  struct GTlsDatabase * D.106475;
  struct GError * gerror.114;
  TlsCertificateFlags D.106479;
  struct GError * gerror;
  TlsCertificateFlags retvalue;

  try
    {
      gerror = 0B;
      D.106474 = Glib::unwrap<Gio::AsyncResult> (result);
      D.106475 = Gio::TlsDatabase::gobj (this);
      retvalue = g_tls_database_verify_chain_finish (D.106475, D.106474, &gerror);
      gerror.114 = gerror;
      if (gerror.114 != 0B) goto <D.106477>; else goto <D.106478>;
      <D.106477>:
      gerror.114 = gerror;
      Glib::Error::throw_exception (gerror.114);
      <D.106478>:
      D.106479 = retvalue;
      return D.106479;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::AsyncResult; typename T::BaseObjectType = _GAsyncResult] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.106485;
  struct BaseObjectType * iftmp.115;
  bool D.106487;
  struct AsyncResult * D.106490;

  D.106487 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.106487 != 0) goto <D.106488>; else goto <D.106489>;
  <D.106488>:
  D.106490 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.115 = Gio::AsyncResult::gobj (D.106490);
  goto <D.106491>;
  <D.106489>:
  iftmp.115 = 0B;
  <D.106491>:
  D.106485 = iftmp.115;
  return D.106485;
}


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

  D.106494 = this->pCppObject_;
  D.106493 = D.106494 != 0B;
  return D.106493;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.106498;
  int (*__vtbl_ptr_type) () * D.106499;
  int (*__vtbl_ptr_type) () * D.106500;
  long int D.106501;
  sizetype D.106502;
  struct ObjectBase * D.106503;

  D.106499 = this->D.86030._vptr.Interface;
  D.106500 = D.106499 + 18446744073709551592;
  D.106501 = MEM[(long int *)D.106500];
  D.106502 = (sizetype) D.106501;
  D.106503 = this + D.106502;
  D.106498 = D.106503->gobject_;
  return D.106498;
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106506;
  struct BaseObjectType * D.106507;
  const struct BaseObjectType * D.106508;
  struct GTlsDatabase * D.106509;
  struct GTlsCertificate * D.106510;
  struct GError * gerror.116;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106506 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106507 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106508 = Glib::unwrap<Gio::TlsCertificate> (certificate);
      D.106509 = Gio::TlsDatabase::gobj (this);
      D.106510 = g_tls_database_lookup_certificate_issuer (D.106509, D.106508, D.106507, flags, D.106506, &gerror);
      *<retval> = Glib::wrap (D.106510, 0); [return slot optimization]
      try
        {
          gerror.116 = gerror;
          if (gerror.116 != 0B) goto <D.106512>; else goto <D.106513>;
          <D.106512>:
          gerror.116 = gerror;
          Glib::Error::throw_exception (gerror.116);
          <D.106513>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


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.106522;
  const struct BaseObjectType * iftmp.117;
  bool D.106524;
  const struct TlsCertificate * D.106527;

  D.106524 = Glib::RefPtr<const Gio::TlsCertificate>::operator bool (ptr);
  if (D.106524 != 0) goto <D.106525>; else goto <D.106526>;
  <D.106525>:
  D.106527 = Glib::RefPtr<const Gio::TlsCertificate>::operator-> (ptr);
  iftmp.117 = Gio::TlsCertificate::gobj (D.106527);
  goto <D.106528>;
  <D.106526>:
  iftmp.117 = 0B;
  <D.106528>:
  D.106522 = iftmp.117;
  return D.106522;
}


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

  D.106531 = this->pCppObject_;
  D.106530 = D.106531 != 0B;
  return D.106530;
}


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

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


const GTlsCertificate* Gio::TlsCertificate::gobj() const (const struct TlsCertificate * const this)
{
  const struct GTlsCertificate * D.106535;
  int (*__vtbl_ptr_type) () * D.106536;
  int (*__vtbl_ptr_type) () * D.106537;
  long int D.106538;
  sizetype D.106539;
  const struct ObjectBase * D.106540;

  D.106536 = this->D.97883._vptr.Object;
  D.106537 = D.106536 + 18446744073709551592;
  D.106538 = MEM[(long int *)D.106537];
  D.106539 = (sizetype) D.106538;
  D.106540 = this + D.106539;
  D.106535 = D.106540->gobject_;
  return D.106535;
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106543;
  const struct BaseObjectType * D.106544;
  struct GTlsDatabase * D.106545;
  struct GTlsCertificate * D.106546;
  struct GError * gerror.118;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106543 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106544 = Glib::unwrap<Gio::TlsCertificate> (certificate);
      D.106545 = Gio::TlsDatabase::gobj (this);
      D.106546 = g_tls_database_lookup_certificate_issuer (D.106545, D.106544, D.106543, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.106546, 0); [return slot optimization]
      try
        {
          gerror.118 = gerror;
          if (gerror.118 != 0B) goto <D.106548>; else goto <D.106549>;
          <D.106548>:
          gerror.118 = gerror;
          Glib::Error::throw_exception (gerror.118);
          <D.106549>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106558;
  const struct BaseObjectType * D.106559;
  struct GTlsDatabase * D.106560;
  struct GTlsCertificate * D.106561;
  struct GError * gerror.119;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106558 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106559 = Glib::unwrap<Gio::TlsCertificate> (certificate);
      D.106560 = Gio::TlsDatabase::gobj (this);
      D.106561 = g_tls_database_lookup_certificate_issuer (D.106560, D.106559, 0B, flags, D.106558, &gerror);
      *<retval> = Glib::wrap (D.106561, 0); [return slot optimization]
      try
        {
          gerror.119 = gerror;
          if (gerror.119 != 0B) goto <D.106563>; else goto <D.106564>;
          <D.106563>:
          gerror.119 = gerror;
          Glib::Error::throw_exception (gerror.119);
          <D.106564>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, TlsDatabaseLookupFlags flags)
{
  const struct BaseObjectType * D.106573;
  struct GTlsDatabase * D.106574;
  struct GTlsCertificate * D.106575;
  struct GError * gerror.120;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106573 = Glib::unwrap<Gio::TlsCertificate> (certificate);
      D.106574 = Gio::TlsDatabase::gobj (this);
      D.106575 = g_tls_database_lookup_certificate_issuer (D.106574, D.106573, 0B, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.106575, 0); [return slot optimization]
      try
        {
          gerror.120 = gerror;
          if (gerror.120 != 0B) goto <D.106577>; else goto <D.106578>;
          <D.106577>:
          gerror.120 = gerror;
          Glib::Error::throw_exception (gerror.120);
          <D.106578>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.101524;

  D.101524 = Gio::TlsDatabase::lookup_certificate_issuer (this, certificate, interaction, cancellable, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.101524);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.101524);
      D.101524 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.101550;

  D.101550 = Gio::TlsDatabase::lookup_certificate_issuer (this, certificate, interaction, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.101550);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.101550);
      D.101550 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.101567;

  D.101567 = Gio::TlsDatabase::lookup_certificate_issuer (this, certificate, cancellable, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.101567);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.101567);
      D.101567 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer(const Glib::RefPtr<const Gio::TlsCertificate>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & certificate, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.101574;

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


void Gio::TlsDatabase::lookup_certificate_issuer_async(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.121;
  struct BaseObjectType * D.106601;
  struct BaseObjectType * D.106602;
  const struct BaseObjectType * D.106603;
  struct GTlsDatabase * D.106604;
  struct SlotAsyncReady * slot_copy;

  slot_copy.121 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.121, slot);
    }
  catch
    {
      operator delete (slot_copy.121);
    }
  slot_copy = slot_copy.121;
  D.106601 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106602 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106603 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.106604 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_issuer_async (D.106604, D.106603, D.106602, flags, D.106601, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_issuer_async(const Glib::RefPtr<const Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.122;
  struct BaseObjectType * D.106610;
  const struct BaseObjectType * D.106611;
  struct GTlsDatabase * D.106612;
  struct SlotAsyncReady * slot_copy;

  slot_copy.122 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.122, slot);
    }
  catch
    {
      operator delete (slot_copy.122);
    }
  slot_copy = slot_copy.122;
  D.106610 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.106611 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.106612 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_issuer_async (D.106612, D.106611, D.106610, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_issuer_async(const Glib::RefPtr<const Gio::TlsCertificate>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.123;
  struct BaseObjectType * D.106617;
  const struct BaseObjectType * D.106618;
  struct GTlsDatabase * D.106619;
  struct SlotAsyncReady * slot_copy;

  slot_copy.123 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.123, slot);
    }
  catch
    {
      operator delete (slot_copy.123);
    }
  slot_copy = slot_copy.123;
  D.106617 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.106618 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.106619 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_issuer_async (D.106619, D.106618, 0B, flags, D.106617, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_issuer_async(const Glib::RefPtr<const Gio::TlsCertificate>&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.124;
  const struct BaseObjectType * D.106624;
  struct GTlsDatabase * D.106625;
  struct SlotAsyncReady * slot_copy;

  slot_copy.124 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.124, slot);
    }
  catch
    {
      operator delete (slot_copy.124);
    }
  slot_copy = slot_copy.124;
  D.106624 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.106625 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_issuer_async (D.106625, D.106624, 0B, flags, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.106630;
  struct GTlsDatabase * D.106631;
  struct GTlsCertificate * D.106632;
  struct GError * gerror.125;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106630 = Glib::unwrap<Gio::AsyncResult> (result);
      D.106631 = Gio::TlsDatabase::gobj (this);
      D.106632 = g_tls_database_lookup_certificate_issuer_finish (D.106631, D.106630, &gerror);
      *<retval> = Glib::wrap (D.106632, 0); [return slot optimization]
      try
        {
          gerror.125 = gerror;
          if (gerror.125 != 0B) goto <D.106634>; else goto <D.106635>;
          <D.106634>:
          gerror.125 = gerror;
          Glib::Error::throw_exception (gerror.125);
          <D.106635>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106643;
  struct BaseObjectType * D.106644;
  struct BaseObjectType * D.106645;
  struct GTlsDatabase * D.106646;
  struct GList * D.106647;
  struct GError * gerror.126;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106643 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106644 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106645 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.106646 = Gio::TlsDatabase::gobj (this);
      D.106647 = g_tls_database_lookup_certificates_issued_by (D.106646, D.106645, D.106644, flags, D.106643, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.106647, 2); [return slot optimization]
      try
        {
          gerror.126 = gerror;
          if (gerror.126 != 0B) goto <D.106649>; else goto <D.106650>;
          <D.106649>:
          gerror.126 = gerror;
          Glib::Error::throw_exception (gerror.126);
          <D.106650>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Glib::ByteArray; typename T::BaseObjectType = _GByteArray] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.106659;
  struct BaseObjectType * iftmp.127;
  bool D.106661;
  struct ByteArray * D.106664;

  D.106661 = Glib::RefPtr<Glib::ByteArray>::operator bool (ptr);
  if (D.106661 != 0) goto <D.106662>; else goto <D.106663>;
  <D.106662>:
  D.106664 = Glib::RefPtr<Glib::ByteArray>::operator-> (ptr);
  iftmp.127 = Glib::ByteArray::gobj (D.106664);
  goto <D.106665>;
  <D.106663>:
  iftmp.127 = 0B;
  <D.106665>:
  D.106659 = iftmp.127;
  return D.106659;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Glib::ByteArray] (const struct RefPtr * const this)
{
  bool D.106668;
  struct ByteArray * D.106669;

  D.106669 = this->pCppObject_;
  D.106668 = D.106669 != 0B;
  return D.106668;
}


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

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


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.103459;
  struct ListIteratorType D.103442;
  struct ListIteratorType D.103441;
  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.103459);
          try
            {
              Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::ListIterator (&D.103442, 0B);
              try
                {
                  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::ListIterator (&D.103441, glist);
                  try
                    {
                      std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (<retval>, D.103441, D.103442, &D.103459);
                      return <retval>;
                    }
                  finally
                    {
                      D.103441 = {CLOBBER};
                    }
                }
              finally
                {
                  D.103442 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<Glib::RefPtr<Gio::TlsCertificate> >::~allocator (&D.103459);
              D.103459 = {CLOBBER};
            }
        }
      finally
        {
          Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::~GListKeeper (&keeper);
        }
    }
  finally
    {
      keeper = {CLOBBER};
    }
}


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

  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.106685 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.106685);
          
        }
    }
}


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

  try
    {
      {

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


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.106687;
  struct _Integral D.104032;
  struct __false_type D.106688;

  D.106687 = &this->D.101040;
  std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_base (D.106687, __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.106688);
          }
        finally
          {
            D.104032 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.106687 = &this->D.101040;
      std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::~_Vector_base (D.106687);
    }
}


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.106691;

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

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


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.106692;

  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.106692 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.106692);
          
        }
    }
}


__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.100380)
{
  void * D.106693;

  try
    {
      {

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


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.103986)
{
  struct _IterCategory D.104339;
  struct forward_iterator_tag D.106694;
  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.106694);
    }
  finally
    {
      D.104339 = {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.104344)
{
  long int D.106696;
  struct _Vector_base * D.106697;
  struct RefPtr * D.106698;
  struct RefPtr * D.106699;
  long unsigned int D.106700;
  struct RefPtr * D.106701;
  struct _Tp_alloc_type & D.106702;
  struct RefPtr * D.106703;
  const size_type __n;

  D.106696 = std::distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (__first, __last);
  __n = (const size_type) D.106696;
  D.106697 = &this->D.101040;
  D.106698 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_allocate (D.106697, __n);
  this->D.101040._M_impl._M_start = D.106698;
  D.106699 = this->D.101040._M_impl._M_start;
  D.106700 = __n * 8;
  D.106701 = D.106699 + D.106700;
  this->D.101040._M_impl._M_end_of_storage = D.106701;
  D.106697 = &this->D.101040;
  D.106702 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.106697);
  D.106699 = this->D.101040._M_impl._M_start;
  D.106703 = 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.106699, D.106702);
  this->D.101040._M_impl._M_finish = D.106703;
}


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.106707;
  struct input_iterator_tag D.104760;
  struct iterator_category D.104723;
  struct iterator_category * D.106708;
  struct input_iterator_tag D.106709;

  std::__iterator_category<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (&__first);
  try
    {
      D.106708 = &D.104723;
      D.106707 = std::__distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > > > (__first, __last, D.106709);
      return D.106707;
    }
  finally
    {
      D.104723 = {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.104722)
{
  struct iterator_category D.106714;

  return D.106714;
}


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.104742)
{
  bool retval.128;
  difference_type D.106717;
  difference_type __n;

  __n = 0;
  goto <D.104812>;
  <D.104813>:
  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator++ (&__first);
  __n = __n + 1;
  <D.104812>:
  retval.128 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator!= (&__first, &__last);
  if (retval.128 != 0) goto <D.104813>; else goto <D.104811>;
  <D.104811>:
  D.106717 = __n;
  return D.106717;
}


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.106719;
  struct GList * D.106720;
  struct ListIterator & D.106721;

  D.106719 = this->node_;
  D.106720 = D.106719->next;
  this->node_ = D.106720;
  D.106721 = this;
  return D.106721;
}


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.106723;
  const struct GList * D.106724;
  const struct GList * D.106725;

  D.106724 = this->node_;
  D.106725 = rhs->node_;
  D.106723 = D.106724 != D.106725;
  return D.106723;
}


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.106727;
  struct RefPtr * iftmp.129;
  struct _Vector_impl * D.106731;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.106729>; else goto <D.106730>;
  <D.106729>:
  D.106731 = &this->_M_impl;
  iftmp.129 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::allocate (D.106731, __n);
  goto <D.106732>;
  <D.106730>:
  iftmp.129 = 0B;
  <D.106732>:
  D.106727 = iftmp.129;
  return D.106727;
}


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.106735;

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


_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.100353)
{
  bool retval.130;
  long unsigned int D.106739;
  struct RefPtr * D.106742;
  long unsigned int D.106743;

  D.106739 = __gnu_cxx::new_allocator<Glib::RefPtr<Gio::TlsCertificate> >::max_size (this);
  retval.130 = D.106739 < __n;
  if (retval.130 != 0) goto <D.106740>; else goto <D.106741>;
  <D.106740>:
  std::__throw_bad_alloc ();
  <D.106741>:
  D.106743 = __n * 8;
  D.106742 = operator new (D.106743);
  return D.106742;
}


__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.106746;
  void * D.106747;

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


_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.104591)
{
  struct RefPtr * D.106749;

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


_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.106752;
  typedef struct _ValueType1 _ValueType1;
  typedef struct _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.106752 = 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.106752;
}


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.104848;
  struct RefPtr * D.106755;
  bool retval.131;
  struct RefPtr * D.106757;
  void * D.106758;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.104852>;
      <D.104851>:
      D.104848 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.106755 = std::__addressof<Glib::RefPtr<Gio::TlsCertificate> > (__cur);
          std::_Construct<Glib::RefPtr<Gio::TlsCertificate>, Glib::RefPtr<Gio::TlsCertificate> > (D.106755, &D.104848);
        }
      finally
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.104848);
          D.104848 = {CLOBBER};
        }
      Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.104852>:
      retval.131 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> > >::operator!= (&__first, &__last);
      if (retval.131 != 0) goto <D.104851>; else goto <D.104849>;
      <D.104849>:
      D.106757 = __cur;
      return D.106757;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.106758 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.106758);
              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.106765;
  void * D.106766;

  D.106765 = this->node_;
  D.106766 = D.106765->data;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::TlsCertificate> >::to_cpp_type (D.106766); [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.132;
  struct ObjectBase * D.106770;
  struct GObject * cobj;

  cobj = ptr;
  D.106770 = Glib::wrap_auto (cobj, 1);
  if (D.106770 == 0B) goto <D.106771>; else goto <D.106772>;
  <D.106771>:
  iftmp.132 = 0B;
  goto <D.106773>;
  <D.106772>:
  iftmp.132 = __dynamic_cast (D.106770, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14TlsCertificateE, -1);
  <D.106773>:
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, iftmp.132);
  return <retval>;
}


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


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.104774;
  void * D.104775;
  struct RefPtr * iftmp.133;

  D.104774 = __p;
  D.104775 = operator new (8, D.104774);
  if (D.104775 != 0B) goto <D.106777>; else goto <D.106778>;
  <D.106777>:
  try
    {
      Glib::RefPtr<Gio::TlsCertificate>::RefPtr (D.104775, __value);
    }
  catch
    {
      operator delete (D.104775, D.104774);
    }
  iftmp.133 = D.104775;
  goto <D.106779>;
  <D.106778>:
  iftmp.133 = D.104775;
  <D.106779>:
}


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

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


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.106784;
  struct TlsCertificate * D.106785;
  int (*__vtbl_ptr_type) () * D.106788;
  int (*__vtbl_ptr_type) () * D.106789;
  long int D.106790;
  sizetype D.106791;
  struct ObjectBase * D.106792;
  int (*__vtbl_ptr_type) () * D.106793;
  int (*__vtbl_ptr_type) () * D.106794;
  int (*__vtbl_ptr_type) () D.106795;

  D.106784 = src->pCppObject_;
  this->pCppObject_ = D.106784;
  D.106785 = this->pCppObject_;
  if (D.106785 != 0B) goto <D.106786>; else goto <D.106787>;
  <D.106786>:
  D.106785 = this->pCppObject_;
  D.106785 = this->pCppObject_;
  D.106788 = D.106785->D.97883._vptr.Object;
  D.106789 = D.106788 + 18446744073709551592;
  D.106790 = MEM[(long int *)D.106789];
  D.106791 = (sizetype) D.106790;
  D.106792 = D.106785 + D.106791;
  D.106785 = this->pCppObject_;
  D.106785 = this->pCppObject_;
  D.106788 = D.106785->D.97883._vptr.Object;
  D.106789 = D.106788 + 18446744073709551592;
  D.106790 = MEM[(long int *)D.106789];
  D.106791 = (sizetype) D.106790;
  D.106792 = D.106785 + D.106791;
  D.106793 = D.106792->_vptr.ObjectBase;
  D.106794 = D.106793 + 16;
  D.106795 = *D.106794;
  D.106785 = this->pCppObject_;
  D.106785 = this->pCppObject_;
  D.106788 = D.106785->D.97883._vptr.Object;
  D.106789 = D.106788 + 18446744073709551592;
  D.106790 = MEM[(long int *)D.106789];
  D.106791 = (sizetype) D.106790;
  D.106792 = D.106785 + D.106791;
  OBJ_TYPE_REF(D.106795;(const struct ObjectBase)D.106792->2) (D.106792);
  goto <D.106796>;
  <D.106787>:
  <D.106796>:
}


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

  try
    {

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


std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106799;
  struct BaseObjectType * D.106800;
  struct GTlsDatabase * D.106801;
  struct GList * D.106802;
  struct GError * gerror.134;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106799 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106800 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.106801 = Gio::TlsDatabase::gobj (this);
      D.106802 = g_tls_database_lookup_certificates_issued_by (D.106801, D.106800, D.106799, flags, 0B, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.106802, 2); [return slot optimization]
      try
        {
          gerror.134 = gerror;
          if (gerror.134 != 0B) goto <D.106804>; else goto <D.106805>;
          <D.106804>:
          gerror.134 = gerror;
          Glib::Error::throw_exception (gerror.134);
          <D.106805>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106814;
  struct BaseObjectType * D.106815;
  struct GTlsDatabase * D.106816;
  struct GList * D.106817;
  struct GError * gerror.135;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106814 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106815 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.106816 = Gio::TlsDatabase::gobj (this);
      D.106817 = g_tls_database_lookup_certificates_issued_by (D.106816, D.106815, 0B, flags, D.106814, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.106817, 2); [return slot optimization]
      try
        {
          gerror.135 = gerror;
          if (gerror.135 != 0B) goto <D.106819>; else goto <D.106820>;
          <D.106819>:
          gerror.135 = gerror;
          Glib::Error::throw_exception (gerror.135);
          <D.106820>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106829;
  struct GTlsDatabase * D.106830;
  struct GList * D.106831;
  struct GError * gerror.136;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106829 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.106830 = Gio::TlsDatabase::gobj (this);
      D.106831 = g_tls_database_lookup_certificates_issued_by (D.106830, D.106829, 0B, flags, 0B, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.106831, 2); [return slot optimization]
      try
        {
          gerror.136 = gerror;
          if (gerror.136 != 0B) goto <D.106833>; else goto <D.106834>;
          <D.106833>:
          gerror.136 = gerror;
          Glib::Error::throw_exception (gerror.136);
          <D.106834>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<const Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.106842;
  struct BaseObjectType * D.106843;
  struct BaseObjectType * D.106844;
  const struct GTlsDatabase * D.106845;
  struct GList * D.106846;
  struct GError * gerror.137;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.106842 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.106843 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.106844 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.106845 = Gio::TlsDatabase::gobj (this);
      D.106846 = g_tls_database_lookup_certificates_issued_by (D.106845, D.106844, D.106843, flags, D.106842, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<const Gio::TlsCertificate> >::list_to_vector (D.106846, 2); [return slot optimization]
      try
        {
          gerror.137 = gerror;
          if (gerror.137 != 0B) goto <D.106848>; else goto <D.106849>;
          <D.106848>:
          gerror.137 = gerror;
          Glib::Error::throw_exception (gerror.137);
          <D.106849>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<const 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<const Gio::TlsCertificate>; Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> >; Glib::ListHandler<T, Tr>::VectorType = std::vector<Glib::RefPtr<const Gio::TlsCertificate> >; GList = _GList] (struct GList * glist, OwnershipType ownership)
{
  struct allocator_type D.103614;
  struct ListIteratorType D.103597;
  struct ListIteratorType D.103596;
  struct GListKeeperType keeper;

  try
    {
      Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::GListKeeper (&keeper, glist, ownership);
      try
        {
          std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >::allocator (&D.103614);
          try
            {
              Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::ListIterator (&D.103597, 0B);
              try
                {
                  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::ListIterator (&D.103596, glist);
                  try
                    {
                      std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::vector<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (<retval>, D.103596, D.103597, &D.103614);
                      return <retval>;
                    }
                  finally
                    {
                      D.103596 = {CLOBBER};
                    }
                }
              finally
                {
                  D.103597 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >::~allocator (&D.103614);
              D.103614 = {CLOBBER};
            }
        }
      finally
        {
          Glib::Container_Helpers::GListKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const 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<const 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<const Gio::TlsCertificate>] (struct allocator * const this)
{
  void * D.106870;

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

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


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

  try
    {
      {

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


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

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

        try
          {
            std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::_M_initialize_dispatch<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (this, __first, __last, D.106873);
          }
        finally
          {
            D.104110 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.106872 = &this->D.102408;
      std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::~_Vector_base (D.106872);
    }
}


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

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

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


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl(const _Tp_alloc_type&) [with _Tp = Glib::RefPtr<const Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >] (struct _Vector_impl * const this, const struct _Tp_alloc_type & __a)
{
  std::allocator<Glib::RefPtr<const 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<const Gio::TlsCertificate> >::~allocator (this);
    }
}


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

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

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


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

  try
    {
      {

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


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

  try
    {
      std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::_M_range_initialize<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (this, __first, __last, D.106879);
    }
  finally
    {
      D.104439 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >; _Tp = Glib::RefPtr<const Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >] (struct vector * const this, struct ListIterator __first, struct ListIterator __last, struct forward_iterator_tag D.104444)
{
  long int D.106881;
  struct _Vector_base * D.106882;
  struct RefPtr * D.106883;
  struct RefPtr * D.106884;
  long unsigned int D.106885;
  struct RefPtr * D.106886;
  struct _Tp_alloc_type & D.106887;
  struct RefPtr * D.106888;
  const size_type __n;

  D.106881 = std::distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (__first, __last);
  __n = (const size_type) D.106881;
  D.106882 = &this->D.102408;
  D.106883 = std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::_M_allocate (D.106882, __n);
  this->D.102408._M_impl._M_start = D.106883;
  D.106884 = this->D.102408._M_impl._M_start;
  D.106885 = __n * 8;
  D.106886 = D.106884 + D.106885;
  this->D.102408._M_impl._M_end_of_storage = D.106886;
  D.106882 = &this->D.102408;
  D.106887 = std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.106882);
  D.106884 = this->D.102408._M_impl._M_start;
  D.106888 = std::__uninitialized_copy_a<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >, Glib::RefPtr<const Gio::TlsCertificate>*, Glib::RefPtr<const Gio::TlsCertificate> > (__first, __last, D.106884, D.106887);
  this->D.102408._M_impl._M_finish = D.106888;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ListIterator __first, struct ListIterator __last)
{
  difference_type D.106892;
  struct input_iterator_tag D.104786;
  struct iterator_category D.104779;
  struct iterator_category * D.106893;
  struct input_iterator_tag D.106894;

  std::__iterator_category<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (&__first);
  try
    {
      D.106893 = &D.104779;
      D.106892 = std::__distance<Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > > > (__first, __last, D.106894);
      return D.106892;
    }
  finally
    {
      D.104779 = {CLOBBER};
    }
}


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

  return D.106899;
}


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

  __n = 0;
  goto <D.104830>;
  <D.104831>:
  Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::operator++ (&__first);
  __n = __n + 1;
  <D.104830>:
  retval.138 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::operator!= (&__first, &__last);
  if (retval.138 != 0) goto <D.104831>; else goto <D.104829>;
  <D.104829>:
  D.106902 = __n;
  return D.106902;
}


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

  D.106904 = this->node_;
  D.106905 = D.106904->next;
  this->node_ = D.106905;
  D.106906 = this;
  return D.106906;
}


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

  D.106909 = this->node_;
  D.106910 = rhs->node_;
  D.106908 = D.106909 != D.106910;
  return D.106908;
}


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

  if (__n != 0) goto <D.106914>; else goto <D.106915>;
  <D.106914>:
  D.106916 = &this->_M_impl;
  iftmp.139 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::allocate (D.106916, __n);
  goto <D.106917>;
  <D.106915>:
  iftmp.139 = 0B;
  <D.106917>:
  D.106912 = iftmp.139;
  return D.106912;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::RefPtr<const Gio::TlsCertificate>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<const Gio::TlsCertificate>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.101721)
{
  bool retval.140;
  long unsigned int D.106924;
  struct RefPtr * D.106927;
  long unsigned int D.106928;

  D.106924 = __gnu_cxx::new_allocator<Glib::RefPtr<const Gio::TlsCertificate> >::max_size (this);
  retval.140 = D.106924 < __n;
  if (retval.140 != 0) goto <D.106925>; else goto <D.106926>;
  <D.106925>:
  std::__throw_bad_alloc ();
  <D.106926>:
  D.106928 = __n * 8;
  D.106927 = operator new (D.106928);
  return D.106927;
}


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

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


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

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


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

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


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

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


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >; _ForwardIterator = Glib::RefPtr<const Gio::TlsCertificate>*; bool _TrivialValueTypes = false] (struct ListIterator __first, struct ListIterator __last, struct RefPtr * __result)
{
  struct value_type D.104864;
  struct RefPtr * D.106942;
  bool retval.141;
  struct RefPtr * D.106944;
  void * D.106945;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.104868>;
      <D.104867>:
      D.104864 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.106942 = std::__addressof<Glib::RefPtr<const Gio::TlsCertificate> > (__cur);
          std::_Construct<Glib::RefPtr<const Gio::TlsCertificate>, Glib::RefPtr<const Gio::TlsCertificate> > (D.106942, &D.104864);
        }
      finally
        {
          Glib::RefPtr<const Gio::TlsCertificate>::~RefPtr (&D.104864);
          D.104864 = {CLOBBER};
        }
      Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.104868>:
      retval.141 = Glib::Container_Helpers::ListIterator<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> > >::operator!= (&__first, &__last);
      if (retval.141 != 0) goto <D.104867>; else goto <D.104865>;
      <D.104865>:
      D.106944 = __cur;
      return D.106944;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.106945 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.106945);
              std::_Destroy<Glib::RefPtr<const 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<const Gio::TlsCertificate> >; Glib::Container_Helpers::ListIterator<Tr>::value_type = Glib::RefPtr<const Gio::TlsCertificate>] (const struct ListIterator * const this)
{
  const struct GList * D.106952;
  void * D.106953;

  D.106952 = this->node_;
  D.106953 = D.106952->data;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> >::to_cpp_type (D.106953); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CppType Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::to_cpp_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType) [with T = Gio::TlsCertificate; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CppType = Glib::RefPtr<const Gio::TlsCertificate>; Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const T> >::CType = const _GTlsCertificate*; typename T::BaseObjectType = _GTlsCertificate] (const struct BaseObjectType * ptr)
{
  const struct TlsCertificate * iftmp.142;
  struct ObjectBase * D.106957;
  struct GObject * cobj;

  cobj = ptr;
  D.106957 = Glib::wrap_auto (cobj, 1);
  if (D.106957 == 0B) goto <D.106958>; else goto <D.106959>;
  <D.106958>:
  iftmp.142 = 0B;
  goto <D.106960>;
  <D.106959>:
  iftmp.142 = __dynamic_cast (D.106957, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14TlsCertificateE, -1);
  <D.106960>:
  Glib::RefPtr<const Gio::TlsCertificate>::RefPtr (<retval>, iftmp.142);
  return <retval>;
}


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


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

  D.106963 = __r;
  return D.106963;
}


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

  D.104805 = __p;
  D.104806 = operator new (8, D.104805);
  if (D.104806 != 0B) goto <D.106966>; else goto <D.106967>;
  <D.106966>:
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr (D.104806, __value);
    }
  catch
    {
      operator delete (D.104806, D.104805);
    }
  iftmp.143 = D.104806;
  goto <D.106968>;
  <D.106967>:
  iftmp.143 = D.104806;
  <D.106968>:
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = const Gio::TlsCertificate] (struct RefPtr * const this, const struct RefPtr & src)
{
  const struct TlsCertificate * D.106970;
  const struct TlsCertificate * D.106971;
  int (*__vtbl_ptr_type) () * D.106974;
  int (*__vtbl_ptr_type) () * D.106975;
  long int D.106976;
  sizetype D.106977;
  const struct ObjectBase * D.106978;
  int (*__vtbl_ptr_type) () * D.106979;
  int (*__vtbl_ptr_type) () * D.106980;
  int (*__vtbl_ptr_type) () D.106981;

  D.106970 = src->pCppObject_;
  this->pCppObject_ = D.106970;
  D.106971 = this->pCppObject_;
  if (D.106971 != 0B) goto <D.106972>; else goto <D.106973>;
  <D.106972>:
  D.106971 = this->pCppObject_;
  D.106971 = this->pCppObject_;
  D.106974 = D.106971->D.97883._vptr.Object;
  D.106975 = D.106974 + 18446744073709551592;
  D.106976 = MEM[(long int *)D.106975];
  D.106977 = (sizetype) D.106976;
  D.106978 = D.106971 + D.106977;
  D.106971 = this->pCppObject_;
  D.106971 = this->pCppObject_;
  D.106974 = D.106971->D.97883._vptr.Object;
  D.106975 = D.106974 + 18446744073709551592;
  D.106976 = MEM[(long int *)D.106975];
  D.106977 = (sizetype) D.106976;
  D.106978 = D.106971 + D.106977;
  D.106979 = D.106978->_vptr.ObjectBase;
  D.106980 = D.106979 + 16;
  D.106981 = *D.106980;
  D.106971 = this->pCppObject_;
  D.106971 = this->pCppObject_;
  D.106974 = D.106971->D.97883._vptr.Object;
  D.106975 = D.106974 + 18446744073709551592;
  D.106976 = MEM[(long int *)D.106975];
  D.106977 = (sizetype) D.106976;
  D.106978 = D.106971 + D.106977;
  OBJ_TYPE_REF(D.106981;(const struct ObjectBase)D.106978->2) (D.106978);
  goto <D.106982>;
  <D.106973>:
  <D.106982>:
}


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

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


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

  goto <D.104662>;
  <D.104661>:
  D.106983 = std::__addressof<Glib::RefPtr<const Gio::TlsCertificate> > (__first);
  std::_Destroy<Glib::RefPtr<const Gio::TlsCertificate> > (D.106983);
  __first = __first + 8;
  <D.104662>:
  if (__first != __last) goto <D.104661>; else goto <D.104659>;
  <D.104659>:
}


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


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::RefPtr<const Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >] (struct _Vector_base * const this)
{
  struct RefPtr * D.106984;
  long int D.106985;
  struct RefPtr * D.106986;
  long int D.106987;
  long int D.106988;
  long int D.106989;
  long unsigned int D.106990;
  struct _Vector_impl * D.106991;

  {
    try
      {
        try
          {
            D.106984 = this->_M_impl._M_end_of_storage;
            D.106985 = (long int) D.106984;
            D.106986 = this->_M_impl._M_start;
            D.106987 = (long int) D.106986;
            D.106988 = D.106985 - D.106987;
            D.106989 = D.106988 /[ex] 8;
            D.106990 = (long unsigned int) D.106989;
            D.106986 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::_M_deallocate (this, D.106986, D.106990);
          }
        finally
          {
            D.106991 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::_Vector_impl::~_Vector_impl (D.106991);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104123>:
}


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

  if (__p != 0B) goto <D.106994>; else goto <D.106995>;
  <D.106994>:
  D.106996 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::deallocate (D.106996, __p, __n);
  goto <D.106997>;
  <D.106995>:
  <D.106997>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<const 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<const 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<const Gio::TlsCertificate>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<const Gio::TlsCertificate>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct RefPtr * __p, size_type D.101725)
{
  operator delete (__p);
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        {
          typedef struct BaseObjectType * CTypeNonConst;

          {
            D.107000 = this->glist_;
            if (D.107000 != 0B) goto <D.107001>; else goto <D.107002>;
            <D.107001>:
            D.107003 = this->ownership_;
            if (D.107003 != 0) goto <D.107004>; else goto <D.107005>;
            <D.107004>:
            {
              {
                D.107003 = this->ownership_;
                if (D.107003 != 1) goto <D.107006>; else goto <D.107007>;
                <D.107006>:
                {
                  {
                    struct GList * node;

                    node = this->glist_;
                    goto <D.104062>;
                    <D.104063>:
                    D.107008 = node->data;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<const Gio::TlsCertificate> >::release_c_type (D.107008);
                    node = node->next;
                    <D.104062>:
                    if (node != 0B) goto <D.104063>; else goto <D.104064>;
                    <D.104064>:
                  }
                }
                goto <D.107009>;
                <D.107007>:
                <D.107009>:
              }
              D.107000 = this->glist_;
              g_list_free (D.107000);
            }
            goto <D.107010>;
            <D.107005>:
            <D.107010>:
            <D.107002>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104065>:
}


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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::RefPtr<const Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<const Gio::TlsCertificate> >] (struct vector * const this)
{
  struct _Vector_base * D.107012;
  struct _Tp_alloc_type & D.107013;
  struct RefPtr * D.107014;
  struct RefPtr * D.107015;

  {
    try
      {
        try
          {
            D.107012 = &this->D.102408;
            D.107013 = std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.107012);
            D.107014 = this->D.102408._M_impl._M_finish;
            D.107015 = this->D.102408._M_impl._M_start;
            std::_Destroy<Glib::RefPtr<const Gio::TlsCertificate>*, Glib::RefPtr<const Gio::TlsCertificate> > (D.107015, D.107014, D.107013);
          }
        finally
          {
            D.107012 = &this->D.102408;
            std::_Vector_base<Glib::RefPtr<const Gio::TlsCertificate>, std::allocator<Glib::RefPtr<const Gio::TlsCertificate> > >::~_Vector_base (D.107012);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103628>:
}


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


std::vector<Glib::RefPtr<const Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107019;
  struct BaseObjectType * D.107020;
  const struct GTlsDatabase * D.107021;
  struct GList * D.107022;
  struct GError * gerror.144;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107019 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.107020 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.107021 = Gio::TlsDatabase::gobj (this);
      D.107022 = g_tls_database_lookup_certificates_issued_by (D.107021, D.107020, D.107019, flags, 0B, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<const Gio::TlsCertificate> >::list_to_vector (D.107022, 2); [return slot optimization]
      try
        {
          gerror.144 = gerror;
          if (gerror.144 != 0B) goto <D.107024>; else goto <D.107025>;
          <D.107024>:
          gerror.144 = gerror;
          Glib::Error::throw_exception (gerror.144);
          <D.107025>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<const Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107034;
  struct BaseObjectType * D.107035;
  const struct GTlsDatabase * D.107036;
  struct GList * D.107037;
  struct GError * gerror.145;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107034 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107035 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.107036 = Gio::TlsDatabase::gobj (this);
      D.107037 = g_tls_database_lookup_certificates_issued_by (D.107036, D.107035, 0B, flags, D.107034, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<const Gio::TlsCertificate> >::list_to_vector (D.107037, 2); [return slot optimization]
      try
        {
          gerror.145 = gerror;
          if (gerror.145 != 0B) goto <D.107039>; else goto <D.107040>;
          <D.107039>:
          gerror.145 = gerror;
          Glib::Error::throw_exception (gerror.145);
          <D.107040>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::vector<Glib::RefPtr<const Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by(const Glib::RefPtr<Glib::ByteArray>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107049;
  const struct GTlsDatabase * D.107050;
  struct GList * D.107051;
  struct GError * gerror.146;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107049 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
      D.107050 = Gio::TlsDatabase::gobj (this);
      D.107051 = g_tls_database_lookup_certificates_issued_by (D.107050, D.107049, 0B, flags, 0B, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<const Gio::TlsCertificate> >::list_to_vector (D.107051, 2); [return slot optimization]
      try
        {
          gerror.146 = gerror;
          if (gerror.146 != 0B) goto <D.107053>; else goto <D.107054>;
          <D.107053>:
          gerror.146 = gerror;
          Glib::Error::throw_exception (gerror.146);
          <D.107054>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<const Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::TlsDatabase::lookup_certificates_issued_by_async(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.147;
  struct BaseObjectType * D.107061;
  struct BaseObjectType * D.107062;
  struct BaseObjectType * D.107063;
  struct GTlsDatabase * D.107064;
  struct SlotAsyncReady * slot_copy;

  slot_copy.147 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.147, slot);
    }
  catch
    {
      operator delete (slot_copy.147);
    }
  slot_copy = slot_copy.147;
  D.107061 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107062 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107063 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
  D.107064 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificates_issued_by_async (D.107064, D.107063, D.107062, flags, D.107061, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificates_issued_by_async(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.148;
  struct BaseObjectType * D.107070;
  struct BaseObjectType * D.107071;
  struct GTlsDatabase * D.107072;
  struct SlotAsyncReady * slot_copy;

  slot_copy.148 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.148, slot);
    }
  catch
    {
      operator delete (slot_copy.148);
    }
  slot_copy = slot_copy.148;
  D.107070 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107071 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
  D.107072 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificates_issued_by_async (D.107072, D.107071, D.107070, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificates_issued_by_async(const Glib::RefPtr<Glib::ByteArray>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.149;
  struct BaseObjectType * D.107077;
  struct BaseObjectType * D.107078;
  struct GTlsDatabase * D.107079;
  struct SlotAsyncReady * slot_copy;

  slot_copy.149 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.149, slot);
    }
  catch
    {
      operator delete (slot_copy.149);
    }
  slot_copy = slot_copy.149;
  D.107077 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107078 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
  D.107079 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificates_issued_by_async (D.107079, D.107078, 0B, flags, D.107077, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificates_issued_by_async(const Glib::RefPtr<Glib::ByteArray>&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.150;
  struct BaseObjectType * D.107084;
  struct GTlsDatabase * D.107085;
  struct SlotAsyncReady * slot_copy;

  slot_copy.150 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.150, slot);
    }
  catch
    {
      operator delete (slot_copy.150);
    }
  slot_copy = slot_copy.150;
  D.107084 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
  D.107085 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificates_issued_by_async (D.107085, D.107084, 0B, flags, 0B, SignalProxy_async_callback, slot_copy);
}


std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.107090;
  struct GTlsDatabase * D.107091;
  struct GList * D.107092;
  struct GError * gerror.151;
  struct GError * gerror;
  struct vector retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107090 = Glib::unwrap<Gio::AsyncResult> (result);
      D.107091 = Gio::TlsDatabase::gobj (this);
      D.107092 = g_tls_database_lookup_certificates_issued_by_finish (D.107091, D.107090, &gerror);
      *<retval> = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.107092, 2); [return slot optimization]
      try
        {
          gerror.151 = gerror;
          if (gerror.151 != 0B) goto <D.107094>; else goto <D.107095>;
          <D.107094>:
          gerror.151 = gerror;
          Glib::Error::throw_exception (gerror.151);
          <D.107095>:
          return <retval>;
        }
      catch
        {
          std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Gio::TlsDatabase::create_certificate_handle(const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsDatabase * const this, const struct RefPtr & certificate)
{
  const struct BaseObjectType * D.107103;
  const struct GTlsDatabase * D.107104;
  gchar * D.107105;

  D.107103 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.107104 = Gio::TlsDatabase::gobj (this);
  D.107105 = g_tls_database_create_certificate_handle (D.107104, D.107103);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.107105); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.152;
  char * D.107115;
  struct ustring * D.107116;

  cleanup.152 = 0;
  try
    {
      if (str != 0B) goto <D.107110>; else goto <D.107111>;
      <D.107110>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.152 = 1;
      D.107115 = Glib::ScopedPtr<char>::get (&D.78974);
      D.107116 = <retval>;
      Glib::ustring::ustring (D.107116, D.107115);
      goto <D.107117>;
      <D.107111>:
      D.107116 = <retval>;
      Glib::ustring::ustring (D.107116);
      <D.107117>:
      return <retval>;
    }
  finally
    {
      if (cleanup.152 != 0) goto <D.107113>; else goto <D.107114>;
      <D.107113>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.107114>:
    }
}


Glib::ScopedPtr<T>::ScopedPtr(T*) [with T = char] (struct ScopedPtr * const this, char * ptr)
{
  this->ptr_ = ptr;
}


T* Glib::ScopedPtr<T>::get() const [with T = char] (const struct ScopedPtr * const this)
{
  char * D.107123;

  D.107123 = this->ptr_;
  return D.107123;
}


Glib::ScopedPtr<T>::~ScopedPtr() [with T = char] (struct ScopedPtr * const this)
{
  char * D.107125;

  {
    try
      {
        D.107125 = this->ptr_;
        g_free (D.107125);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103118>:
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107128;
  struct BaseObjectType * D.107129;
  const char * D.107130;
  struct GTlsDatabase * D.107131;
  struct GTlsCertificate * D.107132;
  struct GError * gerror.153;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107128 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107129 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.107130 = Glib::ustring::c_str (handle);
      D.107131 = Gio::TlsDatabase::gobj (this);
      D.107132 = g_tls_database_lookup_certificate_for_handle (D.107131, D.107130, D.107129, flags, D.107128, &gerror);
      *<retval> = Glib::wrap (D.107132, 0); [return slot optimization]
      try
        {
          gerror.153 = gerror;
          if (gerror.153 != 0B) goto <D.107134>; else goto <D.107135>;
          <D.107134>:
          gerror.153 = gerror;
          Glib::Error::throw_exception (gerror.153);
          <D.107135>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107145;
  const char * D.107146;
  struct GTlsDatabase * D.107147;
  struct GTlsCertificate * D.107148;
  struct GError * gerror.154;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107145 = Glib::unwrap<Gio::TlsInteraction> (interaction);
      D.107146 = Glib::ustring::c_str (handle);
      D.107147 = Gio::TlsDatabase::gobj (this);
      D.107148 = g_tls_database_lookup_certificate_for_handle (D.107147, D.107146, D.107145, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.107148, 0); [return slot optimization]
      try
        {
          gerror.154 = gerror;
          if (gerror.154 != 0B) goto <D.107150>; else goto <D.107151>;
          <D.107150>:
          gerror.154 = gerror;
          Glib::Error::throw_exception (gerror.154);
          <D.107151>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct BaseObjectType * D.107160;
  const char * D.107161;
  struct GTlsDatabase * D.107162;
  struct GTlsCertificate * D.107163;
  struct GError * gerror.155;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107160 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.107161 = Glib::ustring::c_str (handle);
      D.107162 = Gio::TlsDatabase::gobj (this);
      D.107163 = g_tls_database_lookup_certificate_for_handle (D.107162, D.107161, 0B, flags, D.107160, &gerror);
      *<retval> = Glib::wrap (D.107163, 0); [return slot optimization]
      try
        {
          gerror.155 = gerror;
          if (gerror.155 != 0B) goto <D.107165>; else goto <D.107166>;
          <D.107165>:
          gerror.155 = gerror;
          Glib::Error::throw_exception (gerror.155);
          <D.107166>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, TlsDatabaseLookupFlags flags)
{
  const char * D.107175;
  struct GTlsDatabase * D.107176;
  struct GTlsCertificate * D.107177;
  struct GError * gerror.156;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107175 = Glib::ustring::c_str (handle);
      D.107176 = Gio::TlsDatabase::gobj (this);
      D.107177 = g_tls_database_lookup_certificate_for_handle (D.107176, D.107175, 0B, flags, 0B, &gerror);
      *<retval> = Glib::wrap (D.107177, 0); [return slot optimization]
      try
        {
          gerror.156 = gerror;
          if (gerror.156 != 0B) goto <D.107179>; else goto <D.107180>;
          <D.107179>:
          gerror.156 = gerror;
          Glib::Error::throw_exception (gerror.156);
          <D.107180>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.102569;

  D.102569 = Gio::TlsDatabase::lookup_certificate_for_handle (this, handle, interaction, cancellable, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.102569);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.102569);
      D.102569 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.102577;

  D.102577 = Gio::TlsDatabase::lookup_certificate_for_handle (this, handle, interaction, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.102577);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.102577);
      D.102577 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.102585;

  D.102585 = Gio::TlsDatabase::lookup_certificate_for_handle (this, handle, cancellable, flags); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::TlsCertificate>::RefPtr<Gio::TlsCertificate> (<retval>, &D.102585);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&D.102585);
      D.102585 = {CLOBBER};
    }
}


Glib::RefPtr<const Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle(const Glib::ustring&, Gio::TlsDatabaseLookupFlags) const (const struct TlsDatabase * const this, const struct ustring & handle, TlsDatabaseLookupFlags flags)
{
  struct RefPtr D.102592;

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


void Gio::TlsDatabase::lookup_certificate_for_handle_async(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.157;
  struct BaseObjectType * D.107203;
  struct BaseObjectType * D.107204;
  const char * D.107205;
  struct GTlsDatabase * D.107206;
  struct SlotAsyncReady * slot_copy;

  slot_copy.157 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.157, slot);
    }
  catch
    {
      operator delete (slot_copy.157);
    }
  slot_copy = slot_copy.157;
  D.107203 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107204 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107205 = Glib::ustring::c_str (handle);
  D.107206 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_for_handle_async (D.107206, D.107205, D.107204, flags, D.107203, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_for_handle_async(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.158;
  struct BaseObjectType * D.107212;
  const char * D.107213;
  struct GTlsDatabase * D.107214;
  struct SlotAsyncReady * slot_copy;

  slot_copy.158 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.158, slot);
    }
  catch
    {
      operator delete (slot_copy.158);
    }
  slot_copy = slot_copy.158;
  D.107212 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107213 = Glib::ustring::c_str (handle);
  D.107214 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_for_handle_async (D.107214, D.107213, D.107212, flags, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_for_handle_async(const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.159;
  struct BaseObjectType * D.107219;
  const char * D.107220;
  struct GTlsDatabase * D.107221;
  struct SlotAsyncReady * slot_copy;

  slot_copy.159 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.159, slot);
    }
  catch
    {
      operator delete (slot_copy.159);
    }
  slot_copy = slot_copy.159;
  D.107219 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107220 = Glib::ustring::c_str (handle);
  D.107221 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_for_handle_async (D.107221, D.107220, 0B, flags, D.107219, SignalProxy_async_callback, slot_copy);
}


void Gio::TlsDatabase::lookup_certificate_for_handle_async(const Glib::ustring&, const SlotAsyncReady&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct SlotAsyncReady & slot, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.160;
  const char * D.107226;
  struct GTlsDatabase * D.107227;
  struct SlotAsyncReady * slot_copy;

  slot_copy.160 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.160, slot);
    }
  catch
    {
      operator delete (slot_copy.160);
    }
  slot_copy = slot_copy.160;
  D.107226 = Glib::ustring::c_str (handle);
  D.107227 = Gio::TlsDatabase::gobj (this);
  g_tls_database_lookup_certificate_for_handle_async (D.107227, D.107226, 0B, flags, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.107232;
  struct GTlsDatabase * D.107233;
  struct GTlsCertificate * D.107234;
  struct GError * gerror.161;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.107232 = Glib::unwrap<Gio::AsyncResult> (result);
      D.107233 = Gio::TlsDatabase::gobj (this);
      D.107234 = g_tls_database_lookup_certificate_for_handle_finish (D.107233, D.107232, &gerror);
      *<retval> = Glib::wrap (D.107234, 0); [return slot optimization]
      try
        {
          gerror.161 = gerror;
          if (gerror.161 != 0B) goto <D.107236>; else goto <D.107237>;
          <D.107236>:
          gerror.161 = gerror;
          Glib::Error::throw_exception (gerror.161);
          <D.107237>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


virtual Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain_vfunc(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  int (*__vtbl_ptr_type) () * D.107244;
  int (*__vtbl_ptr_type) () * D.107245;
  long int D.107246;
  sizetype D.107247;
  const struct ObjectBase * D.107248;
  struct GObject * D.107249;
  struct GTypeClass * D.107250;
  GTlsCertificateFlags (*<T1124f>) (struct GTlsDatabase *, struct GTlsCertificate *, const gchar *, struct GSocketConnectable *, struct GTlsInteraction *, GTlsDatabaseVerifyFlags, struct GCancellable *, struct GError * *) D.107253;
  struct BaseObjectType * D.107256;
  struct BaseObjectType * D.107257;
  const struct BaseObjectType * D.107258;
  const char * D.107259;
  struct BaseObjectType * D.107260;
  const struct GTlsDatabase * D.107261;
  struct GError * gerror.162;
  TlsCertificateFlags D.107265;
  struct BaseClassType * const base;
  typedef RType RType;

  D.107244 = this->D.97204._vptr.Object;
  D.107245 = D.107244 + 18446744073709551592;
  D.107246 = MEM[(long int *)D.107245];
  D.107247 = (sizetype) D.107246;
  D.107248 = this + D.107247;
  D.107249 = D.107248->gobject_;
  D.107250 = MEM[(struct GTypeInstance *)D.107249].g_class;
  base = g_type_class_peek_parent (D.107250);
  {
    if (base != 0B) goto <D.107251>; else goto <D.107252>;
    <D.107251>:
    D.107253 = base->verify_chain;
    if (D.107253 != 0B) goto <D.107254>; else goto <D.107255>;
    <D.107254>:
    {
      struct GError * gerror;
      TlsCertificateFlags retval;

      try
        {
          gerror = 0B;
          D.107253 = base->verify_chain;
          D.107256 = Glib::unwrap<Gio::Cancellable> (cancellable);
          D.107257 = Glib::unwrap<Gio::TlsInteraction> (interaction);
          D.107258 = Glib::unwrap<Gio::SocketConnectable> (identity);
          D.107259 = Glib::ustring::c_str (purpose);
          D.107260 = Glib::unwrap<Gio::TlsCertificate> (chain);
          D.107261 = Gio::TlsDatabase::gobj (this);
          retval = D.107253 (D.107261, D.107260, D.107259, D.107258, D.107257, flags, D.107256, &gerror);
          gerror.162 = gerror;
          if (gerror.162 != 0B) goto <D.107263>; else goto <D.107264>;
          <D.107263>:
          gerror.162 = gerror;
          Glib::Error::throw_exception (gerror.162);
          <D.107264>:
          D.107265 = retval;
          return D.107265;
        }
      finally
        {
          gerror = {CLOBBER};
        }
    }
    <D.107255>:
    <D.107252>:
  }
  D.107265 = 0;
  return D.107265;
}


virtual void Gio::TlsDatabase::verify_chain_async_vfunc(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::ustring&, const Glib::RefPtr<const Gio::SocketConnectable>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseVerifyFlags) const (const struct TlsDatabase * const this, const struct RefPtr & chain, const struct ustring & purpose, const struct RefPtr & identity, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseVerifyFlags flags)
{
  void * slot_copy.163;
  int (*__vtbl_ptr_type) () * D.107276;
  int (*__vtbl_ptr_type) () * D.107277;
  long int D.107278;
  sizetype D.107279;
  const struct ObjectBase * D.107280;
  struct GObject * D.107281;
  struct GTypeClass * D.107282;
  void (*<T11253>) (struct GTlsDatabase *, struct GTlsCertificate *, const gchar *, struct GSocketConnectable *, struct GTlsInteraction *, GTlsDatabaseVerifyFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.107285;
  struct BaseObjectType * D.107288;
  struct BaseObjectType * D.107289;
  const struct BaseObjectType * D.107290;
  const char * D.107291;
  struct BaseObjectType * D.107292;
  const struct GTlsDatabase * D.107293;
  struct SlotAsyncReady * slot_copy;
  struct BaseClassType * const base;

  slot_copy.163 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.163, slot);
    }
  catch
    {
      operator delete (slot_copy.163);
    }
  slot_copy = slot_copy.163;
  D.107276 = this->D.97204._vptr.Object;
  D.107277 = D.107276 + 18446744073709551592;
  D.107278 = MEM[(long int *)D.107277];
  D.107279 = (sizetype) D.107278;
  D.107280 = this + D.107279;
  D.107281 = D.107280->gobject_;
  D.107282 = MEM[(struct GTypeInstance *)D.107281].g_class;
  base = g_type_class_peek_parent (D.107282);
  if (base != 0B) goto <D.107283>; else goto <D.107284>;
  <D.107283>:
  D.107285 = base->verify_chain_async;
  if (D.107285 != 0B) goto <D.107286>; else goto <D.107287>;
  <D.107286>:
  D.107285 = base->verify_chain_async;
  D.107288 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107289 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107290 = Glib::unwrap<Gio::SocketConnectable> (identity);
  D.107291 = Glib::ustring::c_str (purpose);
  D.107292 = Glib::unwrap<Gio::TlsCertificate> (chain);
  D.107293 = Gio::TlsDatabase::gobj (this);
  D.107285 (D.107293, D.107292, D.107291, D.107290, D.107289, flags, D.107288, SignalProxy_async_callback, slot_copy);
  goto <D.107294>;
  <D.107287>:
  <D.107294>:
  <D.107284>:
}


virtual Gio::TlsCertificateFlags Gio::TlsDatabase::verify_chain_finish_vfunc(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  int (*__vtbl_ptr_type) () * D.107303;
  int (*__vtbl_ptr_type) () * D.107304;
  long int D.107305;
  sizetype D.107306;
  struct ObjectBase * D.107307;
  struct GObject * D.107308;
  struct GTypeClass * D.107309;
  GTlsCertificateFlags (*<T11257>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.107312;
  struct BaseObjectType * D.107315;
  struct GTlsDatabase * D.107316;
  struct GError * gerror.164;
  TlsCertificateFlags D.107320;
  struct BaseClassType * const base;
  typedef RType RType;

  D.107303 = this->D.97204._vptr.Object;
  D.107304 = D.107303 + 18446744073709551592;
  D.107305 = MEM[(long int *)D.107304];
  D.107306 = (sizetype) D.107305;
  D.107307 = this + D.107306;
  D.107308 = D.107307->gobject_;
  D.107309 = MEM[(struct GTypeInstance *)D.107308].g_class;
  base = g_type_class_peek_parent (D.107309);
  {
    if (base != 0B) goto <D.107310>; else goto <D.107311>;
    <D.107310>:
    D.107312 = base->verify_chain_finish;
    if (D.107312 != 0B) goto <D.107313>; else goto <D.107314>;
    <D.107313>:
    {
      struct GError * gerror;
      TlsCertificateFlags retval;

      try
        {
          gerror = 0B;
          D.107312 = base->verify_chain_finish;
          D.107315 = Glib::unwrap<Gio::AsyncResult> (result);
          D.107316 = Gio::TlsDatabase::gobj (this);
          retval = D.107312 (D.107316, D.107315, &gerror);
          gerror.164 = gerror;
          if (gerror.164 != 0B) goto <D.107318>; else goto <D.107319>;
          <D.107318>:
          gerror.164 = gerror;
          Glib::Error::throw_exception (gerror.164);
          <D.107319>:
          D.107320 = retval;
          return D.107320;
        }
      finally
        {
          gerror = {CLOBBER};
        }
    }
    <D.107314>:
    <D.107311>:
  }
  D.107320 = 0;
  return D.107320;
}


virtual Glib::ustring Gio::TlsDatabase::create_certificate_handle_vfunc(const Glib::RefPtr<const Gio::TlsCertificate>&) const (const struct TlsDatabase * const this, const struct RefPtr & certificate)
{
  int (*__vtbl_ptr_type) () * D.107328;
  int (*__vtbl_ptr_type) () * D.107329;
  long int D.107330;
  sizetype D.107331;
  const struct ObjectBase * D.107332;
  struct GObject * D.107333;
  struct GTypeClass * D.107334;
  gchar * (*<T1125b>) (struct GTlsDatabase *, struct GTlsCertificate *) D.107337;
  const struct BaseObjectType * D.107340;
  const struct GTlsDatabase * D.107341;
  gchar * D.107342;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107328 = this->D.97204._vptr.Object;
  D.107329 = D.107328 + 18446744073709551592;
  D.107330 = MEM[(long int *)D.107329];
  D.107331 = (sizetype) D.107330;
  D.107332 = this + D.107331;
  D.107333 = D.107332->gobject_;
  D.107334 = MEM[(struct GTypeInstance *)D.107333].g_class;
  base = g_type_class_peek_parent (D.107334);
  {
    if (base != 0B) goto <D.107335>; else goto <D.107336>;
    <D.107335>:
    D.107337 = base->create_certificate_handle;
    if (D.107337 != 0B) goto <D.107338>; else goto <D.107339>;
    <D.107338>:
    {
      struct ustring retval;

      try
        {
          D.107337 = base->create_certificate_handle;
          D.107340 = Glib::unwrap<Gio::TlsCertificate> (certificate);
          D.107341 = Gio::TlsDatabase::gobj (this);
          D.107342 = D.107337 (D.107341, D.107340);
          retval = Glib::convert_const_gchar_ptr_to_ustring (D.107342); [return slot optimization]
          try
            {
              Glib::ustring::ustring (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::ustring::~ustring (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.107339>:
    <D.107336>:
  }
  Glib::ustring::ustring (<retval>);
  return <retval>;
}


virtual Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle_vfunc(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  int (*__vtbl_ptr_type) () * D.107352;
  int (*__vtbl_ptr_type) () * D.107353;
  long int D.107354;
  sizetype D.107355;
  struct ObjectBase * D.107356;
  struct GObject * D.107357;
  struct GTypeClass * D.107358;
  struct GTlsCertificate * (*<T1125f>) (struct GTlsDatabase *, const gchar *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.107361;
  struct BaseObjectType * D.107364;
  struct BaseObjectType * D.107365;
  const char * D.107366;
  struct GTlsDatabase * D.107367;
  struct GTlsCertificate * D.107368;
  struct GError * gerror.165;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107352 = this->D.97204._vptr.Object;
  D.107353 = D.107352 + 18446744073709551592;
  D.107354 = MEM[(long int *)D.107353];
  D.107355 = (sizetype) D.107354;
  D.107356 = this + D.107355;
  D.107357 = D.107356->gobject_;
  D.107358 = MEM[(struct GTypeInstance *)D.107357].g_class;
  base = g_type_class_peek_parent (D.107358);
  {
    if (base != 0B) goto <D.107359>; else goto <D.107360>;
    <D.107359>:
    D.107361 = base->lookup_certificate_for_handle;
    if (D.107361 != 0B) goto <D.107362>; else goto <D.107363>;
    <D.107362>:
    {
      struct GError * gerror;
      struct RefPtr retval;

      try
        {
          gerror = 0B;
          D.107361 = base->lookup_certificate_for_handle;
          D.107364 = Glib::unwrap<Gio::Cancellable> (cancellable);
          D.107365 = Glib::unwrap<Gio::TlsInteraction> (interaction);
          D.107366 = Glib::ustring::c_str (handle);
          D.107367 = Gio::TlsDatabase::gobj (this);
          D.107368 = D.107361 (D.107367, D.107366, D.107365, flags, D.107364, &gerror);
          retval = Glib::wrap (D.107368, 0); [return slot optimization]
          try
            {
              gerror.165 = gerror;
              if (gerror.165 != 0B) goto <D.107370>; else goto <D.107371>;
              <D.107370>:
              gerror.165 = gerror;
              Glib::Error::throw_exception (gerror.165);
              <D.107371>:
              Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107363>:
    <D.107360>:
  }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>);
  return <retval>;
}


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


virtual void Gio::TlsDatabase::lookup_certificate_for_handle_async_vfunc(const Glib::ustring&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct ustring & handle, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.166;
  int (*__vtbl_ptr_type) () * D.107382;
  int (*__vtbl_ptr_type) () * D.107383;
  long int D.107384;
  sizetype D.107385;
  struct ObjectBase * D.107386;
  struct GObject * D.107387;
  struct GTypeClass * D.107388;
  void (*<T11263>) (struct GTlsDatabase *, const gchar *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.107391;
  struct BaseObjectType * D.107394;
  struct BaseObjectType * D.107395;
  const char * D.107396;
  struct GTlsDatabase * D.107397;
  struct SlotAsyncReady * slot_copy;
  struct BaseClassType * const base;

  slot_copy.166 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.166, slot);
    }
  catch
    {
      operator delete (slot_copy.166);
    }
  slot_copy = slot_copy.166;
  D.107382 = this->D.97204._vptr.Object;
  D.107383 = D.107382 + 18446744073709551592;
  D.107384 = MEM[(long int *)D.107383];
  D.107385 = (sizetype) D.107384;
  D.107386 = this + D.107385;
  D.107387 = D.107386->gobject_;
  D.107388 = MEM[(struct GTypeInstance *)D.107387].g_class;
  base = g_type_class_peek_parent (D.107388);
  if (base != 0B) goto <D.107389>; else goto <D.107390>;
  <D.107389>:
  D.107391 = base->lookup_certificate_for_handle_async;
  if (D.107391 != 0B) goto <D.107392>; else goto <D.107393>;
  <D.107392>:
  D.107391 = base->lookup_certificate_for_handle_async;
  D.107394 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107395 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107396 = Glib::ustring::c_str (handle);
  D.107397 = Gio::TlsDatabase::gobj (this);
  D.107391 (D.107397, D.107396, D.107395, flags, D.107394, SignalProxy_async_callback, slot_copy);
  goto <D.107398>;
  <D.107393>:
  <D.107398>:
  <D.107390>:
}


virtual Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_for_handle_finish_vfunc(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  int (*__vtbl_ptr_type) () * D.107406;
  int (*__vtbl_ptr_type) () * D.107407;
  long int D.107408;
  sizetype D.107409;
  struct ObjectBase * D.107410;
  struct GObject * D.107411;
  struct GTypeClass * D.107412;
  struct GTlsCertificate * (*<T11267>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.107415;
  struct BaseObjectType * D.107418;
  struct GTlsDatabase * D.107419;
  struct GTlsCertificate * D.107420;
  struct GError * gerror.167;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107406 = this->D.97204._vptr.Object;
  D.107407 = D.107406 + 18446744073709551592;
  D.107408 = MEM[(long int *)D.107407];
  D.107409 = (sizetype) D.107408;
  D.107410 = this + D.107409;
  D.107411 = D.107410->gobject_;
  D.107412 = MEM[(struct GTypeInstance *)D.107411].g_class;
  base = g_type_class_peek_parent (D.107412);
  {
    if (base != 0B) goto <D.107413>; else goto <D.107414>;
    <D.107413>:
    D.107415 = base->lookup_certificate_for_handle_finish;
    if (D.107415 != 0B) goto <D.107416>; else goto <D.107417>;
    <D.107416>:
    {
      struct GError * gerror;
      struct RefPtr retval;

      try
        {
          gerror = 0B;
          D.107415 = base->lookup_certificate_for_handle_finish;
          D.107418 = Glib::unwrap<Gio::AsyncResult> (result);
          D.107419 = Gio::TlsDatabase::gobj (this);
          D.107420 = D.107415 (D.107419, D.107418, &gerror);
          retval = Glib::wrap (D.107420, 0); [return slot optimization]
          try
            {
              gerror.167 = gerror;
              if (gerror.167 != 0B) goto <D.107422>; else goto <D.107423>;
              <D.107422>:
              gerror.167 = gerror;
              Glib::Error::throw_exception (gerror.167);
              <D.107423>:
              Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107417>:
    <D.107414>:
  }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>);
  return <retval>;
}


virtual Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer_vfunc(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  int (*__vtbl_ptr_type) () * D.107433;
  int (*__vtbl_ptr_type) () * D.107434;
  long int D.107435;
  sizetype D.107436;
  struct ObjectBase * D.107437;
  struct GObject * D.107438;
  struct GTypeClass * D.107439;
  struct GTlsCertificate * (*<T1126b>) (struct GTlsDatabase *, struct GTlsCertificate *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.107442;
  struct BaseObjectType * D.107445;
  struct BaseObjectType * D.107446;
  struct BaseObjectType * D.107447;
  struct GTlsDatabase * D.107448;
  struct GTlsCertificate * D.107449;
  struct GError * gerror.168;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107433 = this->D.97204._vptr.Object;
  D.107434 = D.107433 + 18446744073709551592;
  D.107435 = MEM[(long int *)D.107434];
  D.107436 = (sizetype) D.107435;
  D.107437 = this + D.107436;
  D.107438 = D.107437->gobject_;
  D.107439 = MEM[(struct GTypeInstance *)D.107438].g_class;
  base = g_type_class_peek_parent (D.107439);
  {
    if (base != 0B) goto <D.107440>; else goto <D.107441>;
    <D.107440>:
    D.107442 = base->lookup_certificate_issuer;
    if (D.107442 != 0B) goto <D.107443>; else goto <D.107444>;
    <D.107443>:
    {
      struct GError * gerror;
      struct RefPtr retval;

      try
        {
          gerror = 0B;
          D.107442 = base->lookup_certificate_issuer;
          D.107445 = Glib::unwrap<Gio::Cancellable> (cancellable);
          D.107446 = Glib::unwrap<Gio::TlsInteraction> (interaction);
          D.107447 = Glib::unwrap<Gio::TlsCertificate> (certificate);
          D.107448 = Gio::TlsDatabase::gobj (this);
          D.107449 = D.107442 (D.107448, D.107447, D.107446, flags, D.107445, &gerror);
          retval = Glib::wrap (D.107449, 0); [return slot optimization]
          try
            {
              gerror.168 = gerror;
              if (gerror.168 != 0B) goto <D.107451>; else goto <D.107452>;
              <D.107451>:
              gerror.168 = gerror;
              Glib::Error::throw_exception (gerror.168);
              <D.107452>:
              Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107444>:
    <D.107441>:
  }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>);
  return <retval>;
}


virtual void Gio::TlsDatabase::lookup_certificate_issuer_async_vfunc(const Glib::RefPtr<Gio::TlsCertificate>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & certificate, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.169;
  int (*__vtbl_ptr_type) () * D.107463;
  int (*__vtbl_ptr_type) () * D.107464;
  long int D.107465;
  sizetype D.107466;
  struct ObjectBase * D.107467;
  struct GObject * D.107468;
  struct GTypeClass * D.107469;
  void (*<T1126f>) (struct GTlsDatabase *, struct GTlsCertificate *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.107472;
  struct BaseObjectType * D.107475;
  struct BaseObjectType * D.107476;
  struct BaseObjectType * D.107477;
  struct GTlsDatabase * D.107478;
  struct SlotAsyncReady * slot_copy;
  struct BaseClassType * const base;

  slot_copy.169 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.169, slot);
    }
  catch
    {
      operator delete (slot_copy.169);
    }
  slot_copy = slot_copy.169;
  D.107463 = this->D.97204._vptr.Object;
  D.107464 = D.107463 + 18446744073709551592;
  D.107465 = MEM[(long int *)D.107464];
  D.107466 = (sizetype) D.107465;
  D.107467 = this + D.107466;
  D.107468 = D.107467->gobject_;
  D.107469 = MEM[(struct GTypeInstance *)D.107468].g_class;
  base = g_type_class_peek_parent (D.107469);
  if (base != 0B) goto <D.107470>; else goto <D.107471>;
  <D.107470>:
  D.107472 = base->lookup_certificate_issuer_async;
  if (D.107472 != 0B) goto <D.107473>; else goto <D.107474>;
  <D.107473>:
  D.107472 = base->lookup_certificate_issuer_async;
  D.107475 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107476 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107477 = Glib::unwrap<Gio::TlsCertificate> (certificate);
  D.107478 = Gio::TlsDatabase::gobj (this);
  D.107472 (D.107478, D.107477, D.107476, flags, D.107475, SignalProxy_async_callback, slot_copy);
  goto <D.107479>;
  <D.107474>:
  <D.107479>:
  <D.107471>:
}


virtual Glib::RefPtr<Gio::TlsCertificate> Gio::TlsDatabase::lookup_certificate_issuer_finish_vfunc(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  int (*__vtbl_ptr_type) () * D.107487;
  int (*__vtbl_ptr_type) () * D.107488;
  long int D.107489;
  sizetype D.107490;
  struct ObjectBase * D.107491;
  struct GObject * D.107492;
  struct GTypeClass * D.107493;
  struct GTlsCertificate * (*<T11267>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.107496;
  struct BaseObjectType * D.107499;
  struct GTlsDatabase * D.107500;
  struct GTlsCertificate * D.107501;
  struct GError * gerror.170;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107487 = this->D.97204._vptr.Object;
  D.107488 = D.107487 + 18446744073709551592;
  D.107489 = MEM[(long int *)D.107488];
  D.107490 = (sizetype) D.107489;
  D.107491 = this + D.107490;
  D.107492 = D.107491->gobject_;
  D.107493 = MEM[(struct GTypeInstance *)D.107492].g_class;
  base = g_type_class_peek_parent (D.107493);
  {
    if (base != 0B) goto <D.107494>; else goto <D.107495>;
    <D.107494>:
    D.107496 = base->lookup_certificate_issuer_finish;
    if (D.107496 != 0B) goto <D.107497>; else goto <D.107498>;
    <D.107497>:
    {
      struct GError * gerror;
      struct RefPtr retval;

      try
        {
          gerror = 0B;
          D.107496 = base->lookup_certificate_issuer_finish;
          D.107499 = Glib::unwrap<Gio::AsyncResult> (result);
          D.107500 = Gio::TlsDatabase::gobj (this);
          D.107501 = D.107496 (D.107500, D.107499, &gerror);
          retval = Glib::wrap (D.107501, 0); [return slot optimization]
          try
            {
              gerror.170 = gerror;
              if (gerror.170 != 0B) goto <D.107503>; else goto <D.107504>;
              <D.107503>:
              gerror.170 = gerror;
              Glib::Error::throw_exception (gerror.170);
              <D.107504>:
              Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Gio::TlsCertificate>::~RefPtr (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107498>:
    <D.107495>:
  }
  Glib::RefPtr<Gio::TlsCertificate>::RefPtr (<retval>);
  return <retval>;
}


virtual std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by_vfunc(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  int (*__vtbl_ptr_type) () * D.107514;
  int (*__vtbl_ptr_type) () * D.107515;
  long int D.107516;
  sizetype D.107517;
  struct ObjectBase * D.107518;
  struct GObject * D.107519;
  struct GTypeClass * D.107520;
  struct GList * (*<T11275>) (struct GTlsDatabase *, struct GByteArray *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, struct GError * *) D.107523;
  struct BaseObjectType * D.107526;
  struct BaseObjectType * D.107527;
  struct BaseObjectType * D.107528;
  struct GTlsDatabase * D.107529;
  struct GList * D.107530;
  struct GError * gerror.171;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107514 = this->D.97204._vptr.Object;
  D.107515 = D.107514 + 18446744073709551592;
  D.107516 = MEM[(long int *)D.107515];
  D.107517 = (sizetype) D.107516;
  D.107518 = this + D.107517;
  D.107519 = D.107518->gobject_;
  D.107520 = MEM[(struct GTypeInstance *)D.107519].g_class;
  base = g_type_class_peek_parent (D.107520);
  {
    if (base != 0B) goto <D.107521>; else goto <D.107522>;
    <D.107521>:
    D.107523 = base->lookup_certificates_issued_by;
    if (D.107523 != 0B) goto <D.107524>; else goto <D.107525>;
    <D.107524>:
    {
      struct GError * gerror;
      struct vector retval;

      try
        {
          gerror = 0B;
          D.107523 = base->lookup_certificates_issued_by;
          D.107526 = Glib::unwrap<Gio::Cancellable> (cancellable);
          D.107527 = Glib::unwrap<Gio::TlsInteraction> (interaction);
          D.107528 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
          D.107529 = Gio::TlsDatabase::gobj (this);
          D.107530 = D.107523 (D.107529, D.107528, D.107527, flags, D.107526, &gerror);
          retval = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.107530, 2); [return slot optimization]
          try
            {
              gerror.171 = gerror;
              if (gerror.171 != 0B) goto <D.107532>; else goto <D.107533>;
              <D.107532>:
              gerror.171 = gerror;
              Glib::Error::throw_exception (gerror.171);
              <D.107533>:
              std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107525>:
    <D.107522>:
  }
  std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector (<retval>);
  return <retval>;
}


std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (struct vector * const this, const struct vector & __x)
{
  const struct _Vector_base * D.107544;
  const struct _Tp_alloc_type & D.107545;
  const struct allocator & D.107546;
  long unsigned int D.107547;
  struct _Vector_base * D.107548;
  struct _Tp_alloc_type & D.107549;
  struct RefPtr * D.107550;
  struct __normal_iterator D.107551;
  struct __normal_iterator D.107552;
  struct RefPtr * D.107553;

  D.107544 = &__x->D.101040;
  D.107545 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.107544);
  D.107546 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_S_select_on_copy (D.107545);
  D.107547 = std::vector<Glib::RefPtr<Gio::TlsCertificate> >::size (__x);
  D.107548 = &this->D.101040;
  std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_base (D.107548, D.107547, D.107546);
  try
    {
      D.107548 = &this->D.101040;
      D.107549 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_get_Tp_allocator (D.107548);
      D.107550 = this->D.101040._M_impl._M_start;
      D.107551 = std::vector<Glib::RefPtr<Gio::TlsCertificate> >::end (__x);
      D.107552 = std::vector<Glib::RefPtr<Gio::TlsCertificate> >::begin (__x);
      D.107553 = std::__uninitialized_copy_a<__gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >, Glib::RefPtr<Gio::TlsCertificate>*, Glib::RefPtr<Gio::TlsCertificate> > (D.107552, D.107551, D.107550, D.107549);
      this->D.101040._M_impl._M_finish = D.107553;
    }
  catch
    {
      D.107548 = &this->D.101040;
      std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::~_Vector_base (D.107548);
    }
}


const _Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [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> >] (const struct _Vector_base * const this)
{
  const struct _Tp_alloc_type & D.107556;

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


static const _Alloc& __gnu_cxx::__alloc_traits<_Alloc>::_S_select_on_copy(const _Alloc&) [with _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >] (const struct allocator & __a)
{
  const struct allocator & D.107558;

  D.107558 = __a;
  return D.107558;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.107560;
  struct RefPtr * D.107561;
  long int D.107562;
  struct RefPtr * D.107563;
  long int D.107564;
  long int D.107565;
  long int D.107566;

  D.107561 = this->D.101040._M_impl._M_finish;
  D.107562 = (long int) D.107561;
  D.107563 = this->D.101040._M_impl._M_start;
  D.107564 = (long int) D.107563;
  D.107565 = D.107562 - D.107564;
  D.107566 = D.107565 /[ex] 8;
  D.107560 = (size_type) D.107566;
  return D.107560;
}


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

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


void std::_Vector_base<_Tp, _Alloc>::_M_create_storage(std::size_t) [with _Tp = Glib::RefPtr<Gio::TlsCertificate>; _Alloc = std::allocator<Glib::RefPtr<Gio::TlsCertificate> >; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct RefPtr * D.107570;
  struct RefPtr * D.107571;
  long unsigned int D.107572;
  struct RefPtr * D.107573;

  D.107570 = std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_M_allocate (this, __n);
  this->_M_impl._M_start = D.107570;
  D.107571 = this->_M_impl._M_start;
  this->_M_impl._M_finish = D.107571;
  D.107571 = this->_M_impl._M_start;
  D.107572 = __n * 8;
  D.107573 = D.107571 + D.107572;
  this->_M_impl._M_end_of_storage = D.107573;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >; _ForwardIterator = Glib::RefPtr<Gio::TlsCertificate>*; _Tp = Glib::RefPtr<Gio::TlsCertificate>] (struct __normal_iterator __first, struct __normal_iterator __last, struct RefPtr * __result, struct allocator & D.103504)
{
  struct RefPtr * D.107575;

  D.107575 = std::uninitialized_copy<__gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >, Glib::RefPtr<Gio::TlsCertificate>*> (__first, __last, __result);
  return D.107575;
}


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

  __assignable = 1;
  D.107578 = std::__uninitialized_copy<false>::__uninit_copy<__gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >, Glib::RefPtr<Gio::TlsCertificate>*> (__first, __last, __result);
  return D.107578;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >; _ForwardIterator = Glib::RefPtr<Gio::TlsCertificate>*; bool _TrivialValueTypes = false] (struct __normal_iterator __first, struct __normal_iterator __last, struct RefPtr * __result)
{
  const struct RefPtr & D.107581;
  struct RefPtr * D.107582;
  bool retval.172;
  struct RefPtr * D.107584;
  void * D.107585;
  struct RefPtr * __cur;

  __cur = __result;
  try
    {
      goto <D.104624>;
      <D.104623>:
      D.107581 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::operator* (&__first);
      D.107582 = std::__addressof<Glib::RefPtr<Gio::TlsCertificate> > (__cur);
      std::_Construct<Glib::RefPtr<Gio::TlsCertificate>, Glib::RefPtr<Gio::TlsCertificate> > (D.107582, D.107581);
      __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.104624>:
      retval.172 = __gnu_cxx::operator!=<const Glib::RefPtr<Gio::TlsCertificate>*, std::vector<Glib::RefPtr<Gio::TlsCertificate> > > (&__first, &__last);
      if (retval.172 != 0) goto <D.104623>; else goto <D.104621>;
      <D.104621>:
      D.107584 = __cur;
      return D.107584;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.107585 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.107585);
              std::_Destroy<Glib::RefPtr<Gio::TlsCertificate>*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++() [with _Iterator = const Glib::RefPtr<Gio::TlsCertificate>*; _Container = std::vector<Glib::RefPtr<Gio::TlsCertificate> >] (struct __normal_iterator * const this)
{
  const struct RefPtr * D.107591;
  const struct RefPtr * D.107592;
  struct __normal_iterator & D.107593;

  D.107591 = this->_M_current;
  D.107592 = D.107591 + 8;
  this->_M_current = D.107592;
  D.107593 = this;
  return D.107593;
}


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.107595;

  D.107595 = &this->D.101040;
  std::_Vector_base<Glib::RefPtr<Gio::TlsCertificate>, std::allocator<Glib::RefPtr<Gio::TlsCertificate> > >::_Vector_base (D.107595);
  try
    {

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


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 _Vector_impl * D.107596;

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

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


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


virtual void Gio::TlsDatabase::lookup_certificates_issued_by_async_vfunc(const Glib::RefPtr<Glib::ByteArray>&, const Glib::RefPtr<Gio::TlsInteraction>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::TlsDatabaseLookupFlags) (struct TlsDatabase * const this, const struct RefPtr & issuer_raw_dn, const struct RefPtr & interaction, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, TlsDatabaseLookupFlags flags)
{
  void * slot_copy.173;
  int (*__vtbl_ptr_type) () * D.107597;
  int (*__vtbl_ptr_type) () * D.107598;
  long int D.107599;
  sizetype D.107600;
  struct ObjectBase * D.107601;
  struct GObject * D.107602;
  struct GTypeClass * D.107603;
  void (*<T11279>) (struct GTlsDatabase *, struct GByteArray *, struct GTlsInteraction *, GTlsDatabaseLookupFlags, struct GCancellable *, void (*GAsyncReadyCallback) (struct GObject *, struct GAsyncResult *, void *), void *) D.107606;
  struct BaseObjectType * D.107609;
  struct BaseObjectType * D.107610;
  struct BaseObjectType * D.107611;
  struct GTlsDatabase * D.107612;
  struct SlotAsyncReady * slot_copy;
  struct BaseClassType * const base;

  slot_copy.173 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.173, slot);
    }
  catch
    {
      operator delete (slot_copy.173);
    }
  slot_copy = slot_copy.173;
  D.107597 = this->D.97204._vptr.Object;
  D.107598 = D.107597 + 18446744073709551592;
  D.107599 = MEM[(long int *)D.107598];
  D.107600 = (sizetype) D.107599;
  D.107601 = this + D.107600;
  D.107602 = D.107601->gobject_;
  D.107603 = MEM[(struct GTypeInstance *)D.107602].g_class;
  base = g_type_class_peek_parent (D.107603);
  if (base != 0B) goto <D.107604>; else goto <D.107605>;
  <D.107604>:
  D.107606 = base->lookup_certificates_issued_by_async;
  if (D.107606 != 0B) goto <D.107607>; else goto <D.107608>;
  <D.107607>:
  D.107606 = base->lookup_certificates_issued_by_async;
  D.107609 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.107610 = Glib::unwrap<Gio::TlsInteraction> (interaction);
  D.107611 = Glib::unwrap<Glib::ByteArray> (issuer_raw_dn);
  D.107612 = Gio::TlsDatabase::gobj (this);
  D.107606 (D.107612, D.107611, D.107610, flags, D.107609, SignalProxy_async_callback, slot_copy);
  goto <D.107613>;
  <D.107608>:
  <D.107613>:
  <D.107605>:
}


virtual std::vector<Glib::RefPtr<Gio::TlsCertificate> > Gio::TlsDatabase::lookup_certificates_issued_by_finish_vfunc(const Glib::RefPtr<Gio::AsyncResult>&) (struct TlsDatabase * const this, const struct RefPtr & result)
{
  int (*__vtbl_ptr_type) () * D.107621;
  int (*__vtbl_ptr_type) () * D.107622;
  long int D.107623;
  sizetype D.107624;
  struct ObjectBase * D.107625;
  struct GObject * D.107626;
  struct GTypeClass * D.107627;
  struct GList * (*<T1127d>) (struct GTlsDatabase *, struct GAsyncResult *, struct GError * *) D.107630;
  struct BaseObjectType * D.107633;
  struct GTlsDatabase * D.107634;
  struct GList * D.107635;
  struct GError * gerror.174;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.107621 = this->D.97204._vptr.Object;
  D.107622 = D.107621 + 18446744073709551592;
  D.107623 = MEM[(long int *)D.107622];
  D.107624 = (sizetype) D.107623;
  D.107625 = this + D.107624;
  D.107626 = D.107625->gobject_;
  D.107627 = MEM[(struct GTypeInstance *)D.107626].g_class;
  base = g_type_class_peek_parent (D.107627);
  {
    if (base != 0B) goto <D.107628>; else goto <D.107629>;
    <D.107628>:
    D.107630 = base->lookup_certificates_issued_by_finish;
    if (D.107630 != 0B) goto <D.107631>; else goto <D.107632>;
    <D.107631>:
    {
      struct GError * gerror;
      struct vector retval;

      try
        {
          gerror = 0B;
          D.107630 = base->lookup_certificates_issued_by_finish;
          D.107633 = Glib::unwrap<Gio::AsyncResult> (result);
          D.107634 = Gio::TlsDatabase::gobj (this);
          D.107635 = D.107630 (D.107634, D.107633, &gerror);
          retval = Glib::ListHandler<Glib::RefPtr<Gio::TlsCertificate> >::list_to_vector (D.107635, 2); [return slot optimization]
          try
            {
              gerror.174 = gerror;
              if (gerror.174 != 0B) goto <D.107637>; else goto <D.107638>;
              <D.107637>:
              gerror.174 = gerror;
              Glib::Error::throw_exception (gerror.174);
              <D.107638>:
              std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              std::vector<Glib::RefPtr<Gio::TlsCertificate> >::~vector (&retval);
            }
        }
      finally
        {
          gerror = {CLOBBER};
          retval = {CLOBBER};
        }
    }
    <D.107632>:
    <D.107629>:
  }
  std::vector<Glib::RefPtr<Gio::TlsCertificate> >::vector (<retval>);
  return <retval>;
}