Glib::RefPtr<Gio::DesktopAppInfo> Glib::wrap(GDesktopAppInfo*, bool) (struct GDesktopAppInfo * object, bool take_copy)
{
  struct DesktopAppInfo * iftmp.0;
  int D.99702;
  struct ObjectBase * D.99703;

  D.99702 = (int) take_copy;
  D.99703 = Glib::wrap_auto (object, D.99702);
  if (D.99703 == 0B) goto <D.99704>; else goto <D.99705>;
  <D.99704>:
  iftmp.0 = 0B;
  goto <D.99706>;
  <D.99705>:
  iftmp.0 = __dynamic_cast (D.99703, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio14DesktopAppInfoE, -1);
  <D.99706>:
  Glib::RefPtr<Gio::DesktopAppInfo>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::DesktopAppInfo_Class::init() (struct DesktopAppInfo_Class * const this)
{
  long unsigned int D.99709;
  long unsigned int D.99712;
  struct Class * D.99713;
  long unsigned int D.99714;
  const struct Class & D.99716;

  D.99709 = this->D.86609.gtype_;
  if (D.99709 == 0) goto <D.99710>; else goto <D.99711>;
  <D.99710>:
  this->D.86609.class_init_func_ = class_init_function;
  D.99712 = g_desktop_app_info_get_type ();
  D.99713 = &this->D.86609;
  Glib::Class::register_derived_type (D.99713, D.99712);
  D.99713 = &this->D.86609;
  D.99714 = Glib::Class::get_type (D.99713);
  Gio::AppInfo::add_interface (D.99714);
  goto <D.99715>;
  <D.99711>:
  <D.99715>:
  D.99716 = &this->D.86609;
  return D.99716;
}


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

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


static void Gio::DesktopAppInfo_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);
}


static Glib::ObjectBase* Gio::DesktopAppInfo_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.99721;
  struct ObjectBase * iftmp.1;
  void * D.97265;
  void * D.99723;
  int (*__vtbl_ptr_type) () * D.99726;
  int (*__vtbl_ptr_type) () * D.99727;
  long int D.99728;
  sizetype D.99729;

  D.97265 = operator new (56);
  try
    {
      Gio::DesktopAppInfo::DesktopAppInfo (D.97265, object);
    }
  catch
    {
      operator delete (D.97265);
    }
  D.99723 = D.97265;
  if (D.99723 != 0B) goto <D.99724>; else goto <D.99725>;
  <D.99724>:
  D.99726 = MEM[(struct DesktopAppInfo *)D.99723].D.86561._vptr.Object;
  D.99727 = D.99726 + 18446744073709551592;
  D.99728 = MEM[(long int *)D.99727];
  D.99729 = (sizetype) D.99728;
  iftmp.1 = D.99723 + D.99729;
  goto <D.99730>;
  <D.99725>:
  iftmp.1 = 0B;
  <D.99730>:
  D.99721 = iftmp.1;
  return D.99721;
}


GDesktopAppInfo* Gio::DesktopAppInfo::gobj_copy() (struct DesktopAppInfo * const this)
{
  int (*__vtbl_ptr_type) () * D.99735;
  int (*__vtbl_ptr_type) () * D.99736;
  long int D.99737;
  sizetype D.99738;
  struct ObjectBase * D.99739;
  int (*__vtbl_ptr_type) () * D.99740;
  int (*__vtbl_ptr_type) () * D.99741;
  int (*__vtbl_ptr_type) () D.99742;
  struct GDesktopAppInfo * D.99743;

  D.99735 = this->D.86561._vptr.Object;
  D.99736 = D.99735 + 18446744073709551592;
  D.99737 = MEM[(long int *)D.99736];
  D.99738 = (sizetype) D.99737;
  D.99739 = this + D.99738;
  D.99735 = this->D.86561._vptr.Object;
  D.99736 = D.99735 + 18446744073709551592;
  D.99737 = MEM[(long int *)D.99736];
  D.99738 = (sizetype) D.99737;
  D.99739 = this + D.99738;
  D.99740 = D.99739->_vptr.ObjectBase;
  D.99741 = D.99740 + 16;
  D.99742 = *D.99741;
  D.99735 = this->D.86561._vptr.Object;
  D.99736 = D.99735 + 18446744073709551592;
  D.99737 = MEM[(long int *)D.99736];
  D.99738 = (sizetype) D.99737;
  D.99739 = this + D.99738;
  OBJ_TYPE_REF(D.99742;(const struct ObjectBase)D.99739->2) (D.99739);
  D.99743 = Gio::DesktopAppInfo::gobj (this);
  return D.99743;
}


GDesktopAppInfo* Gio::DesktopAppInfo::gobj() (struct DesktopAppInfo * const this)
{
  struct GDesktopAppInfo * D.99745;
  int (*__vtbl_ptr_type) () * D.99746;
  int (*__vtbl_ptr_type) () * D.99747;
  long int D.99748;
  sizetype D.99749;
  struct ObjectBase * D.99750;

  D.99746 = this->D.86561._vptr.Object;
  D.99747 = D.99746 + 18446744073709551592;
  D.99748 = MEM[(long int *)D.99747];
  D.99749 = (sizetype) D.99748;
  D.99750 = this + D.99749;
  D.99745 = D.99750->gobject_;
  return D.99745;
}


