static GType Glib::Value<Gio::TlsPasswordFlags>::value_type() ()
{
  GType D.97726;

  D.97726 = g_tls_password_flags_get_type ();
  return D.97726;
}


Glib::RefPtr<Gio::TlsPassword> Glib::wrap(GTlsPassword*, bool) (struct GTlsPassword * object, bool take_copy)
{
  struct TlsPassword * iftmp.0;
  int D.97731;
  struct ObjectBase * D.97732;

  D.97731 = (int) take_copy;
  D.97732 = Glib::wrap_auto (object, D.97731);
  if (D.97732 == 0B) goto <D.97733>; else goto <D.97734>;
  <D.97733>:
  iftmp.0 = 0B;
  goto <D.97735>;
  <D.97734>:
  iftmp.0 = __dynamic_cast (D.97732, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsPasswordE, -1);
  <D.97735>:
  Glib::RefPtr<Gio::TlsPassword>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::TlsPassword_Class::init() (struct TlsPassword_Class * const this)
{
  long unsigned int D.97738;
  long unsigned int D.97741;
  struct Class * D.97742;
  const struct Class & D.97744;

  D.97738 = this->D.86159.gtype_;
  if (D.97738 == 0) goto <D.97739>; else goto <D.97740>;
  <D.97739>:
  this->D.86159.class_init_func_ = class_init_function;
  D.97741 = g_tls_password_get_type ();
  D.97742 = &this->D.86159;
  Glib::Class::register_derived_type (D.97742, D.97741);
  goto <D.97743>;
  <D.97740>:
  <D.97743>:
  D.97744 = &this->D.86159;
  return D.97744;
}


static void Gio::TlsPassword_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->get_value = get_value_vfunc_callback;
  klass->get_default_warning = get_default_warning_vfunc_callback;
}


static const guchar* Gio::TlsPassword_Class::get_value_vfunc_callback(GTlsPassword*, gsize*) (struct GTlsPassword * self, gsize * length)
{
  bool retval.1;
  bool iftmp.2;
  bool D.97752;
  struct CppObjectType * const iftmp.3;
  const guchar * D.97762;
  int (*__vtbl_ptr_type) () * D.97763;
  int (*__vtbl_ptr_type) () * D.97764;
  int (*__vtbl_ptr_type) () D.97765;
  void * D.97766;
  struct GTypeClass * D.97769;
  const guchar * (*<T11359>) (struct GTlsPassword *, gsize *) D.97772;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef const guchar * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97751>; else goto <D.97749>;
    <D.97751>:
    D.97752 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97752 != 0) goto <D.97753>; else goto <D.97749>;
    <D.97753>:
    iftmp.2 = 1;
    goto <D.97750>;
    <D.97749>:
    iftmp.2 = 0;
    <D.97750>:
    retval.1 = iftmp.2;
    if (retval.1 != 0) goto <D.97754>; else goto <D.97755>;
    <D.97754>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97757>; else goto <D.97758>;
      <D.97757>:
      iftmp.3 = 0B;
      goto <D.97759>;
      <D.97758>:
      iftmp.3 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsPasswordE, -1);
      <D.97759>:
      obj = iftmp.3;
      if (obj != 0B) goto <D.97760>; else goto <D.97761>;
      <D.97760>:
      try
        {
          D.97763 = obj->D.86112._vptr.Object;
          D.97764 = D.97763 + 16;
          D.97765 = *D.97764;
          D.97762 = OBJ_TYPE_REF(D.97765;(const struct TlsPassword)obj->2) (obj, length);
          return D.97762;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97766 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97766);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97767>;
      <D.97761>:
      <D.97767>:
    }
    goto <D.97768>;
    <D.97755>:
    <D.97768>:
  }
  D.97769 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.97769);
  {
    if (base != 0B) goto <D.97770>; else goto <D.97771>;
    <D.97770>:
    D.97772 = base->get_value;
    if (D.97772 != 0B) goto <D.97773>; else goto <D.97774>;
    <D.97773>:
    {
      const guchar * retval;

      D.97772 = base->get_value;
      retval = D.97772 (self, length);
      D.97762 = retval;
      return D.97762;
    }
    <D.97774>:
    <D.97771>:
  }
  D.97762 = 0B;
  return D.97762;
}


static const gchar* Gio::TlsPassword_Class::get_default_warning_vfunc_callback(GTlsPassword*) (struct GTlsPassword * self)
{
  bool retval.4;
  bool iftmp.5;
  bool D.97790;
  struct CppObjectType * const iftmp.6;
  const gchar * D.97800;
  struct ustring D.96755;
  int (*__vtbl_ptr_type) () * D.97801;
  int (*__vtbl_ptr_type) () * D.97802;
  int (*__vtbl_ptr_type) () D.97803;
  const char * D.97804;
  void * D.97805;
  struct GTypeClass * D.97808;
  const gchar * (*<T11361>) (struct GTlsPassword *) D.97811;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef const gchar * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97789>; else goto <D.97787>;
    <D.97789>:
    D.97790 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97790 != 0) goto <D.97791>; else goto <D.97787>;
    <D.97791>:
    iftmp.5 = 1;
    goto <D.97788>;
    <D.97787>:
    iftmp.5 = 0;
    <D.97788>:
    retval.4 = iftmp.5;
    if (retval.4 != 0) goto <D.97792>; else goto <D.97793>;
    <D.97792>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97795>; else goto <D.97796>;
      <D.97795>:
      iftmp.6 = 0B;
      goto <D.97797>;
      <D.97796>:
      iftmp.6 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11TlsPasswordE, -1);
      <D.97797>:
      obj = iftmp.6;
      if (obj != 0B) goto <D.97798>; else goto <D.97799>;
      <D.97798>:
      try
        {
          D.97801 = obj->D.86112._vptr.Object;
          D.97802 = D.97801 + 24;
          D.97803 = *D.97802;
          D.96755 = OBJ_TYPE_REF(D.97803;(const struct TlsPassword)obj->3) (obj); [return slot optimization]
          try
            {
              D.97804 = Glib::ustring::c_str (&D.96755);
              D.97800 = g_strdup (D.97804);
              return D.97800;
            }
          finally
            {
              Glib::ustring::~ustring (&D.96755);
              D.96755 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97805 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97805);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97806>;
      <D.97799>:
      <D.97806>:
    }
    goto <D.97807>;
    <D.97793>:
    <D.97807>:
  }
  D.97808 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.97808);
  {
    if (base != 0B) goto <D.97809>; else goto <D.97810>;
    <D.97809>:
    D.97811 = base->get_default_warning;
    if (D.97811 != 0B) goto <D.97812>; else goto <D.97813>;
    <D.97812>:
    {
      const gchar * retval;

      D.97811 = base->get_default_warning;
      retval = D.97811 (self);
      D.97800 = retval;
      return D.97800;
    }
    <D.97813>:
    <D.97810>:
  }
  D.97800 = 0B;
  return D.97800;
}


