void Gio::ApplicationCommandLine::print(const Glib::ustring&) (struct ApplicationCommandLine * const this, const struct ustring & message)
{
  const char * D.105222;
  struct GApplicationCommandLine * D.105223;

  D.105222 = Glib::ustring::c_str (message);
  D.105223 = Gio::ApplicationCommandLine::gobj (this);
  g_application_command_line_print (D.105223, "%s", D.105222);
}


GApplicationCommandLine* Gio::ApplicationCommandLine::gobj() (struct ApplicationCommandLine * const this)
{
  struct GApplicationCommandLine * D.105225;
  int (*__vtbl_ptr_type) () * D.105226;
  int (*__vtbl_ptr_type) () * D.105227;
  long int D.105228;
  sizetype D.105229;
  struct ObjectBase * D.105230;

  D.105226 = this->D.102007._vptr.Object;
  D.105227 = D.105226 + 18446744073709551592;
  D.105228 = MEM[(long int *)D.105227];
  D.105229 = (sizetype) D.105228;
  D.105230 = this + D.105229;
  D.105225 = D.105230->gobject_;
  return D.105225;
}


void Gio::ApplicationCommandLine::printerr(const Glib::ustring&) (struct ApplicationCommandLine * const this, const struct ustring & message)
{
  const char * D.105232;
  struct GApplicationCommandLine * D.105233;

  D.105232 = Glib::ustring::c_str (message);
  D.105233 = Gio::ApplicationCommandLine::gobj (this);
  g_application_command_line_printerr (D.105233, "%s", D.105232);
}


Glib::RefPtr<Gio::ApplicationCommandLine> Glib::wrap(GApplicationCommandLine*, bool) (struct GApplicationCommandLine * object, bool take_copy)
{
  struct ApplicationCommandLine * iftmp.0;
  int D.105237;
  struct ObjectBase * D.105238;

  D.105237 = (int) take_copy;
  D.105238 = Glib::wrap_auto (object, D.105237);
  if (D.105238 == 0B) goto <D.105239>; else goto <D.105240>;
  <D.105239>:
  iftmp.0 = 0B;
  goto <D.105241>;
  <D.105240>:
  iftmp.0 = __dynamic_cast (D.105238, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio22ApplicationCommandLineE, -1);
  <D.105241>:
  Glib::RefPtr<Gio::ApplicationCommandLine>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::ApplicationCommandLine_Class::init() (struct ApplicationCommandLine_Class * const this)
{
  long unsigned int D.105244;
  long unsigned int D.105247;
  struct Class * D.105248;
  const struct Class & D.105250;

  D.105244 = this->D.102050.gtype_;
  if (D.105244 == 0) goto <D.105245>; else goto <D.105246>;
  <D.105245>:
  this->D.102050.class_init_func_ = class_init_function;
  D.105247 = g_application_command_line_get_type ();
  D.105248 = &this->D.102050;
  Glib::Class::register_derived_type (D.105248, D.105247);
  goto <D.105249>;
  <D.105246>:
  <D.105249>:
  D.105250 = &this->D.102050;
  return D.105250;
}


static void Gio::ApplicationCommandLine_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::ApplicationCommandLine_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.105253;
  struct ObjectBase * iftmp.1;
  void * D.102213;
  void * D.105255;
  int (*__vtbl_ptr_type) () * D.105258;
  int (*__vtbl_ptr_type) () * D.105259;
  long int D.105260;
  sizetype D.105261;

  D.102213 = operator new (48);
  try
    {
      Gio::ApplicationCommandLine::ApplicationCommandLine (D.102213, object);
    }
  catch
    {
      operator delete (D.102213);
    }
  D.105255 = D.102213;
  if (D.105255 != 0B) goto <D.105256>; else goto <D.105257>;
  <D.105256>:
  D.105258 = MEM[(struct ApplicationCommandLine *)D.105255].D.102007._vptr.Object;
  D.105259 = D.105258 + 18446744073709551592;
  D.105260 = MEM[(long int *)D.105259];
  D.105261 = (sizetype) D.105260;
  iftmp.1 = D.105255 + D.105261;
  goto <D.105262>;
  <D.105257>:
  iftmp.1 = 0B;
  <D.105262>:
  D.105253 = iftmp.1;
  return D.105253;
}


GApplicationCommandLine* Gio::ApplicationCommandLine::gobj_copy() (struct ApplicationCommandLine * const this)
{
  int (*__vtbl_ptr_type) () * D.105267;
  int (*__vtbl_ptr_type) () * D.105268;
  long int D.105269;
  sizetype D.105270;
  struct ObjectBase * D.105271;
  int (*__vtbl_ptr_type) () * D.105272;
  int (*__vtbl_ptr_type) () * D.105273;
  int (*__vtbl_ptr_type) () D.105274;
  struct GApplicationCommandLine * D.105275;

  D.105267 = this->D.102007._vptr.Object;
  D.105268 = D.105267 + 18446744073709551592;
  D.105269 = MEM[(long int *)D.105268];
  D.105270 = (sizetype) D.105269;
  D.105271 = this + D.105270;
  D.105267 = this->D.102007._vptr.Object;
  D.105268 = D.105267 + 18446744073709551592;
  D.105269 = MEM[(long int *)D.105268];
  D.105270 = (sizetype) D.105269;
  D.105271 = this + D.105270;
  D.105272 = D.105271->_vptr.ObjectBase;
  D.105273 = D.105272 + 16;
  D.105274 = *D.105273;
  D.105267 = this->D.102007._vptr.Object;
  D.105268 = D.105267 + 18446744073709551592;
  D.105269 = MEM[(long int *)D.105268];
  D.105270 = (sizetype) D.105269;
  D.105271 = this + D.105270;
  OBJ_TYPE_REF(D.105274;(const struct ObjectBase)D.105271->2) (D.105271);
  D.105275 = Gio::ApplicationCommandLine::gobj (this);
  return D.105275;
}


Gio::ApplicationCommandLine::ApplicationCommandLine(const Glib::ConstructParams&) (struct ApplicationCommandLine * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.105279;
  const void * * iftmp.2;
  struct ObjectBase * D.105287;
  const void * * iftmp.3;
  struct Object * D.105293;
  int (*__vtbl_ptr_type) () * iftmp.4;
  sizetype iftmp.5;
  int (*__vtbl_ptr_type) () * D.105301;
  int (*__vtbl_ptr_type) () * D.105302;
  long int D.105303;
  struct ObjectBase * D.105305;
  int (*__vtbl_ptr_type) () * iftmp.6;
  const void * * iftmp.7;
  const void * * iftmp.8;

  if (0 != 0) goto <D.105277>; else goto <D.105278>;
  <D.105277>:
  D.105279 = &this->D.102010;
  sigc::trackable::trackable (D.105279);
  goto <D.105280>;
  <D.105278>:
  <D.105280>:
  try
    {
      if (0 != 0) goto <D.105281>; else goto <D.105282>;
      <D.105281>:
      if (0 == 0) goto <D.105284>; else goto <D.105285>;
      <D.105284>:
      iftmp.2 = __vtt_parm + 32;
      goto <D.105286>;
      <D.105285>:
      iftmp.2 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105286>:
      D.105287 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105287, iftmp.2);
      goto <D.105288>;
      <D.105282>:
      <D.105288>:
      try
        {
          if (0 == 0) goto <D.105290>; else goto <D.105291>;
          <D.105290>:
          iftmp.3 = __vtt_parm + 8;
          goto <D.105292>;
          <D.105291>:
          iftmp.3 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
          <D.105292>:
          D.105293 = &this->D.102007;
          Glib::Object::Object (D.105293, iftmp.3, construct_params);
          try
            {
              if (0 == 0) goto <D.105295>; else goto <D.105296>;
              <D.105295>:
              iftmp.4 = *__vtt_parm;
              goto <D.105297>;
              <D.105296>:
              iftmp.4 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105297>:
              this->D.102007._vptr.Object = iftmp.4;
              if (0 == 0) goto <D.105299>; else goto <D.105300>;
              <D.105299>:
              D.105301 = this->D.102007._vptr.Object;
              D.105302 = D.105301 + 18446744073709551592;
              D.105303 = MEM[(long int *)D.105302];
              iftmp.5 = (sizetype) D.105303;
              goto <D.105304>;
              <D.105300>:
              iftmp.5 = 8;
              <D.105304>:
              D.105305 = this + iftmp.5;
              if (0 == 0) goto <D.105307>; else goto <D.105308>;
              <D.105307>:
              iftmp.6 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105309>;
              <D.105308>:
              iftmp.6 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105309>:
              D.105305->_vptr.ObjectBase = iftmp.6;
            }
          catch
            {
              if (0 == 0) goto <D.105311>; else goto <D.105312>;
              <D.105311>:
              iftmp.7 = __vtt_parm + 8;
              goto <D.105313>;
              <D.105312>:
              iftmp.7 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105313>:
              D.105293 = &this->D.102007;
              Glib::Object::~Object (D.105293, iftmp.7);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105314>; else goto <D.105315>;
          <D.105314>:
          if (0 == 0) goto <D.105317>; else goto <D.105318>;
          <D.105317>:
          iftmp.8 = __vtt_parm + 32;
          goto <D.105319>;
          <D.105318>:
          iftmp.8 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105319>:
          D.105287 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105287, iftmp.8);
          goto <D.105320>;
          <D.105315>:
          <D.105320>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105321>; else goto <D.105322>;
      <D.105321>:
      D.105279 = &this->D.102010;
      sigc::trackable::~trackable (D.105279);
      goto <D.105323>;
      <D.105322>:
      <D.105323>:
    }
}