Gio::DesktopAppInfo::DesktopAppInfo(const Glib::ConstructParams&) (struct DesktopAppInfo * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.99754;
  const void * * iftmp.2;
  struct ObjectBase * D.99762;
  const void * * iftmp.3;
  struct Object * D.99768;
  const void * * iftmp.4;
  struct AppInfo * D.99773;
  int (*__vtbl_ptr_type) () * iftmp.5;
  sizetype iftmp.6;
  int (*__vtbl_ptr_type) () * D.99781;
  int (*__vtbl_ptr_type) () * D.99782;
  long int D.99783;
  struct ObjectBase * D.99785;
  int (*__vtbl_ptr_type) () * iftmp.7;
  int (*__vtbl_ptr_type) () * iftmp.8;
  const void * * iftmp.9;
  const void * * iftmp.10;
  const void * * iftmp.11;

  if (0 != 0) goto <D.99752>; else goto <D.99753>;
  <D.99752>:
  D.99754 = &this->D.86566;
  sigc::trackable::trackable (D.99754);
  goto <D.99755>;
  <D.99753>:
  <D.99755>:
  try
    {
      if (0 != 0) goto <D.99756>; else goto <D.99757>;
      <D.99756>:
      if (0 == 0) goto <D.99759>; else goto <D.99760>;
      <D.99759>:
      iftmp.2 = __vtt_parm + 72;
      goto <D.99761>;
      <D.99760>:
      iftmp.2 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
      <D.99761>:
      D.99762 = &this->D.86565;
      Glib::ObjectBase::ObjectBase (D.99762, iftmp.2);
      goto <D.99763>;
      <D.99757>:
      <D.99763>:
      try
        {
          if (0 == 0) goto <D.99765>; else goto <D.99766>;
          <D.99765>:
          iftmp.3 = __vtt_parm + 8;
          goto <D.99767>;
          <D.99766>:
          iftmp.3 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
          <D.99767>:
          D.99768 = &this->D.86561;
          Glib::Object::Object (D.99768, iftmp.3, construct_params);
          try
            {
              if (0 == 0) goto <D.99770>; else goto <D.99771>;
              <D.99770>:
              iftmp.4 = __vtt_parm + 24;
              goto <D.99772>;
              <D.99771>:
              iftmp.4 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
              <D.99772>:
              D.99773 = &this->D.86562;
              Gio::AppInfo::AppInfo (D.99773, iftmp.4);
              try
                {
                  if (0 == 0) goto <D.99775>; else goto <D.99776>;
                  <D.99775>:
                  iftmp.5 = *__vtt_parm;
                  goto <D.99777>;
                  <D.99776>:
                  iftmp.5 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
                  <D.99777>:
                  this->D.86561._vptr.Object = iftmp.5;
                  if (0 == 0) goto <D.99779>; else goto <D.99780>;
                  <D.99779>:
                  D.99781 = this->D.86561._vptr.Object;
                  D.99782 = D.99781 + 18446744073709551592;
                  D.99783 = MEM[(long int *)D.99782];
                  iftmp.6 = (sizetype) D.99783;
                  goto <D.99784>;
                  <D.99780>:
                  iftmp.6 = 16;
                  <D.99784>:
                  D.99785 = this + iftmp.6;
                  if (0 == 0) goto <D.99787>; else goto <D.99788>;
                  <D.99787>:
                  iftmp.7 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.99789>;
                  <D.99788>:
                  iftmp.7 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
                  <D.99789>:
                  D.99785->_vptr.ObjectBase = iftmp.7;
                  if (0 == 0) goto <D.99791>; else goto <D.99792>;
                  <D.99791>:
                  iftmp.8 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.99793>;
                  <D.99792>:
                  iftmp.8 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
                  <D.99793>:
                  this->D.86562.D.86414._vptr.Interface = iftmp.8;
                }
              catch
                {
                  if (0 == 0) goto <D.99795>; else goto <D.99796>;
                  <D.99795>:
                  iftmp.9 = __vtt_parm + 24;
                  goto <D.99797>;
                  <D.99796>:
                  iftmp.9 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                  <D.99797>:
                  D.99773 = &this->D.86562;
                  Gio::AppInfo::~AppInfo (D.99773, iftmp.9);
                }
            }
          catch
            {
              if (0 == 0) goto <D.99799>; else goto <D.99800>;
              <D.99799>:
              iftmp.10 = __vtt_parm + 8;
              goto <D.99801>;
              <D.99800>:
              iftmp.10 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
              <D.99801>:
              D.99768 = &this->D.86561;
              Glib::Object::~Object (D.99768, iftmp.10);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99802>; else goto <D.99803>;
          <D.99802>:
          if (0 == 0) goto <D.99805>; else goto <D.99806>;
          <D.99805>:
          iftmp.11 = __vtt_parm + 72;
          goto <D.99807>;
          <D.99806>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
          <D.99807>:
          D.99762 = &this->D.86565;
          Glib::ObjectBase::~ObjectBase (D.99762, iftmp.11);
          goto <D.99808>;
          <D.99803>:
          <D.99808>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99809>; else goto <D.99810>;
      <D.99809>:
      D.99754 = &this->D.86566;
      sigc::trackable::~trackable (D.99754);
      goto <D.99811>;
      <D.99810>:
      <D.99811>:
    }
}


Gio::DesktopAppInfo::DesktopAppInfo(const Glib::ConstructParams&) (struct DesktopAppInfo * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.99817;
  const void * * iftmp.12;
  struct ObjectBase * D.99825;
  const void * * iftmp.13;
  struct Object * D.99831;
  const void * * iftmp.14;
  struct AppInfo * D.99836;
  int (*__vtbl_ptr_type) () * iftmp.15;
  const void * * D.99840;
  sizetype iftmp.16;
  int (*__vtbl_ptr_type) () * D.99845;
  int (*__vtbl_ptr_type) () * D.99846;
  long int D.99847;
  struct ObjectBase * D.99849;
  int (*__vtbl_ptr_type) () * iftmp.17;
  int (*__vtbl_ptr_type) () * iftmp.18;
  const void * * iftmp.19;
  const void * * iftmp.20;
  const void * * iftmp.21;

  if (1 != 0) goto <D.99815>; else goto <D.99816>;
  <D.99815>:
  D.99817 = &this->D.86566;
  sigc::trackable::trackable (D.99817);
  goto <D.99818>;
  <D.99816>:
  <D.99818>:
  try
    {
      if (1 != 0) goto <D.99819>; else goto <D.99820>;
      <D.99819>:
      if (1 == 0) goto <D.99822>; else goto <D.99823>;
      <D.99822>:
      iftmp.12 = 72B;
      goto <D.99824>;
      <D.99823>:
      iftmp.12 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
      <D.99824>:
      D.99825 = &this->D.86565;
      Glib::ObjectBase::ObjectBase (D.99825, iftmp.12);
      goto <D.99826>;
      <D.99820>:
      <D.99826>:
      try
        {
          if (1 == 0) goto <D.99828>; else goto <D.99829>;
          <D.99828>:
          iftmp.13 = 8B;
          goto <D.99830>;
          <D.99829>:
          iftmp.13 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
          <D.99830>:
          D.99831 = &this->D.86561;
          Glib::Object::Object (D.99831, iftmp.13, construct_params);
          try
            {
              if (1 == 0) goto <D.99833>; else goto <D.99834>;
              <D.99833>:
              iftmp.14 = 24B;
              goto <D.99835>;
              <D.99834>:
              iftmp.14 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
              <D.99835>:
              D.99836 = &this->D.86562;
              Gio::AppInfo::AppInfo (D.99836, iftmp.14);
              try
                {
                  if (1 == 0) goto <D.99838>; else goto <D.99839>;
                  <D.99838>:
                  D.99840 = 0B;
                  iftmp.15 = *D.99840;
                  goto <D.99841>;
                  <D.99839>:
                  iftmp.15 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
                  <D.99841>:
                  this->D.86561._vptr.Object = iftmp.15;
                  if (1 == 0) goto <D.99843>; else goto <D.99844>;
                  <D.99843>:
                  D.99845 = this->D.86561._vptr.Object;
                  D.99846 = D.99845 + 18446744073709551592;
                  D.99847 = MEM[(long int *)D.99846];
                  iftmp.16 = (sizetype) D.99847;
                  goto <D.99848>;
                  <D.99844>:
                  iftmp.16 = 16;
                  <D.99848>:
                  D.99849 = this + iftmp.16;
                  if (1 == 0) goto <D.99851>; else goto <D.99852>;
                  <D.99851>:
                  iftmp.17 = MEM[(const void * *)0B + 56B];
                  goto <D.99853>;
                  <D.99852>:
                  iftmp.17 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
                  <D.99853>:
                  D.99849->_vptr.ObjectBase = iftmp.17;
                  if (1 == 0) goto <D.99855>; else goto <D.99856>;
                  <D.99855>:
                  iftmp.18 = MEM[(const void * *)0B + 64B];
                  goto <D.99857>;
                  <D.99856>:
                  iftmp.18 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
                  <D.99857>:
                  this->D.86562.D.86414._vptr.Interface = iftmp.18;
                }
              catch
                {
                  if (1 == 0) goto <D.99859>; else goto <D.99860>;
                  <D.99859>:
                  iftmp.19 = 24B;
                  goto <D.99861>;
                  <D.99860>:
                  iftmp.19 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                  <D.99861>:
                  D.99836 = &this->D.86562;
                  Gio::AppInfo::~AppInfo (D.99836, iftmp.19);
                }
            }
          catch
            {
              if (1 == 0) goto <D.99863>; else goto <D.99864>;
              <D.99863>:
              iftmp.20 = 8B;
              goto <D.99865>;
              <D.99864>:
              iftmp.20 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
              <D.99865>:
              D.99831 = &this->D.86561;
              Glib::Object::~Object (D.99831, iftmp.20);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99866>; else goto <D.99867>;
          <D.99866>:
          if (1 == 0) goto <D.99869>; else goto <D.99870>;
          <D.99869>:
          iftmp.21 = 72B;
          goto <D.99871>;
          <D.99870>:
          iftmp.21 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
          <D.99871>:
          D.99825 = &this->D.86565;
          Glib::ObjectBase::~ObjectBase (D.99825, iftmp.21);
          goto <D.99872>;
          <D.99867>:
          <D.99872>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99873>; else goto <D.99874>;
      <D.99873>:
      D.99817 = &this->D.86566;
      sigc::trackable::~trackable (D.99817);
      goto <D.99875>;
      <D.99874>:
      <D.99875>:
    }
}


Gio::DesktopAppInfo::DesktopAppInfo(GDesktopAppInfo*) (struct DesktopAppInfo * const this, const void * * __vtt_parm, struct GDesktopAppInfo * castitem)
{
  struct trackable * D.99881;
  const void * * iftmp.22;
  struct ObjectBase * D.99889;
  const void * * iftmp.23;
  struct Object * D.99895;
  const void * * iftmp.24;
  struct AppInfo * D.99900;
  int (*__vtbl_ptr_type) () * iftmp.25;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.99908;
  int (*__vtbl_ptr_type) () * D.99909;
  long int D.99910;
  struct ObjectBase * D.99912;
  int (*__vtbl_ptr_type) () * iftmp.27;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * iftmp.29;
  const void * * iftmp.30;
  const void * * iftmp.31;

  if (0 != 0) goto <D.99879>; else goto <D.99880>;
  <D.99879>:
  D.99881 = &this->D.86566;
  sigc::trackable::trackable (D.99881);
  goto <D.99882>;
  <D.99880>:
  <D.99882>:
  try
    {
      if (0 != 0) goto <D.99883>; else goto <D.99884>;
      <D.99883>:
      if (0 == 0) goto <D.99886>; else goto <D.99887>;
      <D.99886>:
      iftmp.22 = __vtt_parm + 72;
      goto <D.99888>;
      <D.99887>:
      iftmp.22 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
      <D.99888>:
      D.99889 = &this->D.86565;
      Glib::ObjectBase::ObjectBase (D.99889, iftmp.22);
      goto <D.99890>;
      <D.99884>:
      <D.99890>:
      try
        {
          if (0 == 0) goto <D.99892>; else goto <D.99893>;
          <D.99892>:
          iftmp.23 = __vtt_parm + 8;
          goto <D.99894>;
          <D.99893>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
          <D.99894>:
          D.99895 = &this->D.86561;
          Glib::Object::Object (D.99895, iftmp.23, castitem);
          try
            {
              if (0 == 0) goto <D.99897>; else goto <D.99898>;
              <D.99897>:
              iftmp.24 = __vtt_parm + 24;
              goto <D.99899>;
              <D.99898>:
              iftmp.24 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
              <D.99899>:
              D.99900 = &this->D.86562;
              Gio::AppInfo::AppInfo (D.99900, iftmp.24);
              try
                {
                  if (0 == 0) goto <D.99902>; else goto <D.99903>;
                  <D.99902>:
                  iftmp.25 = *__vtt_parm;
                  goto <D.99904>;
                  <D.99903>:
                  iftmp.25 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
                  <D.99904>:
                  this->D.86561._vptr.Object = iftmp.25;
                  if (0 == 0) goto <D.99906>; else goto <D.99907>;
                  <D.99906>:
                  D.99908 = this->D.86561._vptr.Object;
                  D.99909 = D.99908 + 18446744073709551592;
                  D.99910 = MEM[(long int *)D.99909];
                  iftmp.26 = (sizetype) D.99910;
                  goto <D.99911>;
                  <D.99907>:
                  iftmp.26 = 16;
                  <D.99911>:
                  D.99912 = this + iftmp.26;
                  if (0 == 0) goto <D.99914>; else goto <D.99915>;
                  <D.99914>:
                  iftmp.27 = MEM[(const void * *)__vtt_parm + 56B];
                  goto <D.99916>;
                  <D.99915>:
                  iftmp.27 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
                  <D.99916>:
                  D.99912->_vptr.ObjectBase = iftmp.27;
                  if (0 == 0) goto <D.99918>; else goto <D.99919>;
                  <D.99918>:
                  iftmp.28 = MEM[(const void * *)__vtt_parm + 64B];
                  goto <D.99920>;
                  <D.99919>:
                  iftmp.28 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
                  <D.99920>:
                  this->D.86562.D.86414._vptr.Interface = iftmp.28;
                }
              catch
                {
                  if (0 == 0) goto <D.99922>; else goto <D.99923>;
                  <D.99922>:
                  iftmp.29 = __vtt_parm + 24;
                  goto <D.99924>;
                  <D.99923>:
                  iftmp.29 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                  <D.99924>:
                  D.99900 = &this->D.86562;
                  Gio::AppInfo::~AppInfo (D.99900, iftmp.29);
                }
            }
          catch
            {
              if (0 == 0) goto <D.99926>; else goto <D.99927>;
              <D.99926>:
              iftmp.30 = __vtt_parm + 8;
              goto <D.99928>;
              <D.99927>:
              iftmp.30 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
              <D.99928>:
              D.99895 = &this->D.86561;
              Glib::Object::~Object (D.99895, iftmp.30);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99929>; else goto <D.99930>;
          <D.99929>:
          if (0 == 0) goto <D.99932>; else goto <D.99933>;
          <D.99932>:
          iftmp.31 = __vtt_parm + 72;
          goto <D.99934>;
          <D.99933>:
          iftmp.31 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
          <D.99934>:
          D.99889 = &this->D.86565;
          Glib::ObjectBase::~ObjectBase (D.99889, iftmp.31);
          goto <D.99935>;
          <D.99930>:
          <D.99935>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99936>; else goto <D.99937>;
      <D.99936>:
      D.99881 = &this->D.86566;
      sigc::trackable::~trackable (D.99881);
      goto <D.99938>;
      <D.99937>:
      <D.99938>:
    }
}


Gio::DesktopAppInfo::DesktopAppInfo(GDesktopAppInfo*) (struct DesktopAppInfo * const this, struct GDesktopAppInfo * castitem)
{
  struct trackable * D.99944;
  const void * * iftmp.32;
  struct ObjectBase * D.99952;
  const void * * iftmp.33;
  struct Object * D.99958;
  const void * * iftmp.34;
  struct AppInfo * D.99963;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * D.99967;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.99972;
  int (*__vtbl_ptr_type) () * D.99973;
  long int D.99974;
  struct ObjectBase * D.99976;
  int (*__vtbl_ptr_type) () * iftmp.37;
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * iftmp.39;
  const void * * iftmp.40;
  const void * * iftmp.41;

  if (1 != 0) goto <D.99942>; else goto <D.99943>;
  <D.99942>:
  D.99944 = &this->D.86566;
  sigc::trackable::trackable (D.99944);
  goto <D.99945>;
  <D.99943>:
  <D.99945>:
  try
    {
      if (1 != 0) goto <D.99946>; else goto <D.99947>;
      <D.99946>:
      if (1 == 0) goto <D.99949>; else goto <D.99950>;
      <D.99949>:
      iftmp.32 = 72B;
      goto <D.99951>;
      <D.99950>:
      iftmp.32 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
      <D.99951>:
      D.99952 = &this->D.86565;
      Glib::ObjectBase::ObjectBase (D.99952, iftmp.32);
      goto <D.99953>;
      <D.99947>:
      <D.99953>:
      try
        {
          if (1 == 0) goto <D.99955>; else goto <D.99956>;
          <D.99955>:
          iftmp.33 = 8B;
          goto <D.99957>;
          <D.99956>:
          iftmp.33 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
          <D.99957>:
          D.99958 = &this->D.86561;
          Glib::Object::Object (D.99958, iftmp.33, castitem);
          try
            {
              if (1 == 0) goto <D.99960>; else goto <D.99961>;
              <D.99960>:
              iftmp.34 = 24B;
              goto <D.99962>;
              <D.99961>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
              <D.99962>:
              D.99963 = &this->D.86562;
              Gio::AppInfo::AppInfo (D.99963, iftmp.34);
              try
                {
                  if (1 == 0) goto <D.99965>; else goto <D.99966>;
                  <D.99965>:
                  D.99967 = 0B;
                  iftmp.35 = *D.99967;
                  goto <D.99968>;
                  <D.99966>:
                  iftmp.35 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
                  <D.99968>:
                  this->D.86561._vptr.Object = iftmp.35;
                  if (1 == 0) goto <D.99970>; else goto <D.99971>;
                  <D.99970>:
                  D.99972 = this->D.86561._vptr.Object;
                  D.99973 = D.99972 + 18446744073709551592;
                  D.99974 = MEM[(long int *)D.99973];
                  iftmp.36 = (sizetype) D.99974;
                  goto <D.99975>;
                  <D.99971>:
                  iftmp.36 = 16;
                  <D.99975>:
                  D.99976 = this + iftmp.36;
                  if (1 == 0) goto <D.99978>; else goto <D.99979>;
                  <D.99978>:
                  iftmp.37 = MEM[(const void * *)0B + 56B];
                  goto <D.99980>;
                  <D.99979>:
                  iftmp.37 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
                  <D.99980>:
                  D.99976->_vptr.ObjectBase = iftmp.37;
                  if (1 == 0) goto <D.99982>; else goto <D.99983>;
                  <D.99982>:
                  iftmp.38 = MEM[(const void * *)0B + 64B];
                  goto <D.99984>;
                  <D.99983>:
                  iftmp.38 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
                  <D.99984>:
                  this->D.86562.D.86414._vptr.Interface = iftmp.38;
                }
              catch
                {
                  if (1 == 0) goto <D.99986>; else goto <D.99987>;
                  <D.99986>:
                  iftmp.39 = 24B;
                  goto <D.99988>;
                  <D.99987>:
                  iftmp.39 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                  <D.99988>:
                  D.99963 = &this->D.86562;
                  Gio::AppInfo::~AppInfo (D.99963, iftmp.39);
                }
            }
          catch
            {
              if (1 == 0) goto <D.99990>; else goto <D.99991>;
              <D.99990>:
              iftmp.40 = 8B;
              goto <D.99992>;
              <D.99991>:
              iftmp.40 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
              <D.99992>:
              D.99958 = &this->D.86561;
              Glib::Object::~Object (D.99958, iftmp.40);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99993>; else goto <D.99994>;
          <D.99993>:
          if (1 == 0) goto <D.99996>; else goto <D.99997>;
          <D.99996>:
          iftmp.41 = 72B;
          goto <D.99998>;
          <D.99997>:
          iftmp.41 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
          <D.99998>:
          D.99952 = &this->D.86565;
          Glib::ObjectBase::~ObjectBase (D.99952, iftmp.41);
          goto <D.99999>;
          <D.99994>:
          <D.99999>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.100000>; else goto <D.100001>;
      <D.100000>:
      D.99944 = &this->D.86566;
      sigc::trackable::~trackable (D.99944);
      goto <D.100002>;
      <D.100001>:
      <D.100002>:
    }
}


Gio::DesktopAppInfo::~DesktopAppInfo() (struct DesktopAppInfo * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.42;
  sizetype iftmp.43;
  int (*__vtbl_ptr_type) () * D.100013;
  int (*__vtbl_ptr_type) () * D.100014;
  long int D.100015;
  struct ObjectBase * D.100017;
  int (*__vtbl_ptr_type) () * iftmp.44;
  int (*__vtbl_ptr_type) () * iftmp.45;
  const void * * iftmp.46;
  struct AppInfo * D.100030;
  const void * * iftmp.47;
  struct Object * D.100035;
  int D.100036;
  const void * * iftmp.48;
  struct ObjectBase * D.100043;
  struct trackable * D.100047;
  int D.100049;

  {
    if (0 == 0) goto <D.100007>; else goto <D.100008>;
    <D.100007>:
    iftmp.42 = *__vtt_parm;
    goto <D.100009>;
    <D.100008>:
    iftmp.42 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
    <D.100009>:
    this->D.86561._vptr.Object = iftmp.42;
    if (0 == 0) goto <D.100011>; else goto <D.100012>;
    <D.100011>:
    D.100013 = this->D.86561._vptr.Object;
    D.100014 = D.100013 + 18446744073709551592;
    D.100015 = MEM[(long int *)D.100014];
    iftmp.43 = (sizetype) D.100015;
    goto <D.100016>;
    <D.100012>:
    iftmp.43 = 16;
    <D.100016>:
    D.100017 = this + iftmp.43;
    if (0 == 0) goto <D.100019>; else goto <D.100020>;
    <D.100019>:
    iftmp.44 = MEM[(const void * *)__vtt_parm + 56B];
    goto <D.100021>;
    <D.100020>:
    iftmp.44 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
    <D.100021>:
    D.100017->_vptr.ObjectBase = iftmp.44;
    if (0 == 0) goto <D.100023>; else goto <D.100024>;
    <D.100023>:
    iftmp.45 = MEM[(const void * *)__vtt_parm + 64B];
    goto <D.100025>;
    <D.100024>:
    iftmp.45 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
    <D.100025>:
    this->D.86562.D.86414._vptr.Interface = iftmp.45;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (0 == 0) goto <D.100027>; else goto <D.100028>;
                        <D.100027>:
                        iftmp.46 = __vtt_parm + 24;
                        goto <D.100029>;
                        <D.100028>:
                        iftmp.46 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                        <D.100029>:
                        D.100030 = &this->D.86562;
                        Gio::AppInfo::~AppInfo (D.100030, iftmp.46);
                      }
                  }
                finally
                  {
                    if (0 == 0) goto <D.100032>; else goto <D.100033>;
                    <D.100032>:
                    iftmp.47 = __vtt_parm + 8;
                    goto <D.100034>;
                    <D.100033>:
                    iftmp.47 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
                    <D.100034>:
                    D.100035 = &this->D.86561;
                    Glib::Object::~Object (D.100035, iftmp.47);
                  }
              }
            finally
              {
                D.100036 = 0;
                if (D.100036 != 0) goto <D.100037>; else goto <D.100038>;
                <D.100037>:
                if (0 == 0) goto <D.100040>; else goto <D.100041>;
                <D.100040>:
                iftmp.48 = __vtt_parm + 72;
                goto <D.100042>;
                <D.100041>:
                iftmp.48 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
                <D.100042>:
                D.100043 = &this->D.86565;
                Glib::ObjectBase::~ObjectBase (D.100043, iftmp.48);
                goto <D.100044>;
                <D.100038>:
                <D.100044>:
              }
          }
        finally
          {
            D.100036 = 0;
            if (D.100036 != 0) goto <D.100045>; else goto <D.100046>;
            <D.100045>:
            D.100047 = &this->D.86566;
            sigc::trackable::~trackable (D.100047);
            goto <D.100048>;
            <D.100046>:
            <D.100048>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97293>:
  D.100049 = 0;
  if (D.100049 != 0) goto <D.100050>; else goto <D.100051>;
  <D.100050>:
  operator delete (this);
  goto <D.100052>;
  <D.100051>:
  <D.100052>:
}


virtual Gio::DesktopAppInfo::~DesktopAppInfo() (struct DesktopAppInfo * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.49;
  const void * * D.100072;
  sizetype iftmp.50;
  int (*__vtbl_ptr_type) () * D.100077;
  int (*__vtbl_ptr_type) () * D.100078;
  long int D.100079;
  struct ObjectBase * D.100081;
  int (*__vtbl_ptr_type) () * iftmp.51;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * iftmp.53;
  struct AppInfo * D.100094;
  const void * * iftmp.54;
  struct Object * D.100099;
  int D.100100;
  const void * * iftmp.55;
  struct ObjectBase * D.100107;
  struct trackable * D.100111;
  int D.100113;

  {
    if (2 == 0) goto <D.100070>; else goto <D.100071>;
    <D.100070>:
    D.100072 = 0B;
    iftmp.49 = *D.100072;
    goto <D.100073>;
    <D.100071>:
    iftmp.49 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 32B];
    <D.100073>:
    this->D.86561._vptr.Object = iftmp.49;
    if (2 == 0) goto <D.100075>; else goto <D.100076>;
    <D.100075>:
    D.100077 = this->D.86561._vptr.Object;
    D.100078 = D.100077 + 18446744073709551592;
    D.100079 = MEM[(long int *)D.100078];
    iftmp.50 = (sizetype) D.100079;
    goto <D.100080>;
    <D.100076>:
    iftmp.50 = 16;
    <D.100080>:
    D.100081 = this + iftmp.50;
    if (2 == 0) goto <D.100083>; else goto <D.100084>;
    <D.100083>:
    iftmp.51 = MEM[(const void * *)0B + 56B];
    goto <D.100085>;
    <D.100084>:
    iftmp.51 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 160B];
    <D.100085>:
    D.100081->_vptr.ObjectBase = iftmp.51;
    if (2 == 0) goto <D.100087>; else goto <D.100088>;
    <D.100087>:
    iftmp.52 = MEM[(const void * *)0B + 64B];
    goto <D.100089>;
    <D.100088>:
    iftmp.52 = &MEM[(void *)&_ZTVN3Gio14DesktopAppInfoE + 80B];
    <D.100089>:
    this->D.86562.D.86414._vptr.Interface = iftmp.52;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {

                      }
                    finally
                      {
                        if (2 == 0) goto <D.100091>; else goto <D.100092>;
                        <D.100091>:
                        iftmp.53 = 24B;
                        goto <D.100093>;
                        <D.100092>:
                        iftmp.53 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 24B];
                        <D.100093>:
                        D.100094 = &this->D.86562;
                        Gio::AppInfo::~AppInfo (D.100094, iftmp.53);
                      }
                  }
                finally
                  {
                    if (2 == 0) goto <D.100096>; else goto <D.100097>;
                    <D.100096>:
                    iftmp.54 = 8B;
                    goto <D.100098>;
                    <D.100097>:
                    iftmp.54 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 8B];
                    <D.100098>:
                    D.100099 = &this->D.86561;
                    Glib::Object::~Object (D.100099, iftmp.54);
                  }
              }
            finally
              {
                D.100100 = 2;
                if (D.100100 != 0) goto <D.100101>; else goto <D.100102>;
                <D.100101>:
                if (2 == 0) goto <D.100104>; else goto <D.100105>;
                <D.100104>:
                iftmp.55 = 72B;
                goto <D.100106>;
                <D.100105>:
                iftmp.55 = &MEM[(void *)&_ZTTN3Gio14DesktopAppInfoE + 72B];
                <D.100106>:
                D.100107 = &this->D.86565;
                Glib::ObjectBase::~ObjectBase (D.100107, iftmp.55);
                goto <D.100108>;
                <D.100102>:
                <D.100108>:
              }
          }
        finally
          {
            D.100100 = 2;
            if (D.100100 != 0) goto <D.100109>; else goto <D.100110>;
            <D.100109>:
            D.100111 = &this->D.86566;
            sigc::trackable::~trackable (D.100111);
            goto <D.100112>;
            <D.100110>:
            <D.100112>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97296>:
  D.100113 = 0;
  if (D.100113 != 0) goto <D.100114>; else goto <D.100115>;
  <D.100114>:
  operator delete (this);
  goto <D.100116>;
  <D.100115>:
  <D.100116>:
}


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


static GType Gio::DesktopAppInfo::get_type() ()
{
  GType D.100133;
  const struct Class & D.100134;

  D.100134 = Gio::DesktopAppInfo_Class::init (&desktopappinfo_class_);
  D.100133 = Glib::Class::get_type (D.100134);
  return D.100133;
}


static GType Gio::DesktopAppInfo::get_base_type() ()
{
  GType D.100137;

  D.100137 = g_desktop_app_info_get_type ();
  return D.100137;
}


static Glib::RefPtr<Gio::DesktopAppInfo> Gio::DesktopAppInfo::create(const string&) (const struct string & desktop_id)
{
  const char * D.100141;
  struct GDesktopAppInfo * D.100142;

  D.100141 = std::basic_string<char>::c_str (desktop_id);
  D.100142 = g_desktop_app_info_new (D.100141);
  *<retval> = Glib::wrap (D.100142, 0); [return slot optimization]
  return <retval>;
}


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

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


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

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


static Glib::RefPtr<Gio::DesktopAppInfo> Gio::DesktopAppInfo::create_from_keyfile(Glib::KeyFile&) (struct KeyFile & key_file)
{
  struct GKeyFile * D.100152;
  struct GDesktopAppInfo * D.100153;

  D.100152 = Glib::KeyFile::gobj (key_file);
  D.100153 = g_desktop_app_info_new_from_keyfile (D.100152);
  *<retval> = Glib::wrap (D.100153, 0); [return slot optimization]
  return <retval>;
}


GKeyFile* Glib::KeyFile::gobj() (struct KeyFile * const this)
{
  struct GKeyFile * D.100156;

  D.100156 = this->gobject_;
  return D.100156;
}


static Glib::RefPtr<Gio::DesktopAppInfo> Gio::DesktopAppInfo::create_from_filename(const string&) (const struct string & filename)
{
  const char * D.100159;
  struct GDesktopAppInfo * D.100160;

  D.100159 = std::basic_string<char>::c_str (filename);
  D.100160 = g_desktop_app_info_new_from_filename (D.100159);
  *<retval> = Glib::wrap (D.100160, 0); [return slot optimization]
  return <retval>;
}


std::string Gio::DesktopAppInfo::get_filename() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100165;
  const char * D.100166;

  D.100165 = Gio::DesktopAppInfo::gobj (this);
  D.100166 = g_desktop_app_info_get_filename (D.100165);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.100166); [return slot optimization]
  return <retval>;
}