static Glib::ObjectBase* Gio::TlsPassword_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.97826;
  struct ObjectBase * iftmp.7;
  void * D.96763;
  void * D.97828;
  int (*__vtbl_ptr_type) () * D.97831;
  int (*__vtbl_ptr_type) () * D.97832;
  long int D.97833;
  sizetype D.97834;

  D.96763 = operator new (48);
  try
    {
      Gio::TlsPassword::TlsPassword (D.96763, object);
    }
  catch
    {
      operator delete (D.96763);
    }
  D.97828 = D.96763;
  if (D.97828 != 0B) goto <D.97829>; else goto <D.97830>;
  <D.97829>:
  D.97831 = MEM[(struct TlsPassword *)D.97828].D.86112._vptr.Object;
  D.97832 = D.97831 + 18446744073709551592;
  D.97833 = MEM[(long int *)D.97832];
  D.97834 = (sizetype) D.97833;
  iftmp.7 = D.97828 + D.97834;
  goto <D.97835>;
  <D.97830>:
  iftmp.7 = 0B;
  <D.97835>:
  D.97826 = iftmp.7;
  return D.97826;
}


GTlsPassword* Gio::TlsPassword::gobj_copy() (struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.97839;
  int (*__vtbl_ptr_type) () * D.97840;
  long int D.97841;
  sizetype D.97842;
  struct ObjectBase * D.97843;
  int (*__vtbl_ptr_type) () * D.97844;
  int (*__vtbl_ptr_type) () * D.97845;
  int (*__vtbl_ptr_type) () D.97846;
  struct GTlsPassword * D.97847;

  D.97839 = this->D.86112._vptr.Object;
  D.97840 = D.97839 + 18446744073709551592;
  D.97841 = MEM[(long int *)D.97840];
  D.97842 = (sizetype) D.97841;
  D.97843 = this + D.97842;
  D.97839 = this->D.86112._vptr.Object;
  D.97840 = D.97839 + 18446744073709551592;
  D.97841 = MEM[(long int *)D.97840];
  D.97842 = (sizetype) D.97841;
  D.97843 = this + D.97842;
  D.97844 = D.97843->_vptr.ObjectBase;
  D.97845 = D.97844 + 16;
  D.97846 = *D.97845;
  D.97839 = this->D.86112._vptr.Object;
  D.97840 = D.97839 + 18446744073709551592;
  D.97841 = MEM[(long int *)D.97840];
  D.97842 = (sizetype) D.97841;
  D.97843 = this + D.97842;
  OBJ_TYPE_REF(D.97846;(const struct ObjectBase)D.97843->2) (D.97843);
  D.97847 = Gio::TlsPassword::gobj (this);
  return D.97847;
}


GTlsPassword* Gio::TlsPassword::gobj() (struct TlsPassword * const this)
{
  struct GTlsPassword * D.97849;
  int (*__vtbl_ptr_type) () * D.97850;
  int (*__vtbl_ptr_type) () * D.97851;
  long int D.97852;
  sizetype D.97853;
  struct ObjectBase * D.97854;

  D.97850 = this->D.86112._vptr.Object;
  D.97851 = D.97850 + 18446744073709551592;
  D.97852 = MEM[(long int *)D.97851];
  D.97853 = (sizetype) D.97852;
  D.97854 = this + D.97853;
  D.97849 = D.97854->gobject_;
  return D.97849;
}


Gio::TlsPassword::TlsPassword(const Glib::ConstructParams&) (struct TlsPassword * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.97858;
  const void * * iftmp.8;
  struct ObjectBase * D.97866;
  const void * * iftmp.9;
  struct Object * D.97872;
  int (*__vtbl_ptr_type) () * iftmp.10;
  sizetype iftmp.11;
  int (*__vtbl_ptr_type) () * D.97880;
  int (*__vtbl_ptr_type) () * D.97881;
  long int D.97882;
  struct ObjectBase * D.97884;
  int (*__vtbl_ptr_type) () * iftmp.12;
  const void * * iftmp.13;
  const void * * iftmp.14;

  if (0 != 0) goto <D.97856>; else goto <D.97857>;
  <D.97856>:
  D.97858 = &this->D.86115;
  sigc::trackable::trackable (D.97858);
  goto <D.97859>;
  <D.97857>:
  <D.97859>:
  try
    {
      if (0 != 0) goto <D.97860>; else goto <D.97861>;
      <D.97860>:
      if (0 == 0) goto <D.97863>; else goto <D.97864>;
      <D.97863>:
      iftmp.8 = __vtt_parm + 32;
      goto <D.97865>;
      <D.97864>:
      iftmp.8 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.97865>:
      D.97866 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.97866, iftmp.8);
      goto <D.97867>;
      <D.97861>:
      <D.97867>:
      try
        {
          if (0 == 0) goto <D.97869>; else goto <D.97870>;
          <D.97869>:
          iftmp.9 = __vtt_parm + 8;
          goto <D.97871>;
          <D.97870>:
          iftmp.9 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
          <D.97871>:
          D.97872 = &this->D.86112;
          Glib::Object::Object (D.97872, iftmp.9, construct_params);
          try
            {
              if (0 == 0) goto <D.97874>; else goto <D.97875>;
              <D.97874>:
              iftmp.10 = *__vtt_parm;
              goto <D.97876>;
              <D.97875>:
              iftmp.10 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.97876>:
              this->D.86112._vptr.Object = iftmp.10;
              if (0 == 0) goto <D.97878>; else goto <D.97879>;
              <D.97878>:
              D.97880 = this->D.86112._vptr.Object;
              D.97881 = D.97880 + 18446744073709551592;
              D.97882 = MEM[(long int *)D.97881];
              iftmp.11 = (sizetype) D.97882;
              goto <D.97883>;
              <D.97879>:
              iftmp.11 = 8;
              <D.97883>:
              D.97884 = this + iftmp.11;
              if (0 == 0) goto <D.97886>; else goto <D.97887>;
              <D.97886>:
              iftmp.12 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.97888>;
              <D.97887>:
              iftmp.12 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.97888>:
              D.97884->_vptr.ObjectBase = iftmp.12;
            }
          catch
            {
              if (0 == 0) goto <D.97890>; else goto <D.97891>;
              <D.97890>:
              iftmp.13 = __vtt_parm + 8;
              goto <D.97892>;
              <D.97891>:
              iftmp.13 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.97892>:
              D.97872 = &this->D.86112;
              Glib::Object::~Object (D.97872, iftmp.13);
            }
        }
      catch
        {
          if (0 != 0) goto <D.97893>; else goto <D.97894>;
          <D.97893>:
          if (0 == 0) goto <D.97896>; else goto <D.97897>;
          <D.97896>:
          iftmp.14 = __vtt_parm + 32;
          goto <D.97898>;
          <D.97897>:
          iftmp.14 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.97898>:
          D.97866 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.97866, iftmp.14);
          goto <D.97899>;
          <D.97894>:
          <D.97899>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.97900>; else goto <D.97901>;
      <D.97900>:
      D.97858 = &this->D.86115;
      sigc::trackable::~trackable (D.97858);
      goto <D.97902>;
      <D.97901>:
      <D.97902>:
    }
}


