Gio::Error::Error(Gio::Error::Code, const Glib::ustring&) (struct Error * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.0;
  unsigned int D.97321;
  struct Error * D.97322;

  error_code.0 = (int) error_code;
  D.97321 = g_io_error_quark ();
  D.97322 = &this->D.86001;
  Glib::Error::Error (D.97322, D.97321, error_code.0, error_message);
  try
    {
      this->D.86001.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio5ErrorE + 16B];
    }
  catch
    {
      D.97322 = &this->D.86001;
      Glib::Error::~Error (D.97322);
    }
}


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


Gio::Error::~Error() (struct Error * const this)
{
  struct Error * D.97324;
  int D.97325;

  {
    this->D.86001.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio5ErrorE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.97324 = &this->D.86001;
            Glib::Error::~Error (D.97324);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97310>:
  D.97325 = 0;
  if (D.97325 != 0) goto <D.97326>; else goto <D.97327>;
  <D.97326>:
  operator delete (this);
  goto <D.97328>;
  <D.97327>:
  <D.97328>:
}


Gio::Error::Error(GError*) (struct Error * const this, struct GError * gobject)
{
  struct Error * D.97329;

  D.97329 = &this->D.86001;
  Glib::Error::Error (D.97329, gobject, 0);
  try
    {
      this->D.86001.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio5ErrorE + 16B];
    }
  catch
    {
      D.97329 = &this->D.86001;
      Glib::Error::~Error (D.97329);
    }
}


Gio::Error::Code Gio::Error::code() const (const struct Error * const this)
{
  Code D.97330;
  const struct Error * D.97331;
  int D.97332;

  D.97331 = &this->D.86001;
  D.97332 = Glib::Error::code (D.97331);
  D.97330 = (Code) D.97332;
  return D.97330;
}


static void Gio::Error::throw_func(GError*) (struct GError * gobject)
{
  void * D.96574;

  D.96574 = __cxa_allocate_exception (16);
  try
    {
      Gio::Error::Error (D.96574, gobject);
    }
  catch
    {
      __cxa_free_exception (D.96574);
    }
  __cxa_throw (D.96574, &_ZTIN3Gio5ErrorE, __comp_dtor );
}


Gio::ResolverError::ResolverError(Gio::ResolverError::Code, const Glib::ustring&) (struct ResolverError * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.1;
  unsigned int D.97338;
  struct Error * D.97339;

  error_code.1 = (int) error_code;
  D.97338 = g_resolver_error_quark ();
  D.97339 = &this->D.86049;
  Glib::Error::Error (D.97339, D.97338, error_code.1, error_message);
  try
    {
      this->D.86049.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio13ResolverErrorE + 16B];
    }
  catch
    {
      D.97339 = &this->D.86049;
      Glib::Error::~Error (D.97339);
    }
}


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


Gio::ResolverError::~ResolverError() (struct ResolverError * const this)
{
  struct Error * D.97341;
  int D.97342;

  {
    this->D.86049.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio13ResolverErrorE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.97341 = &this->D.86049;
            Glib::Error::~Error (D.97341);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97301>:
  D.97342 = 0;
  if (D.97342 != 0) goto <D.97343>; else goto <D.97344>;
  <D.97343>:
  operator delete (this);
  goto <D.97345>;
  <D.97344>:
  <D.97345>:
}


Gio::ResolverError::ResolverError(GError*) (struct ResolverError * const this, struct GError * gobject)
{
  struct Error * D.97346;

  D.97346 = &this->D.86049;
  Glib::Error::Error (D.97346, gobject, 0);
  try
    {
      this->D.86049.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio13ResolverErrorE + 16B];
    }
  catch
    {
      D.97346 = &this->D.86049;
      Glib::Error::~Error (D.97346);
    }
}


Gio::ResolverError::Code Gio::ResolverError::code() const (const struct ResolverError * const this)
{
  Code D.97347;
  const struct Error * D.97348;
  int D.97349;

  D.97348 = &this->D.86049;
  D.97349 = Glib::Error::code (D.97348);
  D.97347 = (Code) D.97349;
  return D.97347;
}


static void Gio::ResolverError::throw_func(GError*) (struct GError * gobject)
{
  void * D.96609;

  D.96609 = __cxa_allocate_exception (16);
  try
    {
      Gio::ResolverError::ResolverError (D.96609, gobject);
    }
  catch
    {
      __cxa_free_exception (D.96609);
    }
  __cxa_throw (D.96609, &_ZTIN3Gio13ResolverErrorE, __comp_dtor );
}


Gio::TlsError::TlsError(Gio::TlsError::Code, const Glib::ustring&) (struct TlsError * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.2;
  unsigned int D.97354;
  struct Error * D.97355;

  error_code.2 = (int) error_code;
  D.97354 = g_tls_error_quark ();
  D.97355 = &this->D.86101;
  Glib::Error::Error (D.97355, D.97354, error_code.2, error_message);
  try
    {
      this->D.86101.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio8TlsErrorE + 16B];
    }
  catch
    {
      D.97355 = &this->D.86101;
      Glib::Error::~Error (D.97355);
    }
}


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


Gio::TlsError::~TlsError() (struct TlsError * const this)
{
  struct Error * D.97357;
  int D.97358;

  {
    this->D.86101.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio8TlsErrorE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.97357 = &this->D.86101;
            Glib::Error::~Error (D.97357);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97292>:
  D.97358 = 0;
  if (D.97358 != 0) goto <D.97359>; else goto <D.97360>;
  <D.97359>:
  operator delete (this);
  goto <D.97361>;
  <D.97360>:
  <D.97361>:
}


Gio::TlsError::TlsError(GError*) (struct TlsError * const this, struct GError * gobject)
{
  struct Error * D.97362;

  D.97362 = &this->D.86101;
  Glib::Error::Error (D.97362, gobject, 0);
  try
    {
      this->D.86101.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN3Gio8TlsErrorE + 16B];
    }
  catch
    {
      D.97362 = &this->D.86101;
      Glib::Error::~Error (D.97362);
    }
}


Gio::TlsError::Code Gio::TlsError::code() const (const struct TlsError * const this)
{
  Code D.97363;
  const struct Error * D.97364;
  int D.97365;

  D.97364 = &this->D.86101;
  D.97365 = Glib::Error::code (D.97364);
  D.97363 = (Code) D.97365;
  return D.97363;
}


static void Gio::TlsError::throw_func(GError*) (struct GError * gobject)
{
  void * D.96643;

  D.96643 = __cxa_allocate_exception (16);
  try
    {
      Gio::TlsError::TlsError (D.96643, gobject);
    }
  catch
    {
      __cxa_free_exception (D.96643);
    }
  __cxa_throw (D.96643, &_ZTIN3Gio8TlsErrorE, __comp_dtor );
}