Gio::ApplicationCommandLine::ApplicationCommandLine(const Glib::ConstructParams&) (struct ApplicationCommandLine * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.105328;
  const void * * iftmp.9;
  struct ObjectBase * D.105336;
  const void * * iftmp.10;
  struct Object * D.105342;
  int (*__vtbl_ptr_type) () * iftmp.11;
  const void * * D.105346;
  sizetype iftmp.12;
  int (*__vtbl_ptr_type) () * D.105351;
  int (*__vtbl_ptr_type) () * D.105352;
  long int D.105353;
  struct ObjectBase * D.105355;
  int (*__vtbl_ptr_type) () * iftmp.13;
  const void * * iftmp.14;
  const void * * iftmp.15;

  if (1 != 0) goto <D.105326>; else goto <D.105327>;
  <D.105326>:
  D.105328 = &this->D.102010;
  sigc::trackable::trackable (D.105328);
  goto <D.105329>;
  <D.105327>:
  <D.105329>:
  try
    {
      if (1 != 0) goto <D.105330>; else goto <D.105331>;
      <D.105330>:
      if (1 == 0) goto <D.105333>; else goto <D.105334>;
      <D.105333>:
      iftmp.9 = 32B;
      goto <D.105335>;
      <D.105334>:
      iftmp.9 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105335>:
      D.105336 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105336, iftmp.9);
      goto <D.105337>;
      <D.105331>:
      <D.105337>:
      try
        {
          if (1 == 0) goto <D.105339>; else goto <D.105340>;
          <D.105339>:
          iftmp.10 = 8B;
          goto <D.105341>;
          <D.105340>:
          iftmp.10 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
          <D.105341>:
          D.105342 = &this->D.102007;
          Glib::Object::Object (D.105342, iftmp.10, construct_params);
          try
            {
              if (1 == 0) goto <D.105344>; else goto <D.105345>;
              <D.105344>:
              D.105346 = 0B;
              iftmp.11 = *D.105346;
              goto <D.105347>;
              <D.105345>:
              iftmp.11 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105347>:
              this->D.102007._vptr.Object = iftmp.11;
              if (1 == 0) goto <D.105349>; else goto <D.105350>;
              <D.105349>:
              D.105351 = this->D.102007._vptr.Object;
              D.105352 = D.105351 + 18446744073709551592;
              D.105353 = MEM[(long int *)D.105352];
              iftmp.12 = (sizetype) D.105353;
              goto <D.105354>;
              <D.105350>:
              iftmp.12 = 8;
              <D.105354>:
              D.105355 = this + iftmp.12;
              if (1 == 0) goto <D.105357>; else goto <D.105358>;
              <D.105357>:
              iftmp.13 = MEM[(const void * *)0B + 24B];
              goto <D.105359>;
              <D.105358>:
              iftmp.13 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105359>:
              D.105355->_vptr.ObjectBase = iftmp.13;
            }
          catch
            {
              if (1 == 0) goto <D.105361>; else goto <D.105362>;
              <D.105361>:
              iftmp.14 = 8B;
              goto <D.105363>;
              <D.105362>:
              iftmp.14 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105363>:
              D.105342 = &this->D.102007;
              Glib::Object::~Object (D.105342, iftmp.14);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105364>; else goto <D.105365>;
          <D.105364>:
          if (1 == 0) goto <D.105367>; else goto <D.105368>;
          <D.105367>:
          iftmp.15 = 32B;
          goto <D.105369>;
          <D.105368>:
          iftmp.15 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105369>:
          D.105336 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105336, iftmp.15);
          goto <D.105370>;
          <D.105365>:
          <D.105370>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105371>; else goto <D.105372>;
      <D.105371>:
      D.105328 = &this->D.102010;
      sigc::trackable::~trackable (D.105328);
      goto <D.105373>;
      <D.105372>:
      <D.105373>:
    }
}


Gio::ApplicationCommandLine::ApplicationCommandLine(GApplicationCommandLine*) (struct ApplicationCommandLine * const this, const void * * __vtt_parm, struct GApplicationCommandLine * castitem)
{
  struct trackable * D.105378;
  const void * * iftmp.16;
  struct ObjectBase * D.105386;
  const void * * iftmp.17;
  struct Object * D.105392;
  int (*__vtbl_ptr_type) () * iftmp.18;
  sizetype iftmp.19;
  int (*__vtbl_ptr_type) () * D.105400;
  int (*__vtbl_ptr_type) () * D.105401;
  long int D.105402;
  struct ObjectBase * D.105404;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * iftmp.21;
  const void * * iftmp.22;

  if (0 != 0) goto <D.105376>; else goto <D.105377>;
  <D.105376>:
  D.105378 = &this->D.102010;
  sigc::trackable::trackable (D.105378);
  goto <D.105379>;
  <D.105377>:
  <D.105379>:
  try
    {
      if (0 != 0) goto <D.105380>; else goto <D.105381>;
      <D.105380>:
      if (0 == 0) goto <D.105383>; else goto <D.105384>;
      <D.105383>:
      iftmp.16 = __vtt_parm + 32;
      goto <D.105385>;
      <D.105384>:
      iftmp.16 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105385>:
      D.105386 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105386, iftmp.16);
      goto <D.105387>;
      <D.105381>:
      <D.105387>:
      try
        {
          if (0 == 0) goto <D.105389>; else goto <D.105390>;
          <D.105389>:
          iftmp.17 = __vtt_parm + 8;
          goto <D.105391>;
          <D.105390>:
          iftmp.17 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
          <D.105391>:
          D.105392 = &this->D.102007;
          Glib::Object::Object (D.105392, iftmp.17, castitem);
          try
            {
              if (0 == 0) goto <D.105394>; else goto <D.105395>;
              <D.105394>:
              iftmp.18 = *__vtt_parm;
              goto <D.105396>;
              <D.105395>:
              iftmp.18 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105396>:
              this->D.102007._vptr.Object = iftmp.18;
              if (0 == 0) goto <D.105398>; else goto <D.105399>;
              <D.105398>:
              D.105400 = this->D.102007._vptr.Object;
              D.105401 = D.105400 + 18446744073709551592;
              D.105402 = MEM[(long int *)D.105401];
              iftmp.19 = (sizetype) D.105402;
              goto <D.105403>;
              <D.105399>:
              iftmp.19 = 8;
              <D.105403>:
              D.105404 = this + iftmp.19;
              if (0 == 0) goto <D.105406>; else goto <D.105407>;
              <D.105406>:
              iftmp.20 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105408>;
              <D.105407>:
              iftmp.20 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105408>:
              D.105404->_vptr.ObjectBase = iftmp.20;
            }
          catch
            {
              if (0 == 0) goto <D.105410>; else goto <D.105411>;
              <D.105410>:
              iftmp.21 = __vtt_parm + 8;
              goto <D.105412>;
              <D.105411>:
              iftmp.21 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105412>:
              D.105392 = &this->D.102007;
              Glib::Object::~Object (D.105392, iftmp.21);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105413>; else goto <D.105414>;
          <D.105413>:
          if (0 == 0) goto <D.105416>; else goto <D.105417>;
          <D.105416>:
          iftmp.22 = __vtt_parm + 32;
          goto <D.105418>;
          <D.105417>:
          iftmp.22 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105418>:
          D.105386 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105386, iftmp.22);
          goto <D.105419>;
          <D.105414>:
          <D.105419>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105420>; else goto <D.105421>;
      <D.105420>:
      D.105378 = &this->D.102010;
      sigc::trackable::~trackable (D.105378);
      goto <D.105422>;
      <D.105421>:
      <D.105422>:
    }
}