const GDesktopAppInfo* Gio::DesktopAppInfo::gobj() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100169;
  int (*__vtbl_ptr_type) () * D.100170;
  int (*__vtbl_ptr_type) () * D.100171;
  long int D.100172;
  sizetype D.100173;
  const struct ObjectBase * D.100174;

  D.100170 = this->D.86561._vptr.Object;
  D.100171 = D.100170 + 18446744073709551592;
  D.100172 = MEM[(long int *)D.100171];
  D.100173 = (sizetype) D.100172;
  D.100174 = this + D.100173;
  D.100169 = D.100174->gobject_;
  return D.100169;
}


std::string Glib::convert_const_gchar_ptr_to_stdstring(const char*) (const char * str)
{
  struct allocator D.78923;
  bool cleanup.56;
  struct string * D.100182;

  cleanup.56 = 0;
  try
    {
      if (str != 0B) goto <D.100177>; else goto <D.100178>;
      <D.100177>:
      std::allocator<char>::allocator (&D.78923);
      cleanup.56 = 1;
      D.100182 = <retval>;
      std::basic_string<char>::basic_string (D.100182, str, &D.78923);
      goto <D.100183>;
      <D.100178>:
      D.100182 = <retval>;
      std::basic_string<char>::basic_string (D.100182);
      <D.100183>:
      return <retval>;
    }
  finally
    {
      if (cleanup.56 != 0) goto <D.100180>; else goto <D.100181>;
      <D.100180>:
      std::allocator<char>::~allocator (&D.78923);
      D.78923 = {CLOBBER};
      <D.100181>:
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100189 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100189);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.100190;

  try
    {
      {

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


std::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator D.98584;
  struct _Rep & D.100191;
  char * D.100192;
  struct _Alloc_hider * D.100193;

  std::allocator<char>::allocator (&D.98584);
  try
    {
      D.100191 = std::basic_string<char>::_S_empty_rep ();
      D.100192 = std::basic_string<char>::_Rep::_M_refdata (D.100191);
      D.100193 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.100193, D.100192, &D.98584);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.98584);
      D.98584 = {CLOBBER};
    }
  try
    {

    }
  catch
    {
      D.100193 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.100193);
    }
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.100196;

  D.100196 = std::basic_string<char>::_Rep::_S_empty_rep ();
  return D.100196;
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.100199;
  void * __p;

  __p = &_S_empty_rep_storage;
  D.100199 = __p;
  return D.100199;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_refdata() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  char * D.100201;
  void * D.100202;

  try
    {
      D.100201 = this + 24;
      return D.100201;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100202 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100202);
          
        }
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::_Alloc_hider::_Alloc_hider(_CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Alloc_hider * const this, char * __dat, const struct allocator & __a)
{
  std::allocator<char>::allocator (this, __a);
  try
    {
      this->_M_p = __dat;
    }
  catch
    {
      std::allocator<char>::~allocator (this);
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100204 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100204);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = char] (struct new_allocator * const this, const struct new_allocator & D.14983)
{
  void * D.100205;

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<char>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.98559>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100206 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100206);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.100207;

  try
    {
      {
        try
          {

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


bool Gio::DesktopAppInfo::is_hidden() const (const struct DesktopAppInfo * const this)
{
  bool D.100208;
  const struct GDesktopAppInfo * D.100209;
  int D.100210;

  D.100209 = Gio::DesktopAppInfo::gobj (this);
  D.100210 = g_desktop_app_info_get_is_hidden (D.100209);
  D.100208 = D.100210 != 0;
  return D.100208;
}


static void Gio::DesktopAppInfo::set_desktop_env(const string&) (const struct string & desktop_env)
{
  const char * D.100213;

  D.100213 = std::basic_string<char>::c_str (desktop_env);
  g_desktop_app_info_set_desktop_env (D.100213);
}


std::vector<Glib::ustring> Gio::DesktopAppInfo::get_keywords() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100216;
  const char * const * D.100217;

  D.100216 = Gio::DesktopAppInfo::gobj (this);
  D.100217 = g_desktop_app_info_get_keywords (D.100216);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (D.100217, 0); [return slot optimization]
  return <retval>;
}


static Glib::ArrayHandler<T, Tr>::VectorType Glib::ArrayHandler<T, Tr>::array_to_vector(const CType*, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::ustring>; Glib::ArrayHandler<T, Tr>::CType = const char*] (const char * const * array, OwnershipType ownership)
{
  long unsigned int D.100221;

  D.100221 = Glib::Container_Helpers::compute_array_size2<const char*> (array);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (array, D.100221, ownership); [return slot optimization]
  return <retval>;
}


std::size_t Glib::Container_Helpers::compute_array_size2(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.100225;
  size_t D.100226;
  long int pend.57;
  long int array.58;
  long int D.100229;
  long int D.100230;

  {
    if (array != 0B) goto <D.100223>; else goto <D.100224>;
    <D.100223>:
    {
      const char * const * pend;

      pend = array;
      goto <D.98919>;
      <D.98920>:
      pend = pend + 8;
      <D.98919>:
      D.100225 = *pend;
      if (D.100225 != 0B) goto <D.98920>; else goto <D.98918>;
      <D.98918>:
      pend.57 = (long int) pend;
      array.58 = (long int) array;
      D.100229 = pend.57 - array.58;
      D.100230 = D.100229 /[ex] 8;
      D.100226 = (size_t) D.100230;
      return D.100226;
    }
    <D.100224>:
  }
  D.100226 = 0;
  return D.100226;
}


static Glib::ArrayHandler<T, Tr>::VectorType Glib::ArrayHandler<T, Tr>::array_to_vector(const CType*, std::size_t, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::ustring>; Glib::ArrayHandler<T, Tr>::CType = const char*; std::size_t = long unsigned int] (const char * const * array, size_t array_size, OwnershipType ownership)
{
  struct allocator_type D.99056;
  struct ArrayIteratorType D.99039;
  long unsigned int D.100235;
  const char * const * D.100236;
  struct ArrayIteratorType D.99038;

  {
    if (array != 0B) goto <D.100233>; else goto <D.100234>;
    <D.100233>:
    {
      struct ArrayKeeperType keeper;

      try
        {
          Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayKeeper (&keeper, array, array_size, ownership);
          try
            {
              std::allocator<Glib::ustring>::allocator (&D.99056);
              try
                {
                  D.100235 = array_size * 8;
                  D.100236 = array + D.100235;
                  Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.99039, D.100236);
                  try
                    {
                      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.99038, array);
                      try
                        {
                          std::vector<Glib::ustring>::vector<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (<retval>, D.99038, D.99039, &D.99056);
                          return <retval>;
                        }
                      finally
                        {
                          D.99038 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.99039 = {CLOBBER};
                    }
                }
              finally
                {
                  std::allocator<Glib::ustring>::~allocator (&D.99056);
                  D.99056 = {CLOBBER};
                }
            }
          finally
            {
              Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::~ArrayKeeper (&keeper);
            }
        }
      finally
        {
          keeper = {CLOBBER};
        }
    }
    <D.100234>:
  }
  std::vector<Glib::ustring>::vector (<retval>);
  return <retval>;
}


Glib::Container_Helpers::ArrayKeeper<Tr>::ArrayKeeper(const CType*, std::size_t, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayKeeper<Tr>::CType = const char*; std::size_t = long unsigned int] (struct ArrayKeeper * const this, const char * const * array, size_t array_size, OwnershipType ownership)
{
  this->array_ = array;
  this->array_size_ = array_size;
  this->ownership_ = ownership;
}


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

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

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


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

  try
    {
      {

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


Glib::Container_Helpers::ArrayIterator<Tr>::ArrayIterator(const CType*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::CType = const char*] (struct ArrayIterator * const this, const char * const * pos)
{
  this->pos_ = pos;
}


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.100250;
  struct _Integral D.99317;
  struct __false_type D.100251;

  D.100250 = &this->D.98088;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_base (D.100250, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<Glib::ustring>::_M_initialize_dispatch<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (this, __first, __last, D.100251);
          }
        finally
          {
            D.99317 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.100250 = &this->D.98088;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.100250);
    }
}


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

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

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


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


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

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

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


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = Glib::ustring] (struct new_allocator * const this, const struct new_allocator & D.97428)
{
  void * D.100256;

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct __false_type D.99271)
{
  struct forward_iterator_tag D.99516;
  struct _IterCategory D.99488;
  struct _IterCategory * D.100257;
  struct forward_iterator_tag D.100258;
  typedef struct _IterCategory _IterCategory;

  try
    {
      D.100257 = &D.99488;
      std::vector<Glib::ustring>::_M_range_initialize<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (this, __first, __last, D.100258);
    }
  finally
    {
      D.99488 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct forward_iterator_tag D.99493)
{
  long int D.100260;
  struct _Vector_base * D.100261;
  struct ustring * D.100262;
  struct ustring * D.100263;
  long unsigned int D.100264;
  struct ustring * D.100265;
  struct _Tp_alloc_type & D.100266;
  struct ustring * D.100267;
  const size_type __n;

  D.100260 = std::distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (__first, __last);
  __n = (const size_type) D.100260;
  D.100261 = &this->D.98088;
  D.100262 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_allocate (D.100261, __n);
  this->D.98088._M_impl._M_start = D.100262;
  D.100263 = this->D.98088._M_impl._M_start;
  D.100264 = __n * 8;
  D.100265 = D.100263 + D.100264;
  this->D.98088._M_impl._M_end_of_storage = D.100265;
  D.100261 = &this->D.98088;
  D.100266 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.100261);
  D.100263 = this->D.98088._M_impl._M_start;
  D.100267 = std::__uninitialized_copy_a<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*, Glib::ustring> (__first, __last, D.100263, D.100266);
  this->D.98088._M_impl._M_finish = D.100267;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last)
{
  difference_type D.100271;
  struct iterator_category D.99630;
  struct random_access_iterator_tag D.100272;

  std::__iterator_category<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (&__first);
  try
    {
      D.100271 = std::__distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (__first, __last, D.100272);
      return D.100271;
    }
  finally
    {
      D.99630 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::iterator_category = std::random_access_iterator_tag] (const struct ArrayIterator & D.99629)
{
  struct iterator_category D.100277;

  return D.100277;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_RandomAccessIterator, _RandomAccessIterator, std::random_access_iterator_tag) [with _RandomAccessIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last, struct random_access_iterator_tag D.99634)
{
  difference_type D.100279;

  D.100279 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator- (&__last, &__first);
  return D.100279;
}


Glib::Container_Helpers::ArrayIterator<Tr>::difference_type Glib::Container_Helpers::ArrayIterator<Tr>::operator-(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::difference_type = long int] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  difference_type D.100281;
  const char * const * D.100282;
  long int D.100283;
  const char * const * D.100284;
  long int D.100285;
  long int D.100286;

  D.100282 = this->pos_;
  D.100283 = (long int) D.100282;
  D.100284 = rhs->pos_;
  D.100285 = (long int) D.100284;
  D.100286 = D.100283 - D.100285;
  D.100281 = D.100286 /[ex] 8;
  return D.100281;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::_Vector_base<_Tp, _Alloc>::pointer = Glib::ustring*; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct ustring * D.100288;
  struct ustring * iftmp.59;
  struct _Vector_impl * D.100292;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.100290>; else goto <D.100291>;
  <D.100290>:
  D.100292 = &this->_M_impl;
  iftmp.59 = __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::allocate (D.100292, __n);
  goto <D.100293>;
  <D.100291>:
  iftmp.59 = 0B;
  <D.100293>:
  D.100288 = iftmp.59;
  return D.100288;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::ustring; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::ustring*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.97401)
{
  bool retval.60;
  long unsigned int D.100300;
  struct ustring * D.100303;
  long unsigned int D.100304;

  D.100300 = __gnu_cxx::new_allocator<Glib::ustring>::max_size (this);
  retval.60 = D.100300 < __n;
  if (retval.60 != 0) goto <D.100301>; else goto <D.100302>;
  <D.100301>:
  std::__throw_bad_alloc ();
  <D.100302>:
  D.100304 = __n * 8;
  D.100303 = operator new (D.100304);
  return D.100303;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = Glib::ustring; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.100307;
  void * D.100308;

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


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

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


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*; _Tp = Glib::ustring] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result, struct allocator & D.99600)
{
  struct ustring * D.100312;

  D.100312 = std::uninitialized_copy<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*> (__first, __last, __result);
  return D.100312;
}


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

  __assignable = 1;
  D.100315 = std::__uninitialized_copy<false>::__uninit_copy<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*> (__first, __last, __result);
  return D.100315;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*; bool _TrivialValueTypes = false] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result)
{
  struct value_type D.99682;
  struct ustring * D.100318;
  bool retval.61;
  struct ustring * D.100320;
  void * D.100321;
  struct ustring * __cur;

  __cur = __result;
  try
    {
      goto <D.99686>;
      <D.99685>:
      D.99682 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator* (&__first); [return slot optimization]
      try
        {
          D.100318 = std::__addressof<Glib::ustring> (__cur);
          std::_Construct<Glib::ustring, Glib::ustring> (D.100318, &D.99682);
        }
      finally
        {
          Glib::ustring::~ustring (&D.99682);
          D.99682 = {CLOBBER};
        }
      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator++ (&__first);
      __cur = __cur + 8;
      <D.99686>:
      retval.61 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator!= (&__first, &__last);
      if (retval.61 != 0) goto <D.99685>; else goto <D.99683>;
      <D.99683>:
      D.100320 = __cur;
      return D.100320;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.100321 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.100321);
              std::_Destroy<Glib::ustring*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::Container_Helpers::ArrayIterator<Tr>::value_type Glib::Container_Helpers::ArrayIterator<Tr>::operator*() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::value_type = Glib::ustring] (const struct ArrayIterator * const this)
{
  const char * const * D.100328;
  const char * D.100329;

  D.100328 = this->pos_;
  D.100329 = *D.100328;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_cpp_type (D.100329); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<Glib::ustring>::CppType Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_cpp_type(Glib::Container_Helpers::TypeTraits<Glib::ustring>::CType) (const char * str)
{
  struct CppType * D.100334;

  if (str != 0B) goto <D.100332>; else goto <D.100333>;
  <D.100332>:
  D.100334 = <retval>;
  Glib::ustring::ustring (D.100334, str);
  goto <D.100335>;
  <D.100333>:
  D.100334 = <retval>;
  Glib::ustring::ustring (D.100334);
  <D.100335>:
  return <retval>;
}


_Tp* std::__addressof(_Tp&) [with _Tp = Glib::ustring] (struct ustring & __r)
{
  struct ustring * D.100337;

  D.100337 = __r;
  return D.100337;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::ustring; _T2 = Glib::ustring] (struct ustring * __p, const struct ustring & __value)
{
  void * D.99625;
  void * D.99626;
  struct ustring * iftmp.62;

  D.99625 = __p;
  D.99626 = operator new (8, D.99625);
  if (D.99626 != 0B) goto <D.100340>; else goto <D.100341>;
  <D.100340>:
  try
    {
      Glib::ustring::ustring (D.99626, __value);
    }
  catch
    {
      operator delete (D.99626, D.99625);
    }
  iftmp.62 = D.99626;
  goto <D.100342>;
  <D.100341>:
  iftmp.62 = D.99626;
  <D.100342>:
}


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

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


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

  try
    {

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


Glib::Container_Helpers::ArrayIterator<Tr>& Glib::Container_Helpers::ArrayIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayIterator * const this)
{
  const char * const * D.100348;
  const char * const * D.100349;
  struct ArrayIterator & D.100350;

  D.100348 = this->pos_;
  D.100349 = D.100348 + 8;
  this->pos_ = D.100349;
  D.100350 = this;
  return D.100350;
}


bool Glib::Container_Helpers::ArrayIterator<Tr>::operator!=(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  bool D.100352;
  const char * const * D.100353;
  const char * const * D.100354;

  D.100353 = this->pos_;
  D.100354 = rhs->pos_;
  D.100352 = D.100353 != D.100354;
  return D.100352;
}


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

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


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

  goto <D.99534>;
  <D.99533>:
  D.100356 = std::__addressof<Glib::ustring> (__first);
  std::_Destroy<Glib::ustring> (D.100356);
  __first = __first + 8;
  <D.99534>:
  if (__first != __last) goto <D.99533>; else goto <D.99531>;
  <D.99531>:
}