Gio::TlsPassword::TlsPassword(const Glib::ConstructParams&) (struct TlsPassword * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.97907;
  const void * * iftmp.15;
  struct ObjectBase * D.97915;
  const void * * iftmp.16;
  struct Object * D.97921;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.97925;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.97930;
  int (*__vtbl_ptr_type) () * D.97931;
  long int D.97932;
  struct ObjectBase * D.97934;
  int (*__vtbl_ptr_type) () * iftmp.19;
  const void * * iftmp.20;
  const void * * iftmp.21;

  if (1 != 0) goto <D.97905>; else goto <D.97906>;
  <D.97905>:
  D.97907 = &this->D.86115;
  sigc::trackable::trackable (D.97907);
  goto <D.97908>;
  <D.97906>:
  <D.97908>:
  try
    {
      if (1 != 0) goto <D.97909>; else goto <D.97910>;
      <D.97909>:
      if (1 == 0) goto <D.97912>; else goto <D.97913>;
      <D.97912>:
      iftmp.15 = 32B;
      goto <D.97914>;
      <D.97913>:
      iftmp.15 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.97914>:
      D.97915 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.97915, iftmp.15);
      goto <D.97916>;
      <D.97910>:
      <D.97916>:
      try
        {
          if (1 == 0) goto <D.97918>; else goto <D.97919>;
          <D.97918>:
          iftmp.16 = 8B;
          goto <D.97920>;
          <D.97919>:
          iftmp.16 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
          <D.97920>:
          D.97921 = &this->D.86112;
          Glib::Object::Object (D.97921, iftmp.16, construct_params);
          try
            {
              if (1 == 0) goto <D.97923>; else goto <D.97924>;
              <D.97923>:
              D.97925 = 0B;
              iftmp.17 = *D.97925;
              goto <D.97926>;
              <D.97924>:
              iftmp.17 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.97926>:
              this->D.86112._vptr.Object = iftmp.17;
              if (1 == 0) goto <D.97928>; else goto <D.97929>;
              <D.97928>:
              D.97930 = this->D.86112._vptr.Object;
              D.97931 = D.97930 + 18446744073709551592;
              D.97932 = MEM[(long int *)D.97931];
              iftmp.18 = (sizetype) D.97932;
              goto <D.97933>;
              <D.97929>:
              iftmp.18 = 8;
              <D.97933>:
              D.97934 = this + iftmp.18;
              if (1 == 0) goto <D.97936>; else goto <D.97937>;
              <D.97936>:
              iftmp.19 = MEM[(const void * *)0B + 24B];
              goto <D.97938>;
              <D.97937>:
              iftmp.19 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.97938>:
              D.97934->_vptr.ObjectBase = iftmp.19;
            }
          catch
            {
              if (1 == 0) goto <D.97940>; else goto <D.97941>;
              <D.97940>:
              iftmp.20 = 8B;
              goto <D.97942>;
              <D.97941>:
              iftmp.20 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.97942>:
              D.97921 = &this->D.86112;
              Glib::Object::~Object (D.97921, iftmp.20);
            }
        }
      catch
        {
          if (1 != 0) goto <D.97943>; else goto <D.97944>;
          <D.97943>:
          if (1 == 0) goto <D.97946>; else goto <D.97947>;
          <D.97946>:
          iftmp.21 = 32B;
          goto <D.97948>;
          <D.97947>:
          iftmp.21 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.97948>:
          D.97915 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.97915, iftmp.21);
          goto <D.97949>;
          <D.97944>:
          <D.97949>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.97950>; else goto <D.97951>;
      <D.97950>:
      D.97907 = &this->D.86115;
      sigc::trackable::~trackable (D.97907);
      goto <D.97952>;
      <D.97951>:
      <D.97952>:
    }
}