Gio::ApplicationCommandLine::ApplicationCommandLine(GApplicationCommandLine*) (struct ApplicationCommandLine * const this, struct GApplicationCommandLine * castitem)
{
  struct trackable * D.105427;
  const void * * iftmp.23;
  struct ObjectBase * D.105435;
  const void * * iftmp.24;
  struct Object * D.105441;
  int (*__vtbl_ptr_type) () * iftmp.25;
  const void * * D.105445;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.105450;
  int (*__vtbl_ptr_type) () * D.105451;
  long int D.105452;
  struct ObjectBase * D.105454;
  int (*__vtbl_ptr_type) () * iftmp.27;
  const void * * iftmp.28;
  const void * * iftmp.29;

  if (1 != 0) goto <D.105425>; else goto <D.105426>;
  <D.105425>:
  D.105427 = &this->D.102010;
  sigc::trackable::trackable (D.105427);
  goto <D.105428>;
  <D.105426>:
  <D.105428>:
  try
    {
      if (1 != 0) goto <D.105429>; else goto <D.105430>;
      <D.105429>:
      if (1 == 0) goto <D.105432>; else goto <D.105433>;
      <D.105432>:
      iftmp.23 = 32B;
      goto <D.105434>;
      <D.105433>:
      iftmp.23 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105434>:
      D.105435 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105435, iftmp.23);
      goto <D.105436>;
      <D.105430>:
      <D.105436>:
      try
        {
          if (1 == 0) goto <D.105438>; else goto <D.105439>;
          <D.105438>:
          iftmp.24 = 8B;
          goto <D.105440>;
          <D.105439>:
          iftmp.24 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
          <D.105440>:
          D.105441 = &this->D.102007;
          Glib::Object::Object (D.105441, iftmp.24, castitem);
          try
            {
              if (1 == 0) goto <D.105443>; else goto <D.105444>;
              <D.105443>:
              D.105445 = 0B;
              iftmp.25 = *D.105445;
              goto <D.105446>;
              <D.105444>:
              iftmp.25 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105446>:
              this->D.102007._vptr.Object = iftmp.25;
              if (1 == 0) goto <D.105448>; else goto <D.105449>;
              <D.105448>:
              D.105450 = this->D.102007._vptr.Object;
              D.105451 = D.105450 + 18446744073709551592;
              D.105452 = MEM[(long int *)D.105451];
              iftmp.26 = (sizetype) D.105452;
              goto <D.105453>;
              <D.105449>:
              iftmp.26 = 8;
              <D.105453>:
              D.105454 = this + iftmp.26;
              if (1 == 0) goto <D.105456>; else goto <D.105457>;
              <D.105456>:
              iftmp.27 = MEM[(const void * *)0B + 24B];
              goto <D.105458>;
              <D.105457>:
              iftmp.27 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105458>:
              D.105454->_vptr.ObjectBase = iftmp.27;
            }
          catch
            {
              if (1 == 0) goto <D.105460>; else goto <D.105461>;
              <D.105460>:
              iftmp.28 = 8B;
              goto <D.105462>;
              <D.105461>:
              iftmp.28 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105462>:
              D.105441 = &this->D.102007;
              Glib::Object::~Object (D.105441, iftmp.28);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105463>; else goto <D.105464>;
          <D.105463>:
          if (1 == 0) goto <D.105466>; else goto <D.105467>;
          <D.105466>:
          iftmp.29 = 32B;
          goto <D.105468>;
          <D.105467>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105468>:
          D.105435 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105435, iftmp.29);
          goto <D.105469>;
          <D.105464>:
          <D.105469>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105470>; else goto <D.105471>;
      <D.105470>:
      D.105427 = &this->D.102010;
      sigc::trackable::~trackable (D.105427);
      goto <D.105472>;
      <D.105471>:
      <D.105472>:
    }
}


Gio::ApplicationCommandLine::~ApplicationCommandLine() (struct ApplicationCommandLine * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.30;
  sizetype iftmp.31;
  int (*__vtbl_ptr_type) () * D.105482;
  int (*__vtbl_ptr_type) () * D.105483;
  long int D.105484;
  struct ObjectBase * D.105486;
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * iftmp.33;
  struct Object * D.105495;
  int D.105496;
  const void * * iftmp.34;
  struct ObjectBase * D.105503;
  struct trackable * D.105507;
  int D.105509;

  {
    if (0 == 0) goto <D.105476>; else goto <D.105477>;
    <D.105476>:
    iftmp.30 = *__vtt_parm;
    goto <D.105478>;
    <D.105477>:
    iftmp.30 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
    <D.105478>:
    this->D.102007._vptr.Object = iftmp.30;
    if (0 == 0) goto <D.105480>; else goto <D.105481>;
    <D.105480>:
    D.105482 = this->D.102007._vptr.Object;
    D.105483 = D.105482 + 18446744073709551592;
    D.105484 = MEM[(long int *)D.105483];
    iftmp.31 = (sizetype) D.105484;
    goto <D.105485>;
    <D.105481>:
    iftmp.31 = 8;
    <D.105485>:
    D.105486 = this + iftmp.31;
    if (0 == 0) goto <D.105488>; else goto <D.105489>;
    <D.105488>:
    iftmp.32 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.105490>;
    <D.105489>:
    iftmp.32 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
    <D.105490>:
    D.105486->_vptr.ObjectBase = iftmp.32;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.105492>; else goto <D.105493>;
                    <D.105492>:
                    iftmp.33 = __vtt_parm + 8;
                    goto <D.105494>;
                    <D.105493>:
                    iftmp.33 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
                    <D.105494>:
                    D.105495 = &this->D.102007;
                    Glib::Object::~Object (D.105495, iftmp.33);
                  }
              }
            finally
              {
                D.105496 = 0;
                if (D.105496 != 0) goto <D.105497>; else goto <D.105498>;
                <D.105497>:
                if (0 == 0) goto <D.105500>; else goto <D.105501>;
                <D.105500>:
                iftmp.34 = __vtt_parm + 32;
                goto <D.105502>;
                <D.105501>:
                iftmp.34 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
                <D.105502>:
                D.105503 = &this->D.102009;
                Glib::ObjectBase::~ObjectBase (D.105503, iftmp.34);
                goto <D.105504>;
                <D.105498>:
                <D.105504>:
              }
          }
        finally
          {
            D.105496 = 0;
            if (D.105496 != 0) goto <D.105505>; else goto <D.105506>;
            <D.105505>:
            D.105507 = &this->D.102010;
            sigc::trackable::~trackable (D.105507);
            goto <D.105508>;
            <D.105506>:
            <D.105508>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102241>:
  D.105509 = 0;
  if (D.105509 != 0) goto <D.105510>; else goto <D.105511>;
  <D.105510>:
  operator delete (this);
  goto <D.105512>;
  <D.105511>:
  <D.105512>:
}


virtual Gio::ApplicationCommandLine::~ApplicationCommandLine() (struct ApplicationCommandLine * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * D.105528;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.105533;
  int (*__vtbl_ptr_type) () * D.105534;
  long int D.105535;
  struct ObjectBase * D.105537;
  int (*__vtbl_ptr_type) () * iftmp.37;
  const void * * iftmp.38;
  struct Object * D.105546;
  int D.105547;
  const void * * iftmp.39;
  struct ObjectBase * D.105554;
  struct trackable * D.105558;
  int D.105560;

  {
    if (2 == 0) goto <D.105526>; else goto <D.105527>;
    <D.105526>:
    D.105528 = 0B;
    iftmp.35 = *D.105528;
    goto <D.105529>;
    <D.105527>:
    iftmp.35 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
    <D.105529>:
    this->D.102007._vptr.Object = iftmp.35;
    if (2 == 0) goto <D.105531>; else goto <D.105532>;
    <D.105531>:
    D.105533 = this->D.102007._vptr.Object;
    D.105534 = D.105533 + 18446744073709551592;
    D.105535 = MEM[(long int *)D.105534];
    iftmp.36 = (sizetype) D.105535;
    goto <D.105536>;
    <D.105532>:
    iftmp.36 = 8;
    <D.105536>:
    D.105537 = this + iftmp.36;
    if (2 == 0) goto <D.105539>; else goto <D.105540>;
    <D.105539>:
    iftmp.37 = MEM[(const void * *)0B + 24B];
    goto <D.105541>;
    <D.105540>:
    iftmp.37 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
    <D.105541>:
    D.105537->_vptr.ObjectBase = iftmp.37;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.105543>; else goto <D.105544>;
                    <D.105543>:
                    iftmp.38 = 8B;
                    goto <D.105545>;
                    <D.105544>:
                    iftmp.38 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
                    <D.105545>:
                    D.105546 = &this->D.102007;
                    Glib::Object::~Object (D.105546, iftmp.38);
                  }
              }
            finally
              {
                D.105547 = 2;
                if (D.105547 != 0) goto <D.105548>; else goto <D.105549>;
                <D.105548>:
                if (2 == 0) goto <D.105551>; else goto <D.105552>;
                <D.105551>:
                iftmp.39 = 32B;
                goto <D.105553>;
                <D.105552>:
                iftmp.39 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
                <D.105553>:
                D.105554 = &this->D.102009;
                Glib::ObjectBase::~ObjectBase (D.105554, iftmp.39);
                goto <D.105555>;
                <D.105549>:
                <D.105555>:
              }
          }
        finally
          {
            D.105547 = 2;
            if (D.105547 != 0) goto <D.105556>; else goto <D.105557>;
            <D.105556>:
            D.105558 = &this->D.102010;
            sigc::trackable::~trackable (D.105558);
            goto <D.105559>;
            <D.105557>:
            <D.105559>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102244>:
  D.105560 = 0;
  if (D.105560 != 0) goto <D.105561>; else goto <D.105562>;
  <D.105561>:
  operator delete (this);
  goto <D.105563>;
  <D.105562>:
  <D.105563>:
}


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