void std::_Destroy(_Tp*) [with _Tp = Glib::ustring] (struct ustring * __pointer)
{
  Glib::ustring::~ustring (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct _Vector_base * const this)
{
  struct ustring * D.100357;
  long int D.100358;
  struct ustring * D.100359;
  long int D.100360;
  long int D.100361;
  long int D.100362;
  long unsigned int D.100363;
  struct _Vector_impl * D.100364;

  {
    try
      {
        try
          {
            D.100357 = this->_M_impl._M_end_of_storage;
            D.100358 = (long int) D.100357;
            D.100359 = this->_M_impl._M_start;
            D.100360 = (long int) D.100359;
            D.100361 = D.100358 - D.100360;
            D.100362 = D.100361 /[ex] 8;
            D.100363 = (long unsigned int) D.100362;
            D.100359 = this->_M_impl._M_start;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_deallocate (this, D.100359, D.100363);
          }
        finally
          {
            D.100364 = &this->_M_impl;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.100364);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99070>:
}


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

  if (__p != 0B) goto <D.100367>; else goto <D.100368>;
  <D.100367>:
  D.100369 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::deallocate (D.100369, __p, __n);
  goto <D.100370>;
  <D.100368>:
  <D.100370>:
}


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::ustring>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::ustring*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct ustring * __p, size_type __n)
{
  __gnu_cxx::new_allocator<Glib::ustring>::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::ustring; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::ustring*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct ustring * __p, size_type D.97405)
{
  operator delete (__p);
}


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

          }
        finally
          {
            std::allocator<Glib::ustring>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99065>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<Glib::ustring>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.99255>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100371 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100371);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