Gio::TlsPassword::TlsPassword(GTlsPassword*) (struct TlsPassword * const this, const void * * __vtt_parm, struct GTlsPassword * castitem)
{
  struct trackable * D.97957;
  const void * * iftmp.22;
  struct ObjectBase * D.97965;
  const void * * iftmp.23;
  struct Object * D.97971;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.97979;
  int (*__vtbl_ptr_type) () * D.97980;
  long int D.97981;
  struct ObjectBase * D.97983;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * iftmp.27;
  const void * * iftmp.28;

  if (0 != 0) goto <D.97955>; else goto <D.97956>;
  <D.97955>:
  D.97957 = &this->D.86115;
  sigc::trackable::trackable (D.97957);
  goto <D.97958>;
  <D.97956>:
  <D.97958>:
  try
    {
      if (0 != 0) goto <D.97959>; else goto <D.97960>;
      <D.97959>:
      if (0 == 0) goto <D.97962>; else goto <D.97963>;
      <D.97962>:
      iftmp.22 = __vtt_parm + 32;
      goto <D.97964>;
      <D.97963>:
      iftmp.22 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.97964>:
      D.97965 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.97965, iftmp.22);
      goto <D.97966>;
      <D.97960>:
      <D.97966>:
      try
        {
          if (0 == 0) goto <D.97968>; else goto <D.97969>;
          <D.97968>:
          iftmp.23 = __vtt_parm + 8;
          goto <D.97970>;
          <D.97969>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
          <D.97970>:
          D.97971 = &this->D.86112;
          Glib::Object::Object (D.97971, iftmp.23, castitem);
          try
            {
              if (0 == 0) goto <D.97973>; else goto <D.97974>;
              <D.97973>:
              iftmp.24 = *__vtt_parm;
              goto <D.97975>;
              <D.97974>:
              iftmp.24 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.97975>:
              this->D.86112._vptr.Object = iftmp.24;
              if (0 == 0) goto <D.97977>; else goto <D.97978>;
              <D.97977>:
              D.97979 = this->D.86112._vptr.Object;
              D.97980 = D.97979 + 18446744073709551592;
              D.97981 = MEM[(long int *)D.97980];
              iftmp.25 = (sizetype) D.97981;
              goto <D.97982>;
              <D.97978>:
              iftmp.25 = 8;
              <D.97982>:
              D.97983 = this + iftmp.25;
              if (0 == 0) goto <D.97985>; else goto <D.97986>;
              <D.97985>:
              iftmp.26 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.97987>;
              <D.97986>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.97987>:
              D.97983->_vptr.ObjectBase = iftmp.26;
            }
          catch
            {
              if (0 == 0) goto <D.97989>; else goto <D.97990>;
              <D.97989>:
              iftmp.27 = __vtt_parm + 8;
              goto <D.97991>;
              <D.97990>:
              iftmp.27 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.97991>:
              D.97971 = &this->D.86112;
              Glib::Object::~Object (D.97971, iftmp.27);
            }
        }
      catch
        {
          if (0 != 0) goto <D.97992>; else goto <D.97993>;
          <D.97992>:
          if (0 == 0) goto <D.97995>; else goto <D.97996>;
          <D.97995>:
          iftmp.28 = __vtt_parm + 32;
          goto <D.97997>;
          <D.97996>:
          iftmp.28 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.97997>:
          D.97965 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.97965, iftmp.28);
          goto <D.97998>;
          <D.97993>:
          <D.97998>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.97999>; else goto <D.98000>;
      <D.97999>:
      D.97957 = &this->D.86115;
      sigc::trackable::~trackable (D.97957);
      goto <D.98001>;
      <D.98000>:
      <D.98001>:
    }
}


Gio::TlsPassword::TlsPassword(GTlsPassword*) (struct TlsPassword * const this, struct GTlsPassword * castitem)
{
  struct trackable * D.98006;
  const void * * iftmp.29;
  struct ObjectBase * D.98014;
  const void * * iftmp.30;
  struct Object * D.98020;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * D.98024;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.98029;
  int (*__vtbl_ptr_type) () * D.98030;
  long int D.98031;
  struct ObjectBase * D.98033;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * iftmp.34;
  const void * * iftmp.35;

  if (1 != 0) goto <D.98004>; else goto <D.98005>;
  <D.98004>:
  D.98006 = &this->D.86115;
  sigc::trackable::trackable (D.98006);
  goto <D.98007>;
  <D.98005>:
  <D.98007>:
  try
    {
      if (1 != 0) goto <D.98008>; else goto <D.98009>;
      <D.98008>:
      if (1 == 0) goto <D.98011>; else goto <D.98012>;
      <D.98011>:
      iftmp.29 = 32B;
      goto <D.98013>;
      <D.98012>:
      iftmp.29 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.98013>:
      D.98014 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.98014, iftmp.29);
      goto <D.98015>;
      <D.98009>:
      <D.98015>:
      try
        {
          if (1 == 0) goto <D.98017>; else goto <D.98018>;
          <D.98017>:
          iftmp.30 = 8B;
          goto <D.98019>;
          <D.98018>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
          <D.98019>:
          D.98020 = &this->D.86112;
          Glib::Object::Object (D.98020, iftmp.30, castitem);
          try
            {
              if (1 == 0) goto <D.98022>; else goto <D.98023>;
              <D.98022>:
              D.98024 = 0B;
              iftmp.31 = *D.98024;
              goto <D.98025>;
              <D.98023>:
              iftmp.31 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.98025>:
              this->D.86112._vptr.Object = iftmp.31;
              if (1 == 0) goto <D.98027>; else goto <D.98028>;
              <D.98027>:
              D.98029 = this->D.86112._vptr.Object;
              D.98030 = D.98029 + 18446744073709551592;
              D.98031 = MEM[(long int *)D.98030];
              iftmp.32 = (sizetype) D.98031;
              goto <D.98032>;
              <D.98028>:
              iftmp.32 = 8;
              <D.98032>:
              D.98033 = this + iftmp.32;
              if (1 == 0) goto <D.98035>; else goto <D.98036>;
              <D.98035>:
              iftmp.33 = MEM[(const void * *)0B + 24B];
              goto <D.98037>;
              <D.98036>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.98037>:
              D.98033->_vptr.ObjectBase = iftmp.33;
            }
          catch
            {
              if (1 == 0) goto <D.98039>; else goto <D.98040>;
              <D.98039>:
              iftmp.34 = 8B;
              goto <D.98041>;
              <D.98040>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.98041>:
              D.98020 = &this->D.86112;
              Glib::Object::~Object (D.98020, iftmp.34);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98042>; else goto <D.98043>;
          <D.98042>:
          if (1 == 0) goto <D.98045>; else goto <D.98046>;
          <D.98045>:
          iftmp.35 = 32B;
          goto <D.98047>;
          <D.98046>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.98047>:
          D.98014 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.98014, iftmp.35);
          goto <D.98048>;
          <D.98043>:
          <D.98048>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98049>; else goto <D.98050>;
      <D.98049>:
      D.98006 = &this->D.86115;
      sigc::trackable::~trackable (D.98006);
      goto <D.98051>;
      <D.98050>:
      <D.98051>:
    }
}