static GType Gio::ApplicationCommandLine::get_type() ()
{
  GType D.105576;
  const struct Class & D.105577;

  D.105577 = Gio::ApplicationCommandLine_Class::init (&applicationcommandline_class_);
  D.105576 = Glib::Class::get_type (D.105577);
  return D.105576;
}


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

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


static GType Gio::ApplicationCommandLine::get_base_type() ()
{
  GType D.105582;

  D.105582 = g_application_command_line_get_type ();
  return D.105582;
}


Gio::ApplicationCommandLine::ApplicationCommandLine() (struct ApplicationCommandLine * const this, const void * * __vtt_parm)
{
  struct trackable * D.105587;
  const void * * iftmp.40;
  struct ObjectBase * D.105595;
  struct ConstructParams D.102267;
  const struct Class & D.105597;
  const void * * iftmp.41;
  struct Object * D.105602;
  int (*__vtbl_ptr_type) () * iftmp.42;
  sizetype iftmp.43;
  int (*__vtbl_ptr_type) () * D.105610;
  int (*__vtbl_ptr_type) () * D.105611;
  long int D.105612;
  struct ObjectBase * D.105614;
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * iftmp.45;
  const void * * iftmp.46;

  if (0 != 0) goto <D.105585>; else goto <D.105586>;
  <D.105585>:
  D.105587 = &this->D.102010;
  sigc::trackable::trackable (D.105587);
  goto <D.105588>;
  <D.105586>:
  <D.105588>:
  try
    {
      if (0 != 0) goto <D.105589>; else goto <D.105590>;
      <D.105589>:
      if (0 == 0) goto <D.105592>; else goto <D.105593>;
      <D.105592>:
      iftmp.40 = __vtt_parm + 32;
      goto <D.105594>;
      <D.105593>:
      iftmp.40 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105594>:
      D.105595 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105595, iftmp.40, 0B);
      goto <D.105596>;
      <D.105590>:
      <D.105596>:
      try
        {
          D.105597 = Gio::ApplicationCommandLine_Class::init (&applicationcommandline_class_);
          Glib::ConstructParams::ConstructParams (&D.102267, D.105597);
          try
            {
              if (0 == 0) goto <D.105599>; else goto <D.105600>;
              <D.105599>:
              iftmp.41 = __vtt_parm + 8;
              goto <D.105601>;
              <D.105600>:
              iftmp.41 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105601>:
              D.105602 = &this->D.102007;
              Glib::Object::Object (D.105602, iftmp.41, &D.102267);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.102267);
              D.102267 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.105604>; else goto <D.105605>;
              <D.105604>:
              iftmp.42 = *__vtt_parm;
              goto <D.105606>;
              <D.105605>:
              iftmp.42 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105606>:
              this->D.102007._vptr.Object = iftmp.42;
              if (0 == 0) goto <D.105608>; else goto <D.105609>;
              <D.105608>:
              D.105610 = this->D.102007._vptr.Object;
              D.105611 = D.105610 + 18446744073709551592;
              D.105612 = MEM[(long int *)D.105611];
              iftmp.43 = (sizetype) D.105612;
              goto <D.105613>;
              <D.105609>:
              iftmp.43 = 8;
              <D.105613>:
              D.105614 = this + iftmp.43;
              if (0 == 0) goto <D.105616>; else goto <D.105617>;
              <D.105616>:
              iftmp.44 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.105618>;
              <D.105617>:
              iftmp.44 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105618>:
              D.105614->_vptr.ObjectBase = iftmp.44;
            }
          catch
            {
              if (0 == 0) goto <D.105620>; else goto <D.105621>;
              <D.105620>:
              iftmp.45 = __vtt_parm + 8;
              goto <D.105622>;
              <D.105621>:
              iftmp.45 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105622>:
              D.105602 = &this->D.102007;
              Glib::Object::~Object (D.105602, iftmp.45);
            }
        }
      catch
        {
          if (0 != 0) goto <D.105623>; else goto <D.105624>;
          <D.105623>:
          if (0 == 0) goto <D.105626>; else goto <D.105627>;
          <D.105626>:
          iftmp.46 = __vtt_parm + 32;
          goto <D.105628>;
          <D.105627>:
          iftmp.46 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105628>:
          D.105595 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105595, iftmp.46);
          goto <D.105629>;
          <D.105624>:
          <D.105629>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.105630>; else goto <D.105631>;
      <D.105630>:
      D.105587 = &this->D.102010;
      sigc::trackable::~trackable (D.105587);
      goto <D.105632>;
      <D.105631>:
      <D.105632>:
    }
}


Gio::ApplicationCommandLine::ApplicationCommandLine() (struct ApplicationCommandLine * const this)
{
  struct trackable * D.105639;
  const void * * iftmp.47;
  struct ObjectBase * D.105647;
  struct ConstructParams D.102269;
  const struct Class & D.105649;
  const void * * iftmp.48;
  struct Object * D.105654;
  int (*__vtbl_ptr_type) () * iftmp.49;
  const void * * D.105658;
  sizetype iftmp.50;
  int (*__vtbl_ptr_type) () * D.105663;
  int (*__vtbl_ptr_type) () * D.105664;
  long int D.105665;
  struct ObjectBase * D.105667;
  int (*__vtbl_ptr_type) () * iftmp.51;
  const void * * iftmp.52;
  const void * * iftmp.53;

  if (1 != 0) goto <D.105637>; else goto <D.105638>;
  <D.105637>:
  D.105639 = &this->D.102010;
  sigc::trackable::trackable (D.105639);
  goto <D.105640>;
  <D.105638>:
  <D.105640>:
  try
    {
      if (1 != 0) goto <D.105641>; else goto <D.105642>;
      <D.105641>:
      if (1 == 0) goto <D.105644>; else goto <D.105645>;
      <D.105644>:
      iftmp.47 = 32B;
      goto <D.105646>;
      <D.105645>:
      iftmp.47 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
      <D.105646>:
      D.105647 = &this->D.102009;
      Glib::ObjectBase::ObjectBase (D.105647, iftmp.47, 0B);
      goto <D.105648>;
      <D.105642>:
      <D.105648>:
      try
        {
          D.105649 = Gio::ApplicationCommandLine_Class::init (&applicationcommandline_class_);
          Glib::ConstructParams::ConstructParams (&D.102269, D.105649);
          try
            {
              if (1 == 0) goto <D.105651>; else goto <D.105652>;
              <D.105651>:
              iftmp.48 = 8B;
              goto <D.105653>;
              <D.105652>:
              iftmp.48 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105653>:
              D.105654 = &this->D.102007;
              Glib::Object::Object (D.105654, iftmp.48, &D.102269);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.102269);
              D.102269 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.105656>; else goto <D.105657>;
              <D.105656>:
              D.105658 = 0B;
              iftmp.49 = *D.105658;
              goto <D.105659>;
              <D.105657>:
              iftmp.49 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 32B];
              <D.105659>:
              this->D.102007._vptr.Object = iftmp.49;
              if (1 == 0) goto <D.105661>; else goto <D.105662>;
              <D.105661>:
              D.105663 = this->D.102007._vptr.Object;
              D.105664 = D.105663 + 18446744073709551592;
              D.105665 = MEM[(long int *)D.105664];
              iftmp.50 = (sizetype) D.105665;
              goto <D.105666>;
              <D.105662>:
              iftmp.50 = 8;
              <D.105666>:
              D.105667 = this + iftmp.50;
              if (1 == 0) goto <D.105669>; else goto <D.105670>;
              <D.105669>:
              iftmp.51 = MEM[(const void * *)0B + 24B];
              goto <D.105671>;
              <D.105670>:
              iftmp.51 = &MEM[(void *)&_ZTVN3Gio22ApplicationCommandLineE + 112B];
              <D.105671>:
              D.105667->_vptr.ObjectBase = iftmp.51;
            }
          catch
            {
              if (1 == 0) goto <D.105673>; else goto <D.105674>;
              <D.105673>:
              iftmp.52 = 8B;
              goto <D.105675>;
              <D.105674>:
              iftmp.52 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 8B];
              <D.105675>:
              D.105654 = &this->D.102007;
              Glib::Object::~Object (D.105654, iftmp.52);
            }
        }
      catch
        {
          if (1 != 0) goto <D.105676>; else goto <D.105677>;
          <D.105676>:
          if (1 == 0) goto <D.105679>; else goto <D.105680>;
          <D.105679>:
          iftmp.53 = 32B;
          goto <D.105681>;
          <D.105680>:
          iftmp.53 = &MEM[(void *)&_ZTTN3Gio22ApplicationCommandLineE + 32B];
          <D.105681>:
          D.105647 = &this->D.102009;
          Glib::ObjectBase::~ObjectBase (D.105647, iftmp.53);
          goto <D.105682>;
          <D.105677>:
          <D.105682>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.105683>; else goto <D.105684>;
      <D.105683>:
      D.105639 = &this->D.102010;
      sigc::trackable::~trackable (D.105639);
      goto <D.105685>;
      <D.105684>:
      <D.105685>:
    }
}