std::vector<_Tp, _Alloc>::vector() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this)
{
  struct _Vector_base * D.100373;

  D.100373 = &this->D.98088;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_base (D.100373);
  try
    {

    }
  catch
    {
      D.100373 = &this->D.98088;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.100373);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct _Vector_base * const this)
{
  struct _Vector_impl * D.100374;

  D.100374 = &this->_M_impl;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::_Vector_impl (D.100374);
  try
    {

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


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


Glib::Container_Helpers::ArrayKeeper<Tr>::~ArrayKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayKeeper * const this)
{
  const char * * D.100375;
  OwnershipType D.100378;
  long unsigned int D.100383;
  long unsigned int D.100384;
  const char * D.100385;

  {
    try
      {
        {
          {
            D.100375 = this->array_;
            if (D.100375 != 0B) goto <D.100376>; else goto <D.100377>;
            <D.100376>:
            D.100378 = this->ownership_;
            if (D.100378 != 0) goto <D.100379>; else goto <D.100380>;
            <D.100379>:
            {
              {
                D.100378 = this->ownership_;
                if (D.100378 != 1) goto <D.100381>; else goto <D.100382>;
                <D.100381>:
                {
                  const char * const * const array_end;

                  D.100375 = this->array_;
                  D.100383 = this->array_size_;
                  D.100384 = D.100383 * 8;
                  array_end = D.100375 + D.100384;
                  {
                    const char * const * p;

                    p = this->array_;
                    goto <D.99239>;
                    <D.99240>:
                    D.100385 = *p;
                    Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type (D.100385);
                    p = p + 8;
                    <D.99239>:
                    if (p != array_end) goto <D.99240>; else goto <D.99241>;
                    <D.99241>:
                  }
                }
                goto <D.100386>;
                <D.100382>:
                <D.100386>:
              }
              D.100375 = this->array_;
              g_free (D.100375);
            }
            goto <D.100387>;
            <D.100380>:
            <D.100387>:
            <D.100377>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99242>:
}


static void Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type(Glib::Container_Helpers::TypeTraits<Glib::ustring>::CType) (const char * str)
{
  g_free (str);
}


std::string Gio::DesktopAppInfo::get_startup_wm_class() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100390;
  const char * D.100391;

  D.100390 = Gio::DesktopAppInfo::gobj (this);
  D.100391 = g_desktop_app_info_get_startup_wm_class (D.100390);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.100391); [return slot optimization]
  return <retval>;
}


bool Gio::DesktopAppInfo::get_nodisplay() const (const struct DesktopAppInfo * const this)
{
  bool D.100394;
  const struct GDesktopAppInfo * D.100395;
  int D.100396;

  D.100395 = Gio::DesktopAppInfo::gobj (this);
  D.100396 = g_desktop_app_info_get_nodisplay (D.100395);
  D.100394 = D.100396 != 0;
  return D.100394;
}


bool Gio::DesktopAppInfo::get_show_in(const string&) const (const struct DesktopAppInfo * const this, const struct string & desktop_env)
{
  bool D.100399;
  const char * D.100400;
  const struct GDesktopAppInfo * D.100401;
  int D.100402;

  D.100400 = std::basic_string<char>::c_str (desktop_env);
  D.100401 = Gio::DesktopAppInfo::gobj (this);
  D.100402 = g_desktop_app_info_get_show_in (D.100401, D.100400);
  D.100399 = D.100402 != 0;
  return D.100399;
}


std::string Gio::DesktopAppInfo::get_generic_name() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100407;
  const char * D.100408;

  D.100407 = Gio::DesktopAppInfo::gobj (this);
  D.100408 = g_desktop_app_info_get_generic_name (D.100407);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.100408); [return slot optimization]
  return <retval>;
}


std::string Gio::DesktopAppInfo::get_categories() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100412;
  const char * D.100413;

  D.100412 = Gio::DesktopAppInfo::gobj (this);
  D.100413 = g_desktop_app_info_get_categories (D.100412);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.100413); [return slot optimization]
  return <retval>;
}