Gio::TlsPassword::~TlsPassword() (struct TlsPassword * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.36;
  sizetype iftmp.37;
  int (*__vtbl_ptr_type) () * D.98061;
  int (*__vtbl_ptr_type) () * D.98062;
  long int D.98063;
  struct ObjectBase * D.98065;
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * iftmp.39;
  struct Object * D.98074;
  int D.98075;
  const void * * iftmp.40;
  struct ObjectBase * D.98082;
  struct trackable * D.98086;
  int D.98088;

  {
    if (0 == 0) goto <D.98055>; else goto <D.98056>;
    <D.98055>:
    iftmp.36 = *__vtt_parm;
    goto <D.98057>;
    <D.98056>:
    iftmp.36 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
    <D.98057>:
    this->D.86112._vptr.Object = iftmp.36;
    if (0 == 0) goto <D.98059>; else goto <D.98060>;
    <D.98059>:
    D.98061 = this->D.86112._vptr.Object;
    D.98062 = D.98061 + 18446744073709551592;
    D.98063 = MEM[(long int *)D.98062];
    iftmp.37 = (sizetype) D.98063;
    goto <D.98064>;
    <D.98060>:
    iftmp.37 = 8;
    <D.98064>:
    D.98065 = this + iftmp.37;
    if (0 == 0) goto <D.98067>; else goto <D.98068>;
    <D.98067>:
    iftmp.38 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.98069>;
    <D.98068>:
    iftmp.38 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
    <D.98069>:
    D.98065->_vptr.ObjectBase = iftmp.38;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.98071>; else goto <D.98072>;
                    <D.98071>:
                    iftmp.39 = __vtt_parm + 8;
                    goto <D.98073>;
                    <D.98072>:
                    iftmp.39 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
                    <D.98073>:
                    D.98074 = &this->D.86112;
                    Glib::Object::~Object (D.98074, iftmp.39);
                  }
              }
            finally
              {
                D.98075 = 0;
                if (D.98075 != 0) goto <D.98076>; else goto <D.98077>;
                <D.98076>:
                if (0 == 0) goto <D.98079>; else goto <D.98080>;
                <D.98079>:
                iftmp.40 = __vtt_parm + 32;
                goto <D.98081>;
                <D.98080>:
                iftmp.40 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
                <D.98081>:
                D.98082 = &this->D.86114;
                Glib::ObjectBase::~ObjectBase (D.98082, iftmp.40);
                goto <D.98083>;
                <D.98077>:
                <D.98083>:
              }
          }
        finally
          {
            D.98075 = 0;
            if (D.98075 != 0) goto <D.98084>; else goto <D.98085>;
            <D.98084>:
            D.98086 = &this->D.86115;
            sigc::trackable::~trackable (D.98086);
            goto <D.98087>;
            <D.98085>:
            <D.98087>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96791>:
  D.98088 = 0;
  if (D.98088 != 0) goto <D.98089>; else goto <D.98090>;
  <D.98089>:
  operator delete (this);
  goto <D.98091>;
  <D.98090>:
  <D.98091>:
}


virtual Gio::TlsPassword::~TlsPassword() (struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * D.98107;
  sizetype iftmp.42;
  int (*__vtbl_ptr_type) () * D.98112;
  int (*__vtbl_ptr_type) () * D.98113;
  long int D.98114;
  struct ObjectBase * D.98116;
  int (*__vtbl_ptr_type) () * iftmp.43;
  const void * * iftmp.44;
  struct Object * D.98125;
  int D.98126;
  const void * * iftmp.45;
  struct ObjectBase * D.98133;
  struct trackable * D.98137;
  int D.98139;

  {
    if (2 == 0) goto <D.98105>; else goto <D.98106>;
    <D.98105>:
    D.98107 = 0B;
    iftmp.41 = *D.98107;
    goto <D.98108>;
    <D.98106>:
    iftmp.41 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
    <D.98108>:
    this->D.86112._vptr.Object = iftmp.41;
    if (2 == 0) goto <D.98110>; else goto <D.98111>;
    <D.98110>:
    D.98112 = this->D.86112._vptr.Object;
    D.98113 = D.98112 + 18446744073709551592;
    D.98114 = MEM[(long int *)D.98113];
    iftmp.42 = (sizetype) D.98114;
    goto <D.98115>;
    <D.98111>:
    iftmp.42 = 8;
    <D.98115>:
    D.98116 = this + iftmp.42;
    if (2 == 0) goto <D.98118>; else goto <D.98119>;
    <D.98118>:
    iftmp.43 = MEM[(const void * *)0B + 24B];
    goto <D.98120>;
    <D.98119>:
    iftmp.43 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
    <D.98120>:
    D.98116->_vptr.ObjectBase = iftmp.43;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.98122>; else goto <D.98123>;
                    <D.98122>:
                    iftmp.44 = 8B;
                    goto <D.98124>;
                    <D.98123>:
                    iftmp.44 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
                    <D.98124>:
                    D.98125 = &this->D.86112;
                    Glib::Object::~Object (D.98125, iftmp.44);
                  }
              }
            finally
              {
                D.98126 = 2;
                if (D.98126 != 0) goto <D.98127>; else goto <D.98128>;
                <D.98127>:
                if (2 == 0) goto <D.98130>; else goto <D.98131>;
                <D.98130>:
                iftmp.45 = 32B;
                goto <D.98132>;
                <D.98131>:
                iftmp.45 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
                <D.98132>:
                D.98133 = &this->D.86114;
                Glib::ObjectBase::~ObjectBase (D.98133, iftmp.45);
                goto <D.98134>;
                <D.98128>:
                <D.98134>:
              }
          }
        finally
          {
            D.98126 = 2;
            if (D.98126 != 0) goto <D.98135>; else goto <D.98136>;
            <D.98135>:
            D.98137 = &this->D.86115;
            sigc::trackable::~trackable (D.98137);
            goto <D.98138>;
            <D.98136>:
            <D.98138>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96794>:
  D.98139 = 0;
  if (D.98139 != 0) goto <D.98140>; else goto <D.98141>;
  <D.98140>:
  operator delete (this);
  goto <D.98142>;
  <D.98141>:
  <D.98142>:
}


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


static GType Gio::TlsPassword::get_type() ()
{
  GType D.98155;
  const struct Class & D.98156;

  D.98156 = Gio::TlsPassword_Class::init (&tlspassword_class_);
  D.98155 = Glib::Class::get_type (D.98156);
  return D.98155;
}


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

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


static GType Gio::TlsPassword::get_base_type() ()
{
  GType D.98161;

  D.98161 = g_tls_password_get_type ();
  return D.98161;
}