char** Gio::ApplicationCommandLine::get_arguments(int&) const (const struct ApplicationCommandLine * const this, int & argc)
{
  char * * D.105690;
  const struct GApplicationCommandLine * D.105691;

  D.105691 = Gio::ApplicationCommandLine::gobj (this);
  D.105690 = g_application_command_line_get_arguments (D.105691, argc);
  return D.105690;
}


const GApplicationCommandLine* Gio::ApplicationCommandLine::gobj() const (const struct ApplicationCommandLine * const this)
{
  const struct GApplicationCommandLine * D.105694;
  int (*__vtbl_ptr_type) () * D.105695;
  int (*__vtbl_ptr_type) () * D.105696;
  long int D.105697;
  sizetype D.105698;
  const struct ObjectBase * D.105699;

  D.105695 = this->D.102007._vptr.Object;
  D.105696 = D.105695 + 18446744073709551592;
  D.105697 = MEM[(long int *)D.105696];
  D.105698 = (sizetype) D.105697;
  D.105699 = this + D.105698;
  D.105694 = D.105699->gobject_;
  return D.105694;
}


Glib::RefPtr<Glib::VariantDict> Gio::ApplicationCommandLine::get_options_dict() (struct ApplicationCommandLine * const this)
{
  struct GApplicationCommandLine * D.105702;
  struct GVariantDict * D.105703;
  bool retval.54;
  struct VariantDict * D.105707;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105702 = Gio::ApplicationCommandLine::gobj (this);
  D.105703 = g_application_command_line_get_options_dict (D.105702);
  *<retval> = Glib::wrap (D.105703, 0); [return slot optimization]
  try
    {
      retval.54 = Glib::RefPtr<Glib::VariantDict>::operator bool (<retval>);
      if (retval.54 != 0) goto <D.105705>; else goto <D.105706>;
      <D.105705>:
      D.105707 = Glib::RefPtr<Glib::VariantDict>::operator-> (<retval>);
      Glib::VariantDict::reference (D.105707);
      goto <D.105708>;
      <D.105706>:
      <D.105708>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::VariantDict>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Glib::VariantDict] (const struct RefPtr * const this)
{
  bool D.105712;
  struct VariantDict * D.105713;

  D.105713 = this->pCppObject_;
  D.105712 = D.105713 != 0B;
  return D.105712;
}


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

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


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

  {
    try
      {
        D.105717 = this->pCppObject_;
        if (D.105717 != 0B) goto <D.105718>; else goto <D.105719>;
        <D.105718>:
        D.105717 = this->pCppObject_;
        Glib::VariantDict::unreference (D.105717);
        goto <D.105720>;
        <D.105719>:
        <D.105720>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104092>:
}


Glib::RefPtr<const Glib::VariantDict> Gio::ApplicationCommandLine::get_options_dict() const (const struct ApplicationCommandLine * const this)
{
  struct RefPtr D.102540;

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


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Glib::VariantDict; T_CppObject = const Glib::VariantDict] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct VariantDict * D.105726;
  const struct VariantDict * D.105727;

  D.105726 = Glib::RefPtr<Glib::VariantDict>::operator-> (src);
  this->pCppObject_ = D.105726;
  D.105727 = this->pCppObject_;
  if (D.105727 != 0B) goto <D.105728>; else goto <D.105729>;
  <D.105728>:
  D.105727 = this->pCppObject_;
  Glib::VariantDict::reference (D.105727);
  goto <D.105730>;
  <D.105729>:
  <D.105730>:
}


Glib::RefPtr<Gio::InputStream> Gio::ApplicationCommandLine::get_stdin() (struct ApplicationCommandLine * const this)
{
  struct GApplicationCommandLine * D.105732;
  struct GInputStream * D.105733;
  bool retval.55;
  struct InputStream * D.105737;
  int (*__vtbl_ptr_type) () * D.105738;
  int (*__vtbl_ptr_type) () * D.105739;
  long int D.105740;
  sizetype D.105741;
  struct ObjectBase * D.105742;
  int (*__vtbl_ptr_type) () * D.105743;
  int (*__vtbl_ptr_type) () * D.105744;
  int (*__vtbl_ptr_type) () D.105745;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.105732 = Gio::ApplicationCommandLine::gobj (this);
  D.105733 = g_application_command_line_get_stdin (D.105732);
  *<retval> = Glib::wrap (D.105733, 0); [return slot optimization]
  try
    {
      retval.55 = Glib::RefPtr<Gio::InputStream>::operator bool (<retval>);
      if (retval.55 != 0) goto <D.105735>; else goto <D.105736>;
      <D.105735>:
      D.105737 = Glib::RefPtr<Gio::InputStream>::operator-> (<retval>);
      D.105738 = D.105737->D.98002._vptr.Object;
      D.105739 = D.105738 + 18446744073709551592;
      D.105740 = MEM[(long int *)D.105739];
      D.105741 = (sizetype) D.105740;
      D.105742 = D.105737 + D.105741;
      D.105738 = D.105737->D.98002._vptr.Object;
      D.105739 = D.105738 + 18446744073709551592;
      D.105740 = MEM[(long int *)D.105739];
      D.105741 = (sizetype) D.105740;
      D.105742 = D.105737 + D.105741;
      D.105743 = D.105742->_vptr.ObjectBase;
      D.105744 = D.105743 + 16;
      D.105745 = *D.105744;
      D.105738 = D.105737->D.98002._vptr.Object;
      D.105739 = D.105738 + 18446744073709551592;
      D.105740 = MEM[(long int *)D.105739];
      D.105741 = (sizetype) D.105740;
      D.105742 = D.105737 + D.105741;
      OBJ_TYPE_REF(D.105745;(const struct ObjectBase)D.105742->2) (D.105742);
      goto <D.105746>;
      <D.105736>:
      <D.105746>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::InputStream>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::InputStream] (const struct RefPtr * const this)
{
  bool D.105750;
  struct InputStream * D.105751;

  D.105751 = this->pCppObject_;
  D.105750 = D.105751 != 0B;
  return D.105750;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::InputStream] (struct RefPtr * const this)
{
  struct InputStream * D.105755;
  int (*__vtbl_ptr_type) () * D.105758;
  int (*__vtbl_ptr_type) () * D.105759;
  long int D.105760;
  sizetype D.105761;
  struct ObjectBase * D.105762;
  int (*__vtbl_ptr_type) () * D.105763;
  int (*__vtbl_ptr_type) () * D.105764;
  int (*__vtbl_ptr_type) () D.105765;

  {
    try
      {
        D.105755 = this->pCppObject_;
        if (D.105755 != 0B) goto <D.105756>; else goto <D.105757>;
        <D.105756>:
        D.105755 = this->pCppObject_;
        D.105755 = this->pCppObject_;
        D.105758 = D.105755->D.98002._vptr.Object;
        D.105759 = D.105758 + 18446744073709551592;
        D.105760 = MEM[(long int *)D.105759];
        D.105761 = (sizetype) D.105760;
        D.105762 = D.105755 + D.105761;
        D.105755 = this->pCppObject_;
        D.105755 = this->pCppObject_;
        D.105758 = D.105755->D.98002._vptr.Object;
        D.105759 = D.105758 + 18446744073709551592;
        D.105760 = MEM[(long int *)D.105759];
        D.105761 = (sizetype) D.105760;
        D.105762 = D.105755 + D.105761;
        D.105763 = D.105762->_vptr.ObjectBase;
        D.105764 = D.105763 + 24;
        D.105765 = *D.105764;
        D.105755 = this->pCppObject_;
        D.105755 = this->pCppObject_;
        D.105758 = D.105755->D.98002._vptr.Object;
        D.105759 = D.105758 + 18446744073709551592;
        D.105760 = MEM[(long int *)D.105759];
        D.105761 = (sizetype) D.105760;
        D.105762 = D.105755 + D.105761;
        OBJ_TYPE_REF(D.105765;(const struct ObjectBase)D.105762->3) (D.105762);
        goto <D.105766>;
        <D.105757>:
        <D.105766>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104124>:
}


Glib::RefPtr<const Gio::InputStream> Gio::ApplicationCommandLine::get_stdin() const (const struct ApplicationCommandLine * const this)
{
  struct RefPtr D.102826;

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


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::InputStream; T_CppObject = const Gio::InputStream] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct InputStream * D.105772;
  const struct InputStream * D.105773;
  int (*__vtbl_ptr_type) () * D.105776;
  int (*__vtbl_ptr_type) () * D.105777;
  long int D.105778;
  sizetype D.105779;
  const struct ObjectBase * D.105780;
  int (*__vtbl_ptr_type) () * D.105781;
  int (*__vtbl_ptr_type) () * D.105782;
  int (*__vtbl_ptr_type) () D.105783;

  D.105772 = Glib::RefPtr<Gio::InputStream>::operator-> (src);
  this->pCppObject_ = D.105772;
  D.105773 = this->pCppObject_;
  if (D.105773 != 0B) goto <D.105774>; else goto <D.105775>;
  <D.105774>:
  D.105773 = this->pCppObject_;
  D.105773 = this->pCppObject_;
  D.105776 = D.105773->D.98002._vptr.Object;
  D.105777 = D.105776 + 18446744073709551592;
  D.105778 = MEM[(long int *)D.105777];
  D.105779 = (sizetype) D.105778;
  D.105780 = D.105773 + D.105779;
  D.105773 = this->pCppObject_;
  D.105773 = this->pCppObject_;
  D.105776 = D.105773->D.98002._vptr.Object;
  D.105777 = D.105776 + 18446744073709551592;
  D.105778 = MEM[(long int *)D.105777];
  D.105779 = (sizetype) D.105778;
  D.105780 = D.105773 + D.105779;
  D.105781 = D.105780->_vptr.ObjectBase;
  D.105782 = D.105781 + 16;
  D.105783 = *D.105782;
  D.105773 = this->pCppObject_;
  D.105773 = this->pCppObject_;
  D.105776 = D.105773->D.98002._vptr.Object;
  D.105777 = D.105776 + 18446744073709551592;
  D.105778 = MEM[(long int *)D.105777];
  D.105779 = (sizetype) D.105778;
  D.105780 = D.105773 + D.105779;
  OBJ_TYPE_REF(D.105783;(const struct ObjectBase)D.105780->2) (D.105780);
  goto <D.105784>;
  <D.105775>:
  <D.105784>:
}


std::string Gio::ApplicationCommandLine::get_cwd() const (const struct ApplicationCommandLine * const this)
{
  const struct GApplicationCommandLine * D.105786;
  const gchar * D.105787;

  D.105786 = Gio::ApplicationCommandLine::gobj (this);
  D.105787 = g_application_command_line_get_cwd (D.105786);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.105787); [return slot optimization]
  return <retval>;
}


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

  cleanup.56 = 0;
  try
    {
      if (str != 0B) goto <D.105791>; else goto <D.105792>;
      <D.105791>:
      std::allocator<char>::allocator (&D.78923);
      cleanup.56 = 1;
      D.105796 = <retval>;
      std::basic_string<char>::basic_string (D.105796, str, &D.78923);
      goto <D.105797>;
      <D.105792>:
      D.105796 = <retval>;
      std::basic_string<char>::basic_string (D.105796);
      <D.105797>:
      return <retval>;
    }
  finally
    {
      if (cleanup.56 != 0) goto <D.105794>; else goto <D.105795>;
      <D.105794>:
      std::allocator<char>::~allocator (&D.78923);
      D.78923 = {CLOBBER};
      <D.105795>:
    }
}


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

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

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


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

  try
    {
      {

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


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.104004;
  struct _Rep & D.105805;
  char * D.105806;
  struct _Alloc_hider * D.105807;

  std::allocator<char>::allocator (&D.104004);
  try
    {
      D.105805 = std::basic_string<char>::_S_empty_rep ();
      D.105806 = std::basic_string<char>::_Rep::_M_refdata (D.105805);
      D.105807 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.105807, D.105806, &D.104004);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.104004);
      D.104004 = {CLOBBER};
    }
  try
    {

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


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

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


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.105813;
  void * __p;

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


_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.105815;
  void * D.105816;

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


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

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


__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.105819;

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::vector<std::basic_string<char> > Gio::ApplicationCommandLine::get_environ() const (const struct ApplicationCommandLine * const this)
{
  const struct GApplicationCommandLine * D.105823;
  const gchar * const * D.105824;

  D.105823 = Gio::ApplicationCommandLine::gobj (this);
  D.105824 = g_application_command_line_get_environ (D.105823);
  *<retval> = Glib::ArrayHandler<std::basic_string<char> >::array_to_vector (D.105824, 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 = std::basic_string<char>; Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<std::basic_string<char> >; Glib::ArrayHandler<T, Tr>::CType = const char*] (const char * const * array, OwnershipType ownership)
{
  long unsigned int D.105828;

  D.105828 = Glib::Container_Helpers::compute_array_size2<const char*> (array);
  *<retval> = Glib::ArrayHandler<std::basic_string<char> >::array_to_vector (array, D.105828, 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.105832;
  size_t D.105833;
  long int pend.57;
  long int array.58;
  long int D.105836;
  long int D.105837;

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

      pend = array;
      goto <D.104443>;
      <D.104444>:
      pend = pend + 8;
      <D.104443>:
      D.105832 = *pend;
      if (D.105832 != 0B) goto <D.104444>; else goto <D.104442>;
      <D.104442>:
      pend.57 = (long int) pend;
      array.58 = (long int) array;
      D.105836 = pend.57 - array.58;
      D.105837 = D.105836 /[ex] 8;
      D.105833 = (size_t) D.105837;
      return D.105833;
    }
    <D.105831>:
  }
  D.105833 = 0;
  return D.105833;
}


static Glib::ArrayHandler<T, Tr>::VectorType Glib::ArrayHandler<T, Tr>::array_to_vector(const CType*, std::size_t, Glib::OwnershipType) [with T = std::basic_string<char>; Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<std::basic_string<char> >; 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.104580;
  struct ArrayIteratorType D.104563;
  long unsigned int D.105842;
  const char * const * D.105843;
  struct ArrayIteratorType D.104562;

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

      try
        {
          Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::ArrayKeeper (&keeper, array, array_size, ownership);
          try
            {
              std::allocator<std::basic_string<char> >::allocator (&D.104580);
              try
                {
                  D.105842 = array_size * 8;
                  D.105843 = array + D.105842;
                  Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::ArrayIterator (&D.104563, D.105843);
                  try
                    {
                      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::ArrayIterator (&D.104562, array);
                      try
                        {
                          std::vector<std::basic_string<char> >::vector<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (<retval>, D.104562, D.104563, &D.104580);
                          return <retval>;
                        }
                      finally
                        {
                          D.104562 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.104563 = {CLOBBER};
                    }
                }
              finally
                {
                  std::allocator<std::basic_string<char> >::~allocator (&D.104580);
                  D.104580 = {CLOBBER};
                }
            }
          finally
            {
              Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::~ArrayKeeper (&keeper);
            }
        }
      finally
        {
          keeper = {CLOBBER};
        }
    }
    <D.105841>:
  }
  std::vector<std::basic_string<char> >::vector (<retval>);
  return <retval>;
}


Glib::Container_Helpers::ArrayKeeper<Tr>::ArrayKeeper(const CType*, std::size_t, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >; 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 = std::basic_string<char>] (struct allocator * const this)
{
  void * D.105855;

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

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


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

  try
    {
      {

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


Glib::Container_Helpers::ArrayIterator<Tr>::ArrayIterator(const CType*) [with Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >; 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<std::basic_string<char> > >; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<std::basic_string<char> >] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.105857;
  struct _Integral D.104839;
  struct __false_type D.105858;

  D.105857 = &this->D.103594;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_base (D.105857, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<std::basic_string<char> >::_M_initialize_dispatch<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (this, __first, __last, D.105858);
          }
        finally
          {
            D.104839 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.105857 = &this->D.103594;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::~_Vector_base (D.105857);
    }
}


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

  D.105861 = &this->_M_impl;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::_Vector_impl (D.105861, __a);
  try
    {

    }
  catch
    {
      D.105861 = &this->_M_impl;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::~_Vector_impl (D.105861);
    }
}


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


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

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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct __false_type D.104793)
{
  struct forward_iterator_tag D.105038;
  struct _IterCategory D.105010;
  struct _IterCategory * D.105864;
  struct forward_iterator_tag D.105865;
  typedef struct _IterCategory _IterCategory;

  try
    {
      D.105864 = &D.105010;
      std::vector<std::basic_string<char> >::_M_range_initialize<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (this, __first, __last, D.105865);
    }
  finally
    {
      D.105010 = {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<std::basic_string<char> > >; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct forward_iterator_tag D.105015)
{
  long int D.105867;
  struct _Vector_base * D.105868;
  struct basic_string * D.105869;
  struct basic_string * D.105870;
  long unsigned int D.105871;
  struct basic_string * D.105872;
  struct _Tp_alloc_type & D.105873;
  struct basic_string * D.105874;
  const size_type __n;

  D.105867 = std::distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (__first, __last);
  __n = (const size_type) D.105867;
  D.105868 = &this->D.103594;
  D.105869 = std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_allocate (D.105868, __n);
  this->D.103594._M_impl._M_start = D.105869;
  D.105870 = this->D.103594._M_impl._M_start;
  D.105871 = __n * 8;
  D.105872 = D.105870 + D.105871;
  this->D.103594._M_impl._M_end_of_storage = D.105872;
  D.105868 = &this->D.103594;
  D.105873 = std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_get_Tp_allocator (D.105868);
  D.105870 = this->D.103594._M_impl._M_start;
  D.105874 = std::__uninitialized_copy_a<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >, std::basic_string<char>*, std::basic_string<char> > (__first, __last, D.105870, D.105873);
  this->D.103594._M_impl._M_finish = D.105874;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last)
{
  difference_type D.105878;
  struct iterator_category D.105152;
  struct random_access_iterator_tag D.105879;

  std::__iterator_category<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (&__first);
  try
    {
      D.105878 = std::__distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > > > (__first, __last, D.105879);
      return D.105878;
    }
  finally
    {
      D.105152 = {CLOBBER};
    }
}


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

  return D.105884;
}


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<std::basic_string<char> > >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last, struct random_access_iterator_tag D.105156)
{
  difference_type D.105886;

  D.105886 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::operator- (&__last, &__first);
  return D.105886;
}


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<std::basic_string<char> >; Glib::Container_Helpers::ArrayIterator<Tr>::difference_type = long int] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  difference_type D.105888;
  const char * const * D.105889;
  long int D.105890;
  const char * const * D.105891;
  long int D.105892;
  long int D.105893;

  D.105889 = this->pos_;
  D.105890 = (long int) D.105889;
  D.105891 = rhs->pos_;
  D.105892 = (long int) D.105891;
  D.105893 = D.105890 - D.105892;
  D.105888 = D.105893 /[ex] 8;
  return D.105888;
}


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

  if (__n != 0) goto <D.105897>; else goto <D.105898>;
  <D.105897>:
  D.105899 = &this->_M_impl;
  iftmp.59 = __gnu_cxx::__alloc_traits<std::allocator<std::basic_string<char> > >::allocate (D.105899, __n);
  goto <D.105900>;
  <D.105898>:
  iftmp.59 = 0B;
  <D.105900>:
  D.105895 = iftmp.59;
  return D.105895;
}


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

  D.105903 = __gnu_cxx::new_allocator<std::basic_string<char> >::allocate (__a, __n, 0B);
  return D.105903;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::basic_string<char>; __gnu_cxx::new_allocator<_Tp>::pointer = std::basic_string<char>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.102907)
{
  bool retval.60;
  long unsigned int D.105907;
  struct basic_string * D.105910;
  long unsigned int D.105911;

  D.105907 = __gnu_cxx::new_allocator<std::basic_string<char> >::max_size (this);
  retval.60 = D.105907 < __n;
  if (retval.60 != 0) goto <D.105908>; else goto <D.105909>;
  <D.105908>:
  std::__throw_bad_alloc ();
  <D.105909>:
  D.105911 = __n * 8;
  D.105910 = operator new (D.105911);
  return D.105910;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::basic_string<char>; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.105914;
  void * D.105915;

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


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

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


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

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


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

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


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >; _ForwardIterator = std::basic_string<char>*; bool _TrivialValueTypes = false] (struct ArrayIterator __first, struct ArrayIterator __last, struct basic_string * __result)
{
  struct value_type D.105204;
  struct basic_string * D.105925;
  bool retval.61;
  struct basic_string * D.105927;
  void * D.105928;
  struct basic_string * __cur;

  __cur = __result;
  try
    {
      goto <D.105208>;
      <D.105207>:
      D.105204 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::operator* (&__first); [return slot optimization]
      try
        {
          D.105925 = std::__addressof<std::basic_string<char> > (__cur);
          std::_Construct<std::basic_string<char>, std::basic_string<char> > (D.105925, &D.105204);
        }
      finally
        {
          std::basic_string<char>::~basic_string (&D.105204);
          D.105204 = {CLOBBER};
        }
      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::operator++ (&__first);
      __cur = __cur + 8;
      <D.105208>:
      retval.61 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<std::basic_string<char> > >::operator!= (&__first, &__last);
      if (retval.61 != 0) goto <D.105207>; else goto <D.105205>;
      <D.105205>:
      D.105927 = __cur;
      return D.105927;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.105928 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.105928);
              std::_Destroy<std::basic_string<char>*> (__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<std::basic_string<char> >; Glib::Container_Helpers::ArrayIterator<Tr>::value_type = std::basic_string<char>] (const struct ArrayIterator * const this)
{
  const char * const * D.105935;
  const char * D.105936;

  D.105935 = this->pos_;
  D.105936 = *D.105935;
  *<retval> = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >::to_cpp_type (D.105936); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<std::basic_string<char> >::CppType Glib::Container_Helpers::TypeTraits<std::basic_string<char> >::to_cpp_type(Glib::Container_Helpers::TypeTraits<std::basic_string<char> >::CType) (const char * str)
{
  struct allocator D.74989;
  bool cleanup.62;
  struct CppType * D.105944;

  cleanup.62 = 0;
  try
    {
      if (str != 0B) goto <D.105939>; else goto <D.105940>;
      <D.105939>:
      std::allocator<char>::allocator (&D.74989);
      cleanup.62 = 1;
      D.105944 = <retval>;
      std::basic_string<char>::basic_string (D.105944, str, &D.74989);
      goto <D.105945>;
      <D.105940>:
      D.105944 = <retval>;
      std::basic_string<char>::basic_string (D.105944);
      <D.105945>:
      return <retval>;
    }
  finally
    {
      if (cleanup.62 != 0) goto <D.105942>; else goto <D.105943>;
      <D.105942>:
      std::allocator<char>::~allocator (&D.74989);
      D.74989 = {CLOBBER};
      <D.105943>:
    }
}


_Tp* std::__addressof(_Tp&) [with _Tp = std::basic_string<char>] (struct basic_string & __r)
{
  struct basic_string * D.105951;

  D.105951 = __r;
  return D.105951;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = std::basic_string<char>; _T2 = std::basic_string<char>] (struct basic_string * __p, const struct basic_string & __value)
{
  void * D.105147;
  void * D.105148;
  struct basic_string * iftmp.63;

  D.105147 = __p;
  D.105148 = operator new (8, D.105147);
  if (D.105148 != 0B) goto <D.105954>; else goto <D.105955>;
  <D.105954>:
  try
    {
      std::basic_string<char>::basic_string (D.105148, __value);
    }
  catch
    {
      operator delete (D.105148, D.105147);
    }
  iftmp.63 = D.105148;
  goto <D.105956>;
  <D.105955>:
  iftmp.63 = D.105148;
  <D.105956>:
}


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

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


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

  try
    {

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


Glib::Container_Helpers::ArrayIterator<Tr>& Glib::Container_Helpers::ArrayIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >] (struct ArrayIterator * const this)
{
  const char * const * D.105962;
  const char * const * D.105963;
  struct ArrayIterator & D.105964;

  D.105962 = this->pos_;
  D.105963 = D.105962 + 8;
  this->pos_ = D.105963;
  D.105964 = this;
  return D.105964;
}


bool Glib::Container_Helpers::ArrayIterator<Tr>::operator!=(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  bool D.105966;
  const char * const * D.105967;
  const char * const * D.105968;

  D.105967 = this->pos_;
  D.105968 = rhs->pos_;
  D.105966 = D.105967 != D.105968;
  return D.105966;
}


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_type D.103755;
  struct _Rep * D.105970;
  struct _Alloc_hider * D.105971;

  {
    try
      {
        try
          {
            D.103755 = std::basic_string<char>::get_allocator (this); [return slot optimization]
            try
              {
                D.105970 = std::basic_string<char>::_M_rep (this);
                std::basic_string<char>::_Rep::_M_dispose (D.105970, &D.103755);
              }
            finally
              {
                std::allocator<char>::~allocator (&D.103755);
                D.103755 = {CLOBBER};
              }
          }
        finally
          {
            D.105971 = &this->_M_dataplus;
            std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.105971);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103756>:
}


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

  D.105977 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.105977);
  return <retval>;
}


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

  D.105980 = std::basic_string<char>::_M_data (this);
  D.105979 = D.105980 + 18446744073709551592;
  return D.105979;
}