bool Gio::DesktopAppInfo::has_key(const Glib::ustring&) const (const struct DesktopAppInfo * const this, const struct ustring & key)
{
  bool D.100416;
  const char * D.100417;
  const struct GDesktopAppInfo * D.100418;
  int D.100419;

  D.100417 = Glib::ustring::c_str (key);
  D.100418 = Gio::DesktopAppInfo::gobj (this);
  D.100419 = g_desktop_app_info_has_key (D.100418, D.100417);
  D.100416 = D.100419 != 0;
  return D.100416;
}


Glib::ustring Gio::DesktopAppInfo::get_string(const Glib::ustring&) (struct DesktopAppInfo * const this, const struct ustring & key)
{
  const char * D.100424;
  struct GDesktopAppInfo * D.100425;
  char * D.100426;

  D.100424 = Glib::ustring::c_str (key);
  D.100425 = Gio::DesktopAppInfo::gobj (this);
  D.100426 = g_desktop_app_info_get_string (D.100425, D.100424);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.100426); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.63;
  char * D.100436;
  struct ustring * D.100437;

  cleanup.63 = 0;
  try
    {
      if (str != 0B) goto <D.100431>; else goto <D.100432>;
      <D.100431>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.63 = 1;
      D.100436 = Glib::ScopedPtr<char>::get (&D.78974);
      D.100437 = <retval>;
      Glib::ustring::ustring (D.100437, D.100436);
      goto <D.100438>;
      <D.100432>:
      D.100437 = <retval>;
      Glib::ustring::ustring (D.100437);
      <D.100438>:
      return <retval>;
    }
  finally
    {
      if (cleanup.63 != 0) goto <D.100434>; else goto <D.100435>;
      <D.100434>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.100435>:
    }
}


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

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


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

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