Gio::TlsPassword::TlsPassword(const Glib::ustring&, Gio::TlsPasswordFlags) (struct TlsPassword * const this, const void * * __vtt_parm, const struct ustring & description, TlsPasswordFlags flags)
{
  struct trackable * D.98166;
  const void * * iftmp.46;
  struct ObjectBase * D.98174;
  struct ConstructParams D.96819;
  const char * D.98176;
  int flags.47;
  const struct Class & D.98178;
  const void * * iftmp.48;
  struct Object * D.98183;
  int (*__vtbl_ptr_type) () * iftmp.49;
  sizetype iftmp.50;
  int (*__vtbl_ptr_type) () * D.98191;
  int (*__vtbl_ptr_type) () * D.98192;
  long int D.98193;
  struct ObjectBase * D.98195;
  int (*__vtbl_ptr_type) () * iftmp.51;
  const void * * iftmp.52;
  const void * * iftmp.53;

  if (0 != 0) goto <D.98164>; else goto <D.98165>;
  <D.98164>:
  D.98166 = &this->D.86115;
  sigc::trackable::trackable (D.98166);
  goto <D.98167>;
  <D.98165>:
  <D.98167>:
  try
    {
      if (0 != 0) goto <D.98168>; else goto <D.98169>;
      <D.98168>:
      if (0 == 0) goto <D.98171>; else goto <D.98172>;
      <D.98171>:
      iftmp.46 = __vtt_parm + 32;
      goto <D.98173>;
      <D.98172>:
      iftmp.46 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.98173>:
      D.98174 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.98174, iftmp.46, 0B);
      goto <D.98175>;
      <D.98169>:
      <D.98175>:
      try
        {
          D.98176 = Glib::ustring::c_str (description);
          flags.47 = (int) flags;
          D.98178 = Gio::TlsPassword_Class::init (&tlspassword_class_);
          Glib::ConstructParams::ConstructParams (&D.96819, D.98178, "flags", flags.47, "description", D.98176, 0B);
          try
            {
              if (0 == 0) goto <D.98180>; else goto <D.98181>;
              <D.98180>:
              iftmp.48 = __vtt_parm + 8;
              goto <D.98182>;
              <D.98181>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.98182>:
              D.98183 = &this->D.86112;
              Glib::Object::Object (D.98183, iftmp.48, &D.96819);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.96819);
              D.96819 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.98185>; else goto <D.98186>;
              <D.98185>:
              iftmp.49 = *__vtt_parm;
              goto <D.98187>;
              <D.98186>:
              iftmp.49 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.98187>:
              this->D.86112._vptr.Object = iftmp.49;
              if (0 == 0) goto <D.98189>; else goto <D.98190>;
              <D.98189>:
              D.98191 = this->D.86112._vptr.Object;
              D.98192 = D.98191 + 18446744073709551592;
              D.98193 = MEM[(long int *)D.98192];
              iftmp.50 = (sizetype) D.98193;
              goto <D.98194>;
              <D.98190>:
              iftmp.50 = 8;
              <D.98194>:
              D.98195 = this + iftmp.50;
              if (0 == 0) goto <D.98197>; else goto <D.98198>;
              <D.98197>:
              iftmp.51 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98199>;
              <D.98198>:
              iftmp.51 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.98199>:
              D.98195->_vptr.ObjectBase = iftmp.51;
            }
          catch
            {
              if (0 == 0) goto <D.98201>; else goto <D.98202>;
              <D.98201>:
              iftmp.52 = __vtt_parm + 8;
              goto <D.98203>;
              <D.98202>:
              iftmp.52 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.98203>:
              D.98183 = &this->D.86112;
              Glib::Object::~Object (D.98183, iftmp.52);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98204>; else goto <D.98205>;
          <D.98204>:
          if (0 == 0) goto <D.98207>; else goto <D.98208>;
          <D.98207>:
          iftmp.53 = __vtt_parm + 32;
          goto <D.98209>;
          <D.98208>:
          iftmp.53 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.98209>:
          D.98174 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.98174, iftmp.53);
          goto <D.98210>;
          <D.98205>:
          <D.98210>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98211>; else goto <D.98212>;
      <D.98211>:
      D.98166 = &this->D.86115;
      sigc::trackable::~trackable (D.98166);
      goto <D.98213>;
      <D.98212>:
      <D.98213>:
    }
}


Gio::TlsPassword::TlsPassword(const Glib::ustring&, Gio::TlsPasswordFlags) (struct TlsPassword * const this, const struct ustring & description, TlsPasswordFlags flags)
{
  struct trackable * D.98221;
  const void * * iftmp.54;
  struct ObjectBase * D.98229;
  struct ConstructParams D.96821;
  const char * D.98231;
  int flags.55;
  const struct Class & D.98233;
  const void * * iftmp.56;
  struct Object * D.98238;
  int (*__vtbl_ptr_type) () * iftmp.57;
  const void * * D.98242;
  sizetype iftmp.58;
  int (*__vtbl_ptr_type) () * D.98247;
  int (*__vtbl_ptr_type) () * D.98248;
  long int D.98249;
  struct ObjectBase * D.98251;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * iftmp.60;
  const void * * iftmp.61;

  if (1 != 0) goto <D.98219>; else goto <D.98220>;
  <D.98219>:
  D.98221 = &this->D.86115;
  sigc::trackable::trackable (D.98221);
  goto <D.98222>;
  <D.98220>:
  <D.98222>:
  try
    {
      if (1 != 0) goto <D.98223>; else goto <D.98224>;
      <D.98223>:
      if (1 == 0) goto <D.98226>; else goto <D.98227>;
      <D.98226>:
      iftmp.54 = 32B;
      goto <D.98228>;
      <D.98227>:
      iftmp.54 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
      <D.98228>:
      D.98229 = &this->D.86114;
      Glib::ObjectBase::ObjectBase (D.98229, iftmp.54, 0B);
      goto <D.98230>;
      <D.98224>:
      <D.98230>:
      try
        {
          D.98231 = Glib::ustring::c_str (description);
          flags.55 = (int) flags;
          D.98233 = Gio::TlsPassword_Class::init (&tlspassword_class_);
          Glib::ConstructParams::ConstructParams (&D.96821, D.98233, "flags", flags.55, "description", D.98231, 0B);
          try
            {
              if (1 == 0) goto <D.98235>; else goto <D.98236>;
              <D.98235>:
              iftmp.56 = 8B;
              goto <D.98237>;
              <D.98236>:
              iftmp.56 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.98237>:
              D.98238 = &this->D.86112;
              Glib::Object::Object (D.98238, iftmp.56, &D.96821);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.96821);
              D.96821 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.98240>; else goto <D.98241>;
              <D.98240>:
              D.98242 = 0B;
              iftmp.57 = *D.98242;
              goto <D.98243>;
              <D.98241>:
              iftmp.57 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 32B];
              <D.98243>:
              this->D.86112._vptr.Object = iftmp.57;
              if (1 == 0) goto <D.98245>; else goto <D.98246>;
              <D.98245>:
              D.98247 = this->D.86112._vptr.Object;
              D.98248 = D.98247 + 18446744073709551592;
              D.98249 = MEM[(long int *)D.98248];
              iftmp.58 = (sizetype) D.98249;
              goto <D.98250>;
              <D.98246>:
              iftmp.58 = 8;
              <D.98250>:
              D.98251 = this + iftmp.58;
              if (1 == 0) goto <D.98253>; else goto <D.98254>;
              <D.98253>:
              iftmp.59 = MEM[(const void * *)0B + 24B];
              goto <D.98255>;
              <D.98254>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio11TlsPasswordE + 128B];
              <D.98255>:
              D.98251->_vptr.ObjectBase = iftmp.59;
            }
          catch
            {
              if (1 == 0) goto <D.98257>; else goto <D.98258>;
              <D.98257>:
              iftmp.60 = 8B;
              goto <D.98259>;
              <D.98258>:
              iftmp.60 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 8B];
              <D.98259>:
              D.98238 = &this->D.86112;
              Glib::Object::~Object (D.98238, iftmp.60);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98260>; else goto <D.98261>;
          <D.98260>:
          if (1 == 0) goto <D.98263>; else goto <D.98264>;
          <D.98263>:
          iftmp.61 = 32B;
          goto <D.98265>;
          <D.98264>:
          iftmp.61 = &MEM[(void *)&_ZTTN3Gio11TlsPasswordE + 32B];
          <D.98265>:
          D.98229 = &this->D.86114;
          Glib::ObjectBase::~ObjectBase (D.98229, iftmp.61);
          goto <D.98266>;
          <D.98261>:
          <D.98266>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98267>; else goto <D.98268>;
      <D.98267>:
      D.98221 = &this->D.86115;
      sigc::trackable::~trackable (D.98221);
      goto <D.98269>;
      <D.98268>:
      <D.98269>:
    }
}