_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.105983;

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


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.64;
  struct _Rep & D.105986;
  bool D.105987;
  long int D.105988;
  long int D.105989;
  bool retval.65;
  _Atomic_word * D.105993;
  int D.105994;

  D.105986 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.105987 = D.105986 != this;
  D.105988 = (long int) D.105987;
  D.105989 = __builtin_expect (D.105988, 0);
  retval.64 = D.105989 != 0;
  if (retval.64 != 0) goto <D.105990>; else goto <D.105991>;
  <D.105990>:
  D.105993 = &this->D.18966._M_refcount;
  D.105994 = __gnu_cxx::__exchange_and_add_dispatch (D.105993, -1);
  retval.65 = D.105994 <= 0;
  if (retval.65 != 0) goto <D.105995>; else goto <D.105996>;
  <D.105995>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.105997>;
  <D.105996>:
  <D.105997>:
  goto <D.105998>;
  <D.105991>:
  <D.105998>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.66;
  int D.106001;
  _Atomic_word D.106004;

  D.106001 = __gthread_active_p ();
  retval.66 = D.106001 != 0;
  if (retval.66 != 0) goto <D.106002>; else goto <D.106003>;
  <D.106002>:
  D.106004 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.106004;
  <D.106003>:
  D.106004 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.106004;
}