bool Gio::DesktopAppInfo::get_boolean(const Glib::ustring&) const (const struct DesktopAppInfo * const this, const struct ustring & key)
{
  bool D.100448;
  const char * D.100449;
  const struct GDesktopAppInfo * D.100450;
  int D.100451;

  D.100449 = Glib::ustring::c_str (key);
  D.100450 = Gio::DesktopAppInfo::gobj (this);
  D.100451 = g_desktop_app_info_get_boolean (D.100450, D.100449);
  D.100448 = D.100451 != 0;
  return D.100448;
}


std::vector<Glib::ustring> Gio::DesktopAppInfo::list_actions() const (const struct DesktopAppInfo * const this)
{
  const struct GDesktopAppInfo * D.100456;
  const gchar * const * D.100457;

  D.100456 = Gio::DesktopAppInfo::gobj (this);
  D.100457 = g_desktop_app_info_list_actions (D.100456);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (D.100457, 0); [return slot optimization]
  return <retval>;
}


void Gio::DesktopAppInfo::launch_action(const Glib::ustring&, const Glib::RefPtr<Gio::AppLaunchContext>&) (struct DesktopAppInfo * const this, const struct ustring & action_name, const struct RefPtr & launch_context)
{
  struct BaseObjectType * D.100460;
  const char * D.100461;
  struct GDesktopAppInfo * D.100462;

  D.100460 = Glib::unwrap<Gio::AppLaunchContext> (launch_context);
  D.100461 = Glib::ustring::c_str (action_name);
  D.100462 = Gio::DesktopAppInfo::gobj (this);
  g_desktop_app_info_launch_action (D.100462, D.100461, D.100460);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::AppLaunchContext; typename T::BaseObjectType = _GAppLaunchContext] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.100465;
  struct BaseObjectType * iftmp.64;
  bool D.100467;
  struct AppLaunchContext * D.100470;

  D.100467 = Glib::RefPtr<Gio::AppLaunchContext>::operator bool (ptr);
  if (D.100467 != 0) goto <D.100468>; else goto <D.100469>;
  <D.100468>:
  D.100470 = Glib::RefPtr<Gio::AppLaunchContext>::operator-> (ptr);
  iftmp.64 = Gio::AppLaunchContext::gobj (D.100470);
  goto <D.100471>;
  <D.100469>:
  iftmp.64 = 0B;
  <D.100471>:
  D.100465 = iftmp.64;
  return D.100465;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::AppLaunchContext] (const struct RefPtr * const this)
{
  bool D.100473;
  struct AppLaunchContext * D.100474;

  D.100474 = this->pCppObject_;
  D.100473 = D.100474 != 0B;
  return D.100473;
}


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

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