static Glib::RefPtr<Gio::TlsPassword> Gio::TlsPassword::create(const Glib::ustring&, Gio::TlsPasswordFlags) (const struct ustring & description, TlsPasswordFlags flags)
{
  void * D.96827;

  D.96827 = operator new (48);
  try
    {
      Gio::TlsPassword::TlsPassword (D.96827, description, flags);
    }
  catch
    {
      operator delete (D.96827);
    }
  Glib::RefPtr<Gio::TlsPassword>::RefPtr (<retval>, D.96827);
  return <retval>;
}


const guchar* Gio::TlsPassword::get_value(gsize&) const (const struct TlsPassword * const this, gsize & length)
{
  const guchar * D.98279;
  const struct GTlsPassword * D.98280;

  D.98280 = Gio::TlsPassword::gobj (this);
  D.98279 = g_tls_password_get_value (D.98280, length);
  return D.98279;
}


const GTlsPassword* Gio::TlsPassword::gobj() const (const struct TlsPassword * const this)
{
  const struct GTlsPassword * D.98283;
  int (*__vtbl_ptr_type) () * D.98284;
  int (*__vtbl_ptr_type) () * D.98285;
  long int D.98286;
  sizetype D.98287;
  const struct ObjectBase * D.98288;

  D.98284 = this->D.86112._vptr.Object;
  D.98285 = D.98284 + 18446744073709551592;
  D.98286 = MEM[(long int *)D.98285];
  D.98287 = (sizetype) D.98286;
  D.98288 = this + D.98287;
  D.98283 = D.98288->gobject_;
  return D.98283;
}


const guchar* Gio::TlsPassword::get_value() const (const struct TlsPassword * const this)
{
  const guchar * D.98290;
  const struct GTlsPassword * D.98291;

  D.98291 = Gio::TlsPassword::gobj (this);
  D.98290 = g_tls_password_get_value (D.98291, 0B);
  return D.98290;
}


void Gio::TlsPassword::set_value(const guchar*, gssize) (struct TlsPassword * const this, const guchar * value, gssize length)
{
  struct GTlsPassword * D.98294;

  D.98294 = Gio::TlsPassword::gobj (this);
  g_tls_password_set_value (D.98294, value, length);
}


Glib::ustring Gio::TlsPassword::get_description() const (const struct TlsPassword * const this)
{
  const struct GTlsPassword * D.98296;
  const gchar * D.98297;

  D.98296 = Gio::TlsPassword::gobj (this);
  D.98297 = g_tls_password_get_description (D.98296);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.98297); [return slot optimization]
  return <retval>;
}


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

  if (str != 0B) goto <D.98301>; else goto <D.98302>;
  <D.98301>:
  D.98303 = <retval>;
  Glib::ustring::ustring (D.98303, str);
  goto <D.98304>;
  <D.98302>:
  D.98303 = <retval>;
  Glib::ustring::ustring (D.98303);
  <D.98304>:
  return <retval>;
}


void Gio::TlsPassword::set_description(const Glib::ustring&) (struct TlsPassword * const this, const struct ustring & description)
{
  const char * D.98306;
  struct GTlsPassword * D.98307;

  D.98306 = Glib::ustring::c_str (description);
  D.98307 = Gio::TlsPassword::gobj (this);
  g_tls_password_set_description (D.98307, D.98306);
}


Gio::TlsPasswordFlags Gio::TlsPassword::get_flags() const (const struct TlsPassword * const this)
{
  TlsPasswordFlags D.98309;
  const struct GTlsPassword * D.98310;

  D.98310 = Gio::TlsPassword::gobj (this);
  D.98309 = g_tls_password_get_flags (D.98310);
  return D.98309;
}


void Gio::TlsPassword::set_flags(Gio::TlsPasswordFlags) (struct TlsPassword * const this, TlsPasswordFlags flags)
{
  struct GTlsPassword * D.98313;

  D.98313 = Gio::TlsPassword::gobj (this);
  g_tls_password_set_flags (D.98313, flags);
}


Glib::ustring Gio::TlsPassword::get_warning() const (const struct TlsPassword * const this)
{
  const struct GTlsPassword * D.98315;
  const gchar * D.98316;

  D.98315 = Gio::TlsPassword::gobj (this);
  D.98316 = g_tls_password_get_warning (D.98315);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.98316); [return slot optimization]
  return <retval>;
}


void Gio::TlsPassword::set_warning(const Glib::ustring&) (struct TlsPassword * const this, const struct ustring & warning)
{
  const char * D.98319;
  struct GTlsPassword * D.98320;

  D.98319 = Glib::ustring::c_str (warning);
  D.98320 = Gio::TlsPassword::gobj (this);
  g_tls_password_set_warning (D.98320, D.98319);
}