int __gthread_active_p() ()
{
  int D.106006;
  bool D.106007;
  static void * const __gthread_active_ptr = (void *) __gthrw___pthread_key_create;

  D.106007 = __gthrw___pthread_key_create != 0B;
  D.106006 = (int) D.106007;
  return D.106006;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.106009;
  unsigned int __val.67;
  unsigned int D.106011;

  __val.67 = (unsigned int) __val;
  D.106011 = __atomic_fetch_add_4 (__mem, __val.67, 4);
  D.106009 = (_Atomic_word) D.106011;
  return D.106009;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.106013;
  int D.106014;
  _Atomic_word D.106015;
  _Atomic_word __result;

  __result = *__mem;
  D.106013 = *__mem;
  D.106014 = D.106013 + __val;
  *__mem = D.106014;
  D.106015 = __result;
  return D.106015;
}


std::basic_string<char>::_Alloc_hider::~_Alloc_hider() (struct _Alloc_hider * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<char>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103749>:
}


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = std::basic_string<char>*] (struct basic_string * __first, struct basic_string * __last)
{
  typedef struct _Value_type _Value_type;

  std::_Destroy_aux<false>::__destroy<std::basic_string<char>*> (__first, __last);
}


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

  goto <D.105056>;
  <D.105055>:
  D.106017 = std::__addressof<std::basic_string<char> > (__first);
  std::_Destroy<std::basic_string<char> > (D.106017);
  __first = __first + 8;
  <D.105056>:
  if (__first != __last) goto <D.105055>; else goto <D.105053>;
  <D.105053>:
}