GAppLaunchContext* Gio::AppLaunchContext::gobj() (struct AppLaunchContext * const this)
{
  struct GAppLaunchContext * D.100478;
  int (*__vtbl_ptr_type) () * D.100479;
  int (*__vtbl_ptr_type) () * D.100480;
  long int D.100481;
  sizetype D.100482;
  struct ObjectBase * D.100483;

  D.100479 = this->D.86162._vptr.Object;
  D.100480 = D.100479 + 18446744073709551592;
  D.100481 = MEM[(long int *)D.100480];
  D.100482 = (sizetype) D.100481;
  D.100483 = this + D.100482;
  D.100478 = D.100483->gobject_;
  return D.100478;
}


void Gio::DesktopAppInfo::launch_action(const Glib::ustring&) (struct DesktopAppInfo * const this, const struct ustring & action_name)
{
  const char * D.100485;
  struct GDesktopAppInfo * D.100486;

  D.100485 = Glib::ustring::c_str (action_name);
  D.100486 = Gio::DesktopAppInfo::gobj (this);
  g_desktop_app_info_launch_action (D.100486, D.100485, 0B);
}


Glib::ustring Gio::DesktopAppInfo::get_action_name(const Glib::ustring&) const (const struct DesktopAppInfo * const this, const struct ustring & action_name)
{
  const char * D.100489;
  const struct GDesktopAppInfo * D.100490;
  gchar * D.100491;

  D.100489 = Glib::ustring::c_str (action_name);
  D.100490 = Gio::DesktopAppInfo::gobj (this);
  D.100491 = g_desktop_app_info_get_action_name (D.100490, D.100489);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.100491); [return slot optimization]
  return <retval>;
}