Glib::PropertyProxy<Glib::ustring> Gio::TlsPassword::property_description() (struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98323;
  int (*__vtbl_ptr_type) () * D.98324;
  long int D.98325;
  sizetype D.98326;
  struct ObjectBase * D.98327;

  D.98323 = this->D.86112._vptr.Object;
  D.98324 = D.98323 + 18446744073709551592;
  D.98325 = MEM[(long int *)D.98324];
  D.98326 = (sizetype) D.98325;
  D.98327 = this + D.98326;
  Glib::PropertyProxy<Glib::ustring>::PropertyProxy (<retval>, D.98327, "description");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::TlsPassword::property_description() const (const struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98331;
  int (*__vtbl_ptr_type) () * D.98332;
  long int D.98333;
  sizetype D.98334;
  const struct ObjectBase * D.98335;

  D.98331 = this->D.86112._vptr.Object;
  D.98332 = D.98331 + 18446744073709551592;
  D.98333 = MEM[(long int *)D.98332];
  D.98334 = (sizetype) D.98333;
  D.98335 = this + D.98334;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.98335, "description");
  return <retval>;
}


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

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


Glib::PropertyProxy<Gio::TlsPasswordFlags> Gio::TlsPassword::property_flags() (struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98339;
  int (*__vtbl_ptr_type) () * D.98340;
  long int D.98341;
  sizetype D.98342;
  struct ObjectBase * D.98343;

  D.98339 = this->D.86112._vptr.Object;
  D.98340 = D.98339 + 18446744073709551592;
  D.98341 = MEM[(long int *)D.98340];
  D.98342 = (sizetype) D.98341;
  D.98343 = this + D.98342;
  Glib::PropertyProxy<Gio::TlsPasswordFlags>::PropertyProxy (<retval>, D.98343, "flags");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Gio::TlsPasswordFlags> Gio::TlsPassword::property_flags() const (const struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98347;
  int (*__vtbl_ptr_type) () * D.98348;
  long int D.98349;
  sizetype D.98350;
  const struct ObjectBase * D.98351;

  D.98347 = this->D.86112._vptr.Object;
  D.98348 = D.98347 + 18446744073709551592;
  D.98349 = MEM[(long int *)D.98348];
  D.98350 = (sizetype) D.98349;
  D.98351 = this + D.98350;
  Glib::PropertyProxy_ReadOnly<Gio::TlsPasswordFlags>::PropertyProxy_ReadOnly (<retval>, D.98351, "flags");
  return <retval>;
}


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

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


Glib::PropertyProxy<Glib::ustring> Gio::TlsPassword::property_warning() (struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98355;
  int (*__vtbl_ptr_type) () * D.98356;
  long int D.98357;
  sizetype D.98358;
  struct ObjectBase * D.98359;

  D.98355 = this->D.86112._vptr.Object;
  D.98356 = D.98355 + 18446744073709551592;
  D.98357 = MEM[(long int *)D.98356];
  D.98358 = (sizetype) D.98357;
  D.98359 = this + D.98358;
  Glib::PropertyProxy<Glib::ustring>::PropertyProxy (<retval>, D.98359, "warning");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::TlsPassword::property_warning() const (const struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98362;
  int (*__vtbl_ptr_type) () * D.98363;
  long int D.98364;
  sizetype D.98365;
  const struct ObjectBase * D.98366;

  D.98362 = this->D.86112._vptr.Object;
  D.98363 = D.98362 + 18446744073709551592;
  D.98364 = MEM[(long int *)D.98363];
  D.98365 = (sizetype) D.98364;
  D.98366 = this + D.98365;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.98366, "warning");
  return <retval>;
}


virtual const guchar* Gio::TlsPassword::get_value_vfunc(gsize&) const (const struct TlsPassword * const this, gsize & length)
{
  int (*__vtbl_ptr_type) () * D.98368;
  int (*__vtbl_ptr_type) () * D.98369;
  long int D.98370;
  sizetype D.98371;
  const struct ObjectBase * D.98372;
  struct GObject * D.98373;
  struct GTypeClass * D.98374;
  const guchar * (*<T11359>) (struct GTlsPassword *, gsize *) D.98377;
  const struct GTlsPassword * D.98380;
  const guchar * D.98381;
  struct BaseClassType * const base;
  typedef const guchar * RType;

  D.98368 = this->D.86112._vptr.Object;
  D.98369 = D.98368 + 18446744073709551592;
  D.98370 = MEM[(long int *)D.98369];
  D.98371 = (sizetype) D.98370;
  D.98372 = this + D.98371;
  D.98373 = D.98372->gobject_;
  D.98374 = MEM[(struct GTypeInstance *)D.98373].g_class;
  base = g_type_class_peek_parent (D.98374);
  {
    if (base != 0B) goto <D.98375>; else goto <D.98376>;
    <D.98375>:
    D.98377 = base->get_value;
    if (D.98377 != 0B) goto <D.98378>; else goto <D.98379>;
    <D.98378>:
    {
      const guchar * retval;

      D.98377 = base->get_value;
      D.98380 = Gio::TlsPassword::gobj (this);
      retval = D.98377 (D.98380, length);
      D.98381 = retval;
      return D.98381;
    }
    <D.98379>:
    <D.98376>:
  }
  D.98381 = 0B;
  return D.98381;
}


virtual Glib::ustring Gio::TlsPassword::get_default_warning_vfunc() const (const struct TlsPassword * const this)
{
  int (*__vtbl_ptr_type) () * D.98386;
  int (*__vtbl_ptr_type) () * D.98387;
  long int D.98388;
  sizetype D.98389;
  const struct ObjectBase * D.98390;
  struct GObject * D.98391;
  struct GTypeClass * D.98392;
  const gchar * (*<T11361>) (struct GTlsPassword *) D.98395;
  const struct GTlsPassword * D.98398;
  const gchar * D.98399;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.98386 = this->D.86112._vptr.Object;
  D.98387 = D.98386 + 18446744073709551592;
  D.98388 = MEM[(long int *)D.98387];
  D.98389 = (sizetype) D.98388;
  D.98390 = this + D.98389;
  D.98391 = D.98390->gobject_;
  D.98392 = MEM[(struct GTypeInstance *)D.98391].g_class;
  base = g_type_class_peek_parent (D.98392);
  {
    if (base != 0B) goto <D.98393>; else goto <D.98394>;
    <D.98393>:
    D.98395 = base->get_default_warning;
    if (D.98395 != 0B) goto <D.98396>; else goto <D.98397>;
    <D.98396>:
    {
      struct ustring retval;

      try
        {
          D.98395 = base->get_default_warning;
          D.98398 = Gio::TlsPassword::gobj (this);
          D.98399 = D.98395 (D.98398);
          retval = Glib::convert_const_gchar_ptr_to_ustring (D.98399); [return slot optimization]
          try
            {
              Glib::ustring::ustring (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::ustring::~ustring (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.98397>:
    <D.98394>:
  }
  Glib::ustring::ustring (<retval>);
  return <retval>;
}