void std::_Destroy(_Tp*) [with _Tp = std::basic_string<char>] (struct basic_string * __pointer)
{
  std::basic_string<char>::~basic_string (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct _Vector_base * const this)
{
  struct basic_string * D.106018;
  long int D.106019;
  struct basic_string * D.106020;
  long int D.106021;
  long int D.106022;
  long int D.106023;
  long unsigned int D.106024;
  struct _Vector_impl * D.106025;

  {
    try
      {
        try
          {
            D.106018 = this->_M_impl._M_end_of_storage;
            D.106019 = (long int) D.106018;
            D.106020 = this->_M_impl._M_start;
            D.106021 = (long int) D.106020;
            D.106022 = D.106019 - D.106021;
            D.106023 = D.106022 /[ex] 8;
            D.106024 = (long unsigned int) D.106023;
            D.106020 = this->_M_impl._M_start;
            std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_deallocate (this, D.106020, D.106024);
          }
        finally
          {
            D.106025 = &this->_M_impl;
            std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::~_Vector_impl (D.106025);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104594>:
}


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

  if (__p != 0B) goto <D.106028>; else goto <D.106029>;
  <D.106028>:
  D.106030 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<std::basic_string<char> > >::deallocate (D.106030, __p, __n);
  goto <D.106031>;
  <D.106029>:
  <D.106031>:
}


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


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

          }
        finally
          {
            std::allocator<std::basic_string<char> >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104589>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.106034 = &this->D.103594;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_base (D.106034);
  try
    {

    }
  catch
    {
      D.106034 = &this->D.103594;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::~_Vector_base (D.106034);
    }
}


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

  D.106035 = &this->_M_impl;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::_Vector_impl (D.106035);
  try
    {

    }
  catch
    {
      D.106035 = &this->_M_impl;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::~_Vector_impl (D.106035);
    }
}


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


Glib::Container_Helpers::ArrayKeeper<Tr>::~ArrayKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<std::basic_string<char> >] (struct ArrayKeeper * const this)
{
  const char * * D.106036;
  OwnershipType D.106039;
  long unsigned int D.106044;
  long unsigned int D.106045;
  const char * D.106046;

  {
    try
      {
        {
          {
            D.106036 = this->array_;
            if (D.106036 != 0B) goto <D.106037>; else goto <D.106038>;
            <D.106037>:
            D.106039 = this->ownership_;
            if (D.106039 != 0) goto <D.106040>; else goto <D.106041>;
            <D.106040>:
            {
              {
                D.106039 = this->ownership_;
                if (D.106039 != 1) goto <D.106042>; else goto <D.106043>;
                <D.106042>:
                {
                  const char * const * const array_end;

                  D.106036 = this->array_;
                  D.106044 = this->array_size_;
                  D.106045 = D.106044 * 8;
                  array_end = D.106036 + D.106045;
                  {
                    const char * const * p;

                    p = this->array_;
                    goto <D.104761>;
                    <D.104762>:
                    D.106046 = *p;
                    Glib::Container_Helpers::TypeTraits<std::basic_string<char> >::release_c_type (D.106046);
                    p = p + 8;
                    <D.104761>:
                    if (p != array_end) goto <D.104762>; else goto <D.104763>;
                    <D.104763>:
                  }
                }
                goto <D.106047>;
                <D.106043>:
                <D.106047>:
              }
              D.106036 = this->array_;
              g_free (D.106036);
            }
            goto <D.106048>;
            <D.106041>:
            <D.106048>:
            <D.106038>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104764>:
}


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


std::string Gio::ApplicationCommandLine::getenv(const Glib::ustring&) const (const struct ApplicationCommandLine * const this, const struct ustring & name)
{
  const char * D.106051;
  const struct GApplicationCommandLine * D.106052;
  const gchar * D.106053;

  D.106051 = Glib::ustring::c_str (name);
  D.106052 = Gio::ApplicationCommandLine::gobj (this);
  D.106053 = g_application_command_line_getenv (D.106052, D.106051);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.106053); [return slot optimization]
  return <retval>;
}


bool Gio::ApplicationCommandLine::is_remote() const (const struct ApplicationCommandLine * const this)
{
  bool D.106057;
  const struct GApplicationCommandLine * D.106058;
  int D.106059;

  D.106058 = Gio::ApplicationCommandLine::gobj (this);
  D.106059 = g_application_command_line_get_is_remote (D.106058);
  D.106057 = D.106059 != 0;
  return D.106057;
}


Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> > Gio::ApplicationCommandLine::get_platform_data() const (const struct ApplicationCommandLine * const this)
{
  const struct GApplicationCommandLine * D.106063;
  struct GVariant * D.106064;

  D.106063 = Gio::ApplicationCommandLine::gobj (this);
  D.106064 = g_application_command_line_get_platform_data (D.106063);
  Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::Variant (<retval>, D.106064, 0);
  return <retval>;
}


Glib::Variant<std::map<K, V> >::Variant(GVariant*, bool) [with K = Glib::ustring; V = Glib::VariantBase; GVariant = _GVariant] (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.106067;
  struct VariantContainerBase * D.106068;

  D.106067 = (int) take_a_reference;
  D.106068 = &this->D.103663;
  Glib::VariantContainerBase::VariantContainerBase (D.106068, castitem, D.106067);
  try
    {

    }
  catch
    {
      D.106068 = &this->D.103663;
      Glib::VariantContainerBase::~VariantContainerBase (D.106068);
    }
}


void Gio::ApplicationCommandLine::set_exit_status(int) (struct ApplicationCommandLine * const this, int exit_status)
{
  struct GApplicationCommandLine * D.106069;

  D.106069 = Gio::ApplicationCommandLine::gobj (this);
  g_application_command_line_set_exit_status (D.106069, exit_status);
}


int Gio::ApplicationCommandLine::get_exit_status() const (const struct ApplicationCommandLine * const this)
{
  int D.106070;
  const struct GApplicationCommandLine * D.106071;

  D.106071 = Gio::ApplicationCommandLine::gobj (this);
  D.106070 = g_application_command_line_get_exit_status (D.106071);
  return D.106070;
}


Glib::RefPtr<Gio::File> Gio::ApplicationCommandLine::create_file_for_arg(const Glib::ustring&) const (const struct ApplicationCommandLine * const this, const struct ustring & arg)
{
  const char * D.106075;
  const struct GApplicationCommandLine * D.106076;
  struct GFile * D.106077;

  D.106075 = Glib::ustring::c_str (arg);
  D.106076 = Gio::ApplicationCommandLine::gobj (this);
  D.106077 = g_application_command_line_create_file_for_arg (D.106076, D.106075);
  *<retval> = Glib::wrap (D.106077, 0); [return slot optimization]
  return <retval>;
}