const Glib::Class& Gio::Application::custom_class_init() (struct Application * const this)
{
  const struct Class & D.115451;

  Glib::init ();
  Gio::init ();
  D.115451 = Gio::Application_Class::init (&application_class_);
  return D.115451;
}


Gio::Application::Application(const Glib::ustring&, Gio::ApplicationFlags) (struct Application * const this, const void * * __vtt_parm, const struct ustring & application_id, ApplicationFlags flags)
{
  struct trackable * D.115456;
  const void * * iftmp.0;
  struct ObjectBase * D.115464;
  struct ConstructParams D.110752;
  int flags.1;
  const char * iftmp.2;
  bool D.115468;
  const struct Class & D.115472;
  const void * * iftmp.3;
  struct Object * D.115477;
  const void * * iftmp.4;
  struct ActionGroup * D.115482;
  const void * * iftmp.5;
  struct ActionMap * D.115487;
  int (*__vtbl_ptr_type) () * iftmp.6;
  sizetype iftmp.7;
  int (*__vtbl_ptr_type) () * D.115495;
  int (*__vtbl_ptr_type) () * D.115496;
  long int D.115497;
  struct ObjectBase * D.115499;
  int (*__vtbl_ptr_type) () * iftmp.8;
  int (*__vtbl_ptr_type) () * iftmp.9;
  int (*__vtbl_ptr_type) () * iftmp.10;
  const void * * iftmp.11;
  const void * * iftmp.12;
  const void * * iftmp.13;
  const void * * iftmp.14;

  if (0 != 0) goto <D.115454>; else goto <D.115455>;
  <D.115454>:
  D.115456 = &this->D.106838;
  sigc::trackable::trackable (D.115456);
  goto <D.115457>;
  <D.115455>:
  <D.115457>:
  try
    {
      if (0 != 0) goto <D.115458>; else goto <D.115459>;
      <D.115458>:
      if (0 == 0) goto <D.115461>; else goto <D.115462>;
      <D.115461>:
      iftmp.0 = __vtt_parm + 112;
      goto <D.115463>;
      <D.115462>:
      iftmp.0 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.115463>:
      D.115464 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.115464, iftmp.0, 0B);
      goto <D.115465>;
      <D.115459>:
      <D.115465>:
      try
        {
          flags.1 = (int) flags;
          D.115468 = Glib::ustring::empty (application_id);
          if (D.115468 != 0) goto <D.115469>; else goto <D.115470>;
          <D.115469>:
          iftmp.2 = 0B;
          goto <D.115471>;
          <D.115470>:
          iftmp.2 = Glib::ustring::c_str (application_id);
          <D.115471>:
          D.115472 = Gio::Application::custom_class_init (this);
          Glib::ConstructParams::ConstructParams (&D.110752, D.115472, "application_id", iftmp.2, "flags", flags.1, 0B);
          try
            {
              if (0 == 0) goto <D.115474>; else goto <D.115475>;
              <D.115474>:
              iftmp.3 = __vtt_parm + 8;
              goto <D.115476>;
              <D.115475>:
              iftmp.3 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.115476>:
              D.115477 = &this->D.106831;
              Glib::Object::Object (D.115477, iftmp.3, &D.110752);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.110752);
              D.110752 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.115479>; else goto <D.115480>;
              <D.115479>:
              iftmp.4 = __vtt_parm + 24;
              goto <D.115481>;
              <D.115480>:
              iftmp.4 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.115481>:
              D.115482 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.115482, iftmp.4);
              try
                {
                  if (0 == 0) goto <D.115484>; else goto <D.115485>;
                  <D.115484>:
                  iftmp.5 = __vtt_parm + 56;
                  goto <D.115486>;
                  <D.115485>:
                  iftmp.5 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.115486>:
                  D.115487 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.115487, iftmp.5);
                  try
                    {
                      if (0 == 0) goto <D.115489>; else goto <D.115490>;
                      <D.115489>:
                      iftmp.6 = *__vtt_parm;
                      goto <D.115491>;
                      <D.115490>:
                      iftmp.6 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.115491>:
                      this->D.106831._vptr.Object = iftmp.6;
                      if (0 == 0) goto <D.115493>; else goto <D.115494>;
                      <D.115493>:
                      D.115495 = this->D.106831._vptr.Object;
                      D.115496 = D.115495 + 18446744073709551592;
                      D.115497 = MEM[(long int *)D.115496];
                      iftmp.7 = (sizetype) D.115497;
                      goto <D.115498>;
                      <D.115494>:
                      iftmp.7 = 24;
                      <D.115498>:
                      D.115499 = this + iftmp.7;
                      if (0 == 0) goto <D.115501>; else goto <D.115502>;
                      <D.115501>:
                      iftmp.8 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.115503>;
                      <D.115502>:
                      iftmp.8 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.115503>:
                      D.115499->_vptr.ObjectBase = iftmp.8;
                      if (0 == 0) goto <D.115505>; else goto <D.115506>;
                      <D.115505>:
                      iftmp.9 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.115507>;
                      <D.115506>:
                      iftmp.9 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.115507>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.9;
                      if (0 == 0) goto <D.115509>; else goto <D.115510>;
                      <D.115509>:
                      iftmp.10 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.115511>;
                      <D.115510>:
                      iftmp.10 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.115511>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.10;
                    }
                  catch
                    {
                      if (0 == 0) goto <D.115513>; else goto <D.115514>;
                      <D.115513>:
                      iftmp.11 = __vtt_parm + 56;
                      goto <D.115515>;
                      <D.115514>:
                      iftmp.11 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.115515>:
                      D.115487 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.115487, iftmp.11);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.115517>; else goto <D.115518>;
                  <D.115517>:
                  iftmp.12 = __vtt_parm + 24;
                  goto <D.115519>;
                  <D.115518>:
                  iftmp.12 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.115519>:
                  D.115482 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.115482, iftmp.12);
                }
            }
          catch
            {
              if (0 == 0) goto <D.115521>; else goto <D.115522>;
              <D.115521>:
              iftmp.13 = __vtt_parm + 8;
              goto <D.115523>;
              <D.115522>:
              iftmp.13 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.115523>:
              D.115477 = &this->D.106831;
              Glib::Object::~Object (D.115477, iftmp.13);
            }
        }
      catch
        {
          if (0 != 0) goto <D.115524>; else goto <D.115525>;
          <D.115524>:
          if (0 == 0) goto <D.115527>; else goto <D.115528>;
          <D.115527>:
          iftmp.14 = __vtt_parm + 112;
          goto <D.115529>;
          <D.115528>:
          iftmp.14 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.115529>:
          D.115464 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.115464, iftmp.14);
          goto <D.115530>;
          <D.115525>:
          <D.115530>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.115531>; else goto <D.115532>;
      <D.115531>:
      D.115456 = &this->D.106838;
      sigc::trackable::~trackable (D.115456);
      goto <D.115533>;
      <D.115532>:
      <D.115533>:
    }
}


Gio::Application::Application(const Glib::ustring&, Gio::ApplicationFlags) (struct Application * const this, const struct ustring & application_id, ApplicationFlags flags)
{
  struct trackable * D.115545;
  const void * * iftmp.15;
  struct ObjectBase * D.115553;
  struct ConstructParams D.110754;
  int flags.16;
  const char * iftmp.17;
  bool D.115557;
  const struct Class & D.115561;
  const void * * iftmp.18;
  struct Object * D.115566;
  const void * * iftmp.19;
  struct ActionGroup * D.115571;
  const void * * iftmp.20;
  struct ActionMap * D.115576;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * D.115580;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.115585;
  int (*__vtbl_ptr_type) () * D.115586;
  long int D.115587;
  struct ObjectBase * D.115589;
  int (*__vtbl_ptr_type) () * iftmp.23;
  int (*__vtbl_ptr_type) () * iftmp.24;
  int (*__vtbl_ptr_type) () * iftmp.25;
  const void * * iftmp.26;
  const void * * iftmp.27;
  const void * * iftmp.28;
  const void * * iftmp.29;

  if (1 != 0) goto <D.115543>; else goto <D.115544>;
  <D.115543>:
  D.115545 = &this->D.106838;
  sigc::trackable::trackable (D.115545);
  goto <D.115546>;
  <D.115544>:
  <D.115546>:
  try
    {
      if (1 != 0) goto <D.115547>; else goto <D.115548>;
      <D.115547>:
      if (1 == 0) goto <D.115550>; else goto <D.115551>;
      <D.115550>:
      iftmp.15 = 112B;
      goto <D.115552>;
      <D.115551>:
      iftmp.15 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.115552>:
      D.115553 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.115553, iftmp.15, 0B);
      goto <D.115554>;
      <D.115548>:
      <D.115554>:
      try
        {
          flags.16 = (int) flags;
          D.115557 = Glib::ustring::empty (application_id);
          if (D.115557 != 0) goto <D.115558>; else goto <D.115559>;
          <D.115558>:
          iftmp.17 = 0B;
          goto <D.115560>;
          <D.115559>:
          iftmp.17 = Glib::ustring::c_str (application_id);
          <D.115560>:
          D.115561 = Gio::Application::custom_class_init (this);
          Glib::ConstructParams::ConstructParams (&D.110754, D.115561, "application_id", iftmp.17, "flags", flags.16, 0B);
          try
            {
              if (1 == 0) goto <D.115563>; else goto <D.115564>;
              <D.115563>:
              iftmp.18 = 8B;
              goto <D.115565>;
              <D.115564>:
              iftmp.18 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.115565>:
              D.115566 = &this->D.106831;
              Glib::Object::Object (D.115566, iftmp.18, &D.110754);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.110754);
              D.110754 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.115568>; else goto <D.115569>;
              <D.115568>:
              iftmp.19 = 24B;
              goto <D.115570>;
              <D.115569>:
              iftmp.19 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.115570>:
              D.115571 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.115571, iftmp.19);
              try
                {
                  if (1 == 0) goto <D.115573>; else goto <D.115574>;
                  <D.115573>:
                  iftmp.20 = 56B;
                  goto <D.115575>;
                  <D.115574>:
                  iftmp.20 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.115575>:
                  D.115576 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.115576, iftmp.20);
                  try
                    {
                      if (1 == 0) goto <D.115578>; else goto <D.115579>;
                      <D.115578>:
                      D.115580 = 0B;
                      iftmp.21 = *D.115580;
                      goto <D.115581>;
                      <D.115579>:
                      iftmp.21 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.115581>:
                      this->D.106831._vptr.Object = iftmp.21;
                      if (1 == 0) goto <D.115583>; else goto <D.115584>;
                      <D.115583>:
                      D.115585 = this->D.106831._vptr.Object;
                      D.115586 = D.115585 + 18446744073709551592;
                      D.115587 = MEM[(long int *)D.115586];
                      iftmp.22 = (sizetype) D.115587;
                      goto <D.115588>;
                      <D.115584>:
                      iftmp.22 = 24;
                      <D.115588>:
                      D.115589 = this + iftmp.22;
                      if (1 == 0) goto <D.115591>; else goto <D.115592>;
                      <D.115591>:
                      iftmp.23 = MEM[(const void * *)0B + 88B];
                      goto <D.115593>;
                      <D.115592>:
                      iftmp.23 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.115593>:
                      D.115589->_vptr.ObjectBase = iftmp.23;
                      if (1 == 0) goto <D.115595>; else goto <D.115596>;
                      <D.115595>:
                      iftmp.24 = MEM[(const void * *)0B + 96B];
                      goto <D.115597>;
                      <D.115596>:
                      iftmp.24 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.115597>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.24;
                      if (1 == 0) goto <D.115599>; else goto <D.115600>;
                      <D.115599>:
                      iftmp.25 = MEM[(const void * *)0B + 104B];
                      goto <D.115601>;
                      <D.115600>:
                      iftmp.25 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.115601>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.25;
                    }
                  catch
                    {
                      if (1 == 0) goto <D.115603>; else goto <D.115604>;
                      <D.115603>:
                      iftmp.26 = 56B;
                      goto <D.115605>;
                      <D.115604>:
                      iftmp.26 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.115605>:
                      D.115576 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.115576, iftmp.26);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.115607>; else goto <D.115608>;
                  <D.115607>:
                  iftmp.27 = 24B;
                  goto <D.115609>;
                  <D.115608>:
                  iftmp.27 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.115609>:
                  D.115571 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.115571, iftmp.27);
                }
            }
          catch
            {
              if (1 == 0) goto <D.115611>; else goto <D.115612>;
              <D.115611>:
              iftmp.28 = 8B;
              goto <D.115613>;
              <D.115612>:
              iftmp.28 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.115613>:
              D.115566 = &this->D.106831;
              Glib::Object::~Object (D.115566, iftmp.28);
            }
        }
      catch
        {
          if (1 != 0) goto <D.115614>; else goto <D.115615>;
          <D.115614>:
          if (1 == 0) goto <D.115617>; else goto <D.115618>;
          <D.115617>:
          iftmp.29 = 112B;
          goto <D.115619>;
          <D.115618>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.115619>:
          D.115553 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.115553, iftmp.29);
          goto <D.115620>;
          <D.115615>:
          <D.115620>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.115621>; else goto <D.115622>;
      <D.115621>:
      D.115545 = &this->D.106838;
      sigc::trackable::~trackable (D.115545);
      goto <D.115623>;
      <D.115622>:
      <D.115623>:
    }
}


Gio::Application::~Application() (struct Application * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.30;
  sizetype iftmp.31;
  int (*__vtbl_ptr_type) () * D.115639;
  int (*__vtbl_ptr_type) () * D.115640;
  long int D.115641;
  struct ObjectBase * D.115643;
  int (*__vtbl_ptr_type) () * iftmp.32;
  int (*__vtbl_ptr_type) () * iftmp.33;
  int (*__vtbl_ptr_type) () * iftmp.34;
  bool retval.35;
  struct pair * D.115657;
  struct OptionArgCallbackData * D.115658;
  const struct Application * D.115659;
  struct pair * D.115662;
  struct OptionArgCallbackData * D.115663;
  bool retval.36;
  struct iterator D.110790;
  const void * * iftmp.37;
  struct ActionMap * D.115673;
  const void * * iftmp.38;
  struct ActionGroup * D.115678;
  const void * * iftmp.39;
  struct Object * D.115683;
  int D.115684;
  const void * * iftmp.40;
  struct ObjectBase * D.115691;
  struct trackable * D.115695;
  int D.115697;

  {
    if (0 == 0) goto <D.115633>; else goto <D.115634>;
    <D.115633>:
    iftmp.30 = *__vtt_parm;
    goto <D.115635>;
    <D.115634>:
    iftmp.30 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
    <D.115635>:
    this->D.106831._vptr.Object = iftmp.30;
    if (0 == 0) goto <D.115637>; else goto <D.115638>;
    <D.115637>:
    D.115639 = this->D.106831._vptr.Object;
    D.115640 = D.115639 + 18446744073709551592;
    D.115641 = MEM[(long int *)D.115640];
    iftmp.31 = (sizetype) D.115641;
    goto <D.115642>;
    <D.115638>:
    iftmp.31 = 24;
    <D.115642>:
    D.115643 = this + iftmp.31;
    if (0 == 0) goto <D.115645>; else goto <D.115646>;
    <D.115645>:
    iftmp.32 = MEM[(const void * *)__vtt_parm + 88B];
    goto <D.115647>;
    <D.115646>:
    iftmp.32 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
    <D.115647>:
    D.115643->_vptr.ObjectBase = iftmp.32;
    if (0 == 0) goto <D.115649>; else goto <D.115650>;
    <D.115649>:
    iftmp.33 = MEM[(const void * *)__vtt_parm + 96B];
    goto <D.115651>;
    <D.115650>:
    iftmp.33 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
    <D.115651>:
    this->D.106832.D.96606._vptr.Interface = iftmp.33;
    if (0 == 0) goto <D.115653>; else goto <D.115654>;
    <D.115653>:
    iftmp.34 = MEM[(const void * *)__vtt_parm + 104B];
    goto <D.115655>;
    <D.115654>:
    iftmp.34 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
    <D.115655>:
    this->D.106833.D.97343._vptr.Interface = iftmp.34;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {
                        try
                          {
                            {
                              struct Lock lock;
                              struct iterator iter;

                              try
                                {
                                  Glib::Threads::Mutex::Lock::Lock (&lock, &option_arg_callback_data_mutex);
                                  try
                                    {
                                      iter = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::begin (&option_arg_callback_data);
                                      goto <D.110785>;
                                      <D.110786>:
                                      {
                                        struct iterator saved_iter;

                                        try
                                          {
                                            saved_iter = iter;
                                            std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator++ (&iter);
                                            D.115657 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&saved_iter);
                                            D.115658 = D.115657->second;
                                            D.115659 = {anonymous}::OptionArgCallbackData::get_application (D.115658);
                                            retval.35 = D.115659 == this;
                                            if (retval.35 != 0) goto <D.115660>; else goto <D.115661>;
                                            <D.115660>:
                                            D.115662 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&saved_iter);
                                            D.115663 = D.115662->second;
                                            if (D.115663 != 0B) goto <D.115664>; else goto <D.115665>;
                                            <D.115664>:
                                            {anonymous}::OptionArgCallbackData::~OptionArgCallbackData (D.115663);
                                            operator delete (D.115663);
                                            goto <D.115666>;
                                            <D.115665>:
                                            <D.115666>:
                                            std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::erase (&option_arg_callback_data, saved_iter);
                                            goto <D.115667>;
                                            <D.115661>:
                                            <D.115667>:
                                          }
                                        finally
                                          {
                                            saved_iter = {CLOBBER};
                                          }
                                      }
                                      <D.110785>:
                                      D.110790 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
                                      try
                                        {
                                          retval.36 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator!= (&iter, &D.110790);
                                        }
                                      finally
                                        {
                                          D.110790 = {CLOBBER};
                                        }
                                      if (retval.36 != 0) goto <D.110786>; else goto <D.110791>;
                                      <D.110791>:
                                    }
                                  finally
                                    {
                                      Glib::Threads::Mutex::Lock::~Lock (&lock);
                                    }
                                }
                              finally
                                {
                                  lock = {CLOBBER};
                                  iter = {CLOBBER};
                                }
                            }
                          }
                        finally
                          {
                            if (0 == 0) goto <D.115670>; else goto <D.115671>;
                            <D.115670>:
                            iftmp.37 = __vtt_parm + 56;
                            goto <D.115672>;
                            <D.115671>:
                            iftmp.37 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                            <D.115672>:
                            D.115673 = &this->D.106833;
                            Gio::ActionMap::~ActionMap (D.115673, iftmp.37);
                          }
                      }
                    finally
                      {
                        if (0 == 0) goto <D.115675>; else goto <D.115676>;
                        <D.115675>:
                        iftmp.38 = __vtt_parm + 24;
                        goto <D.115677>;
                        <D.115676>:
                        iftmp.38 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                        <D.115677>:
                        D.115678 = &this->D.106832;
                        Gio::ActionGroup::~ActionGroup (D.115678, iftmp.38);
                      }
                  }
                finally
                  {
                    if (0 == 0) goto <D.115680>; else goto <D.115681>;
                    <D.115680>:
                    iftmp.39 = __vtt_parm + 8;
                    goto <D.115682>;
                    <D.115681>:
                    iftmp.39 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
                    <D.115682>:
                    D.115683 = &this->D.106831;
                    Glib::Object::~Object (D.115683, iftmp.39);
                  }
              }
            finally
              {
                D.115684 = 0;
                if (D.115684 != 0) goto <D.115685>; else goto <D.115686>;
                <D.115685>:
                if (0 == 0) goto <D.115688>; else goto <D.115689>;
                <D.115688>:
                iftmp.40 = __vtt_parm + 112;
                goto <D.115690>;
                <D.115689>:
                iftmp.40 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
                <D.115690>:
                D.115691 = &this->D.106837;
                Glib::ObjectBase::~ObjectBase (D.115691, iftmp.40);
                goto <D.115692>;
                <D.115686>:
                <D.115692>:
              }
          }
        finally
          {
            D.115684 = 0;
            if (D.115684 != 0) goto <D.115693>; else goto <D.115694>;
            <D.115693>:
            D.115695 = &this->D.106838;
            sigc::trackable::~trackable (D.115695);
            goto <D.115696>;
            <D.115694>:
            <D.115696>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.110792>:
  D.115697 = 0;
  if (D.115697 != 0) goto <D.115698>; else goto <D.115699>;
  <D.115698>:
  operator delete (this);
  goto <D.115700>;
  <D.115699>:
  <D.115700>:
}


Glib::Threads::Mutex::Lock::Lock(Glib::Threads::Mutex&) (struct Lock * const this, struct Mutex & mutex)
{
  struct Mutex & D.115730;

  this->mutex_ = mutex;
  this->locked_ = 1;
  D.115730 = this->mutex_;
  Glib::Threads::Mutex::lock (D.115730);
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::begin() [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct map * const this)
{
  struct iterator D.115731;
  struct _Rep_type * D.115732;

  D.115732 = &this->_M_t;
  D.115731 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::begin (D.115732);
  return D.115731;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this)
{
  struct iterator D.115734;
  struct iterator D.114501;
  struct _Rb_tree_node_base * D.115735;

  D.115735 = this->_M_impl._M_header._M_left;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.114501, D.115735);
  try
    {
      D.115734 = D.114501;
      return D.115734;
    }
  finally
    {
      D.114501 = {CLOBBER};
    }
}


std::_Rb_tree_iterator<_Tp>::_Rb_tree_iterator(std::_Rb_tree_iterator<_Tp>::_Link_type) [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree_iterator * const this, struct _Rb_tree_node * __x)
{
  this->_M_node = __x;
}


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator++() [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.115738;
  struct _Rb_tree_node_base * D.115739;
  struct _Self & D.115740;

  D.115738 = this->_M_node;
  D.115739 = std::_Rb_tree_increment (D.115738);
  this->_M_node = D.115739;
  D.115740 = this;
  return D.115740;
}


const Gio::Application* {anonymous}::OptionArgCallbackData::get_application() const (const struct OptionArgCallbackData * const this)
{
  const struct Application * D.115742;

  D.115742 = this->application_;
  return D.115742;
}


_Tp* std::_Rb_tree_iterator<_Tp>::operator->() const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::pointer = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>*] (const struct _Rb_tree_iterator * const this)
{
  struct pair * D.115744;
  struct _Rb_tree_node_base * D.115745;

  D.115745 = this->_M_node;
  D.115744 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (D.115745);
  return D.115744;
}


_Val* std::_Rb_tree_node<_Val>::_M_valptr() [with _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct _Rb_tree_node * const this)
{
  struct pair * D.115748;
  struct pair * D.115749;

  D.115749 = &this->_M_value_field;
  D.115748 = std::__addressof<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > (D.115749);
  return D.115748;
}


_Tp* std::__addressof(_Tp&) [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct pair & __r)
{
  struct pair * D.115751;

  D.115751 = __r;
  return D.115751;
}


{anonymous}::OptionArgCallbackData::~OptionArgCallbackData() (struct OptionArgCallbackData * const this)
{
  struct SlotOptionArgString * D.115753;
  struct SlotOptionArgFilename * D.115757;

  {
    try
      {
        D.115753 = this->slot_string_;
        if (D.115753 != 0B) goto <D.115754>; else goto <D.115755>;
        <D.115754>:
        sigc::slot<bool, const Glib::ustring&, const Glib::ustring&, bool>::~slot (D.115753);
        operator delete (D.115753);
        goto <D.115756>;
        <D.115755>:
        <D.115756>:
        D.115757 = this->slot_filename_;
        if (D.115757 != 0B) goto <D.115758>; else goto <D.115759>;
        <D.115758>:
        sigc::slot<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::~slot (D.115757);
        operator delete (D.115757);
        goto <D.115760>;
        <D.115759>:
        <D.115760>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.109510>:
}


sigc::slot<bool, const Glib::ustring&, const Glib::ustring&, bool>::~slot() (struct slot * const this)
{
  struct slot3 * D.115762;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.115762 = &this->D.109303;
            sigc::slot3<bool, const Glib::ustring&, const Glib::ustring&, bool>::~slot3 (D.115762);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.109473>:
}


sigc::slot3<bool, const Glib::ustring&, const Glib::ustring&, bool>::~slot3() (struct slot3 * const this)
{
  struct slot_base * D.115764;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.115764 = &this->D.109261;
            sigc::slot_base::~slot_base (D.115764);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.109468>:
}


sigc::slot<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::~slot() (struct slot * const this)
{
  struct slot3 * D.115766;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.115766 = &this->D.109422;
            sigc::slot3<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::~slot3 (D.115766);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.109505>:
}


sigc::slot3<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::~slot3() (struct slot3 * const this)
{
  struct slot_base * D.115768;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.115768 = &this->D.109380;
            sigc::slot_base::~slot_base (D.115768);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.109500>:
}


void std::map<_Key, _Tp, _Compare, _Alloc>::erase(std::map<_Key, _Tp, _Compare, _Alloc>::iterator) [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct map * const this, struct iterator __position)
{
  struct _Rep_type * D.115770;

  D.115770 = &this->_M_t;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::erase (D.115770, __position);
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::erase(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this, struct iterator __position)
{
  struct const_iterator D.114509;

  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&D.114509, &__position);
  try
    {
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_erase_aux (this, D.114509);
    }
  finally
    {
      D.114509 = {CLOBBER};
    }
}


std::_Rb_tree_const_iterator<_Tp>::_Rb_tree_const_iterator(const iterator&) [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_const_iterator * const this, const struct iterator & __it)
{
  struct _Rb_tree_node_base * D.115772;

  D.115772 = __it->_M_node;
  this->_M_node = D.115772;
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase_aux(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this, struct const_iterator __position)
{
  struct _Rb_tree_node_base * D.115773;
  const struct _Rb_tree_node_base * D.115774;
  long unsigned int D.115775;
  long unsigned int D.115776;
  struct _Rb_tree_node * __y;

  D.115773 = &this->_M_impl._M_header;
  D.115774 = __position._M_node;
  __y = std::_Rb_tree_rebalance_for_erase (D.115774, D.115773);
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_destroy_node (this, __y);
  D.115775 = this->_M_impl._M_node_count;
  D.115776 = D.115775 + 18446744073709551615;
  this->_M_impl._M_node_count = D.115776;
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_destroy_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct pair * D.115777;
  struct allocator_type D.115028;

  D.115777 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (__p);
  D.115028 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::get_allocator (this); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::destroy (&D.115028, D.115777);
    }
  finally
    {
      std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::~allocator (&D.115028);
      D.115028 = {CLOBBER};
    }
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_put_node (this, __p);
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::get_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.115781;

  D.115781 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_Node_allocator (this);
  std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > > (<retval>, D.115781);
  return <retval>;
}


const _Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.115783;

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


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator<_Tp1>&) [with _Tp1 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct allocator * const this, const struct allocator & D.115142)
{
  void * D.115785;

  try
    {
      {
        __gnu_cxx::new_allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.115785 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.115785);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct new_allocator * const this)
{
  void * D.115786;

  try
    {
      {

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


void __gnu_cxx::new_allocator<_Tp>::destroy(__gnu_cxx::new_allocator<_Tp>::pointer) [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>*] (struct new_allocator * const this, struct pair * __p)
{
  std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::~pair (__p);
}


std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::~pair() (struct pair * const this)
{
  const struct ustring * D.115787;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.115787 = &this->first;
            Glib::ustring::~ustring (D.115787);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114056>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_put_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct _Node_allocator & D.115789;

  D.115789 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_Node_allocator (this);
  __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > > >::deallocate (D.115789, __p, 1);
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >] (struct _Rb_tree * const this)
{
  struct _Node_allocator & D.115790;

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


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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.115157>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.115792 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.115792);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct new_allocator * const this)
{
  void * D.115793;

  try
    {
      {
        try
          {

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


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::end() [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct map * const this)
{
  struct iterator D.115794;
  struct _Rep_type * D.115795;

  D.115795 = &this->_M_t;
  D.115794 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::end (D.115795);
  return D.115794;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::end() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this)
{
  struct iterator D.115797;
  struct iterator D.114492;
  struct _Rb_tree_node_base * D.115798;

  D.115798 = &this->_M_impl._M_header;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.114492, D.115798);
  try
    {
      D.115797 = D.114492;
      return D.115797;
    }
  finally
    {
      D.114492 = {CLOBBER};
    }
}


bool std::_Rb_tree_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree_iterator * const this, const struct _Self & __x)
{
  bool D.115801;
  struct _Rb_tree_node_base * D.115802;
  struct _Rb_tree_node_base * D.115803;

  D.115802 = this->_M_node;
  D.115803 = __x->_M_node;
  D.115801 = D.115802 != D.115803;
  return D.115801;
}


Glib::Threads::Mutex::Lock::~Lock() (struct Lock * const this)
{
  bool D.115805;
  struct Mutex & D.115808;

  {
    try
      {
        D.115805 = this->locked_;
        if (D.115805 != 0) goto <D.115806>; else goto <D.115807>;
        <D.115806>:
        D.115808 = this->mutex_;
        Glib::Threads::Mutex::unlock (D.115808);
        goto <D.115809>;
        <D.115807>:
        <D.115809>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.59006>:
}


virtual Gio::Application::~Application() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * D.115814;
  sizetype iftmp.42;
  int (*__vtbl_ptr_type) () * D.115819;
  int (*__vtbl_ptr_type) () * D.115820;
  long int D.115821;
  struct ObjectBase * D.115823;
  int (*__vtbl_ptr_type) () * iftmp.43;
  int (*__vtbl_ptr_type) () * iftmp.44;
  int (*__vtbl_ptr_type) () * iftmp.45;
  bool retval.46;
  struct pair * D.115837;
  struct OptionArgCallbackData * D.115838;
  const struct Application * D.115839;
  struct pair * D.115842;
  struct OptionArgCallbackData * D.115843;
  bool retval.47;
  struct iterator D.110803;
  const void * * iftmp.48;
  struct ActionMap * D.115853;
  const void * * iftmp.49;
  struct ActionGroup * D.115858;
  const void * * iftmp.50;
  struct Object * D.115863;
  int D.115864;
  const void * * iftmp.51;
  struct ObjectBase * D.115871;
  struct trackable * D.115875;
  int D.115877;

  {
    if (2 == 0) goto <D.115812>; else goto <D.115813>;
    <D.115812>:
    D.115814 = 0B;
    iftmp.41 = *D.115814;
    goto <D.115815>;
    <D.115813>:
    iftmp.41 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
    <D.115815>:
    this->D.106831._vptr.Object = iftmp.41;
    if (2 == 0) goto <D.115817>; else goto <D.115818>;
    <D.115817>:
    D.115819 = this->D.106831._vptr.Object;
    D.115820 = D.115819 + 18446744073709551592;
    D.115821 = MEM[(long int *)D.115820];
    iftmp.42 = (sizetype) D.115821;
    goto <D.115822>;
    <D.115818>:
    iftmp.42 = 24;
    <D.115822>:
    D.115823 = this + iftmp.42;
    if (2 == 0) goto <D.115825>; else goto <D.115826>;
    <D.115825>:
    iftmp.43 = MEM[(const void * *)0B + 88B];
    goto <D.115827>;
    <D.115826>:
    iftmp.43 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
    <D.115827>:
    D.115823->_vptr.ObjectBase = iftmp.43;
    if (2 == 0) goto <D.115829>; else goto <D.115830>;
    <D.115829>:
    iftmp.44 = MEM[(const void * *)0B + 96B];
    goto <D.115831>;
    <D.115830>:
    iftmp.44 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
    <D.115831>:
    this->D.106832.D.96606._vptr.Interface = iftmp.44;
    if (2 == 0) goto <D.115833>; else goto <D.115834>;
    <D.115833>:
    iftmp.45 = MEM[(const void * *)0B + 104B];
    goto <D.115835>;
    <D.115834>:
    iftmp.45 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
    <D.115835>:
    this->D.106833.D.97343._vptr.Interface = iftmp.45;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {
                        try
                          {
                            {
                              struct Lock lock;
                              struct iterator iter;

                              try
                                {
                                  Glib::Threads::Mutex::Lock::Lock (&lock, &option_arg_callback_data_mutex);
                                  try
                                    {
                                      iter = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::begin (&option_arg_callback_data);
                                      goto <D.110798>;
                                      <D.110799>:
                                      {
                                        struct iterator saved_iter;

                                        try
                                          {
                                            saved_iter = iter;
                                            std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator++ (&iter);
                                            D.115837 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&saved_iter);
                                            D.115838 = D.115837->second;
                                            D.115839 = {anonymous}::OptionArgCallbackData::get_application (D.115838);
                                            retval.46 = D.115839 == this;
                                            if (retval.46 != 0) goto <D.115840>; else goto <D.115841>;
                                            <D.115840>:
                                            D.115842 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&saved_iter);
                                            D.115843 = D.115842->second;
                                            if (D.115843 != 0B) goto <D.115844>; else goto <D.115845>;
                                            <D.115844>:
                                            {anonymous}::OptionArgCallbackData::~OptionArgCallbackData (D.115843);
                                            operator delete (D.115843);
                                            goto <D.115846>;
                                            <D.115845>:
                                            <D.115846>:
                                            std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::erase (&option_arg_callback_data, saved_iter);
                                            goto <D.115847>;
                                            <D.115841>:
                                            <D.115847>:
                                          }
                                        finally
                                          {
                                            saved_iter = {CLOBBER};
                                          }
                                      }
                                      <D.110798>:
                                      D.110803 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
                                      try
                                        {
                                          retval.47 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator!= (&iter, &D.110803);
                                        }
                                      finally
                                        {
                                          D.110803 = {CLOBBER};
                                        }
                                      if (retval.47 != 0) goto <D.110799>; else goto <D.110804>;
                                      <D.110804>:
                                    }
                                  finally
                                    {
                                      Glib::Threads::Mutex::Lock::~Lock (&lock);
                                    }
                                }
                              finally
                                {
                                  lock = {CLOBBER};
                                  iter = {CLOBBER};
                                }
                            }
                          }
                        finally
                          {
                            if (2 == 0) goto <D.115850>; else goto <D.115851>;
                            <D.115850>:
                            iftmp.48 = 56B;
                            goto <D.115852>;
                            <D.115851>:
                            iftmp.48 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                            <D.115852>:
                            D.115853 = &this->D.106833;
                            Gio::ActionMap::~ActionMap (D.115853, iftmp.48);
                          }
                      }
                    finally
                      {
                        if (2 == 0) goto <D.115855>; else goto <D.115856>;
                        <D.115855>:
                        iftmp.49 = 24B;
                        goto <D.115857>;
                        <D.115856>:
                        iftmp.49 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                        <D.115857>:
                        D.115858 = &this->D.106832;
                        Gio::ActionGroup::~ActionGroup (D.115858, iftmp.49);
                      }
                  }
                finally
                  {
                    if (2 == 0) goto <D.115860>; else goto <D.115861>;
                    <D.115860>:
                    iftmp.50 = 8B;
                    goto <D.115862>;
                    <D.115861>:
                    iftmp.50 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
                    <D.115862>:
                    D.115863 = &this->D.106831;
                    Glib::Object::~Object (D.115863, iftmp.50);
                  }
              }
            finally
              {
                D.115864 = 2;
                if (D.115864 != 0) goto <D.115865>; else goto <D.115866>;
                <D.115865>:
                if (2 == 0) goto <D.115868>; else goto <D.115869>;
                <D.115868>:
                iftmp.51 = 112B;
                goto <D.115870>;
                <D.115869>:
                iftmp.51 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
                <D.115870>:
                D.115871 = &this->D.106837;
                Glib::ObjectBase::~ObjectBase (D.115871, iftmp.51);
                goto <D.115872>;
                <D.115866>:
                <D.115872>:
              }
          }
        finally
          {
            D.115864 = 2;
            if (D.115864 != 0) goto <D.115873>; else goto <D.115874>;
            <D.115873>:
            D.115875 = &this->D.106838;
            sigc::trackable::~trackable (D.115875);
            goto <D.115876>;
            <D.115874>:
            <D.115876>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.110805>:
  D.115877 = 0;
  if (D.115877 != 0) goto <D.115878>; else goto <D.115879>;
  <D.115878>:
  operator delete (this);
  goto <D.115880>;
  <D.115879>:
  <D.115880>:
}


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


static void Gio::Application::unset_default() ()
{
  g_application_set_default (0B);
}


static void Gio::Application_Class::open_callback(GApplication*, GFile**, gint, const gchar*) (struct GApplication * self, struct GFile * * files, gint n_files, const gchar * hint)
{
  bool retval.52;
  bool iftmp.53;
  bool D.115915;
  struct CppObjectType * const iftmp.54;
  struct allocator_type D.110843;
  struct value_type D.110841;
  long unsigned int D.115925;
  struct RefPtr D.110845;
  long unsigned int D.115926;
  long unsigned int D.115927;
  struct GFile * * D.115928;
  struct GFile * D.115929;
  long unsigned int D.115930;
  struct RefPtr & D.115931;
  int (*__vtbl_ptr_type) () * D.115935;
  int (*__vtbl_ptr_type) () * D.115936;
  int (*__vtbl_ptr_type) () D.115937;
  void * D.115938;
  struct GTypeClass * D.115941;
  void (*<Tf93a>) (struct GApplication *, struct GFile * *, gint, const gchar *) D.115944;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.115914>; else goto <D.115912>;
    <D.115914>:
    D.115915 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.115915 != 0) goto <D.115916>; else goto <D.115912>;
    <D.115916>:
    iftmp.53 = 1;
    goto <D.115913>;
    <D.115912>:
    iftmp.53 = 0;
    <D.115913>:
    retval.52 = iftmp.53;
    if (retval.52 != 0) goto <D.115917>; else goto <D.115918>;
    <D.115917>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.115920>; else goto <D.115921>;
      <D.115920>:
      iftmp.54 = 0B;
      goto <D.115922>;
      <D.115921>:
      iftmp.54 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.115922>:
      obj = iftmp.54;
      {
        if (obj != 0B) goto <D.115923>; else goto <D.115924>;
        <D.115923>:
        {
          try
            {
              {
                struct type_vec_files vec_files;
                const struct ustring hint_str;

                try
                  {
                    std::allocator<Glib::RefPtr<Gio::File> >::allocator (&D.110843);
                    try
                      {
                        Glib::RefPtr<Gio::File>::RefPtr (&D.110841);
                        try
                          {
                            D.115925 = (long unsigned int) n_files;
                            std::vector<Glib::RefPtr<Gio::File> >::vector (&vec_files, D.115925, &D.110841, &D.110843);
                          }
                        finally
                          {
                            try
                              {
                                Glib::RefPtr<Gio::File>::~RefPtr (&D.110841);
                              }
                            catch
                              {
                                std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
                              }
                            D.110841 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        try
                          {
                            std::allocator<Glib::RefPtr<Gio::File> >::~allocator (&D.110843);
                          }
                        catch
                          {
                            std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
                          }
                        D.110843 = {CLOBBER};
                      }
                    try
                      {
                        {
                          int i;

                          i = 0;
                          goto <D.110854>;
                          <D.110853>:
                          D.115926 = (long unsigned int) i;
                          D.115927 = D.115926 * 8;
                          D.115928 = files + D.115927;
                          D.115929 = *D.115928;
                          D.110845 = Glib::wrap (D.115929, 1); [return slot optimization]
                          try
                            {
                              D.115930 = (long unsigned int) i;
                              D.115931 = std::vector<Glib::RefPtr<Gio::File> >::operator[] (&vec_files, D.115930);
                              Glib::RefPtr<Gio::File>::operator= (D.115931, &D.110845);
                            }
                          finally
                            {
                              Glib::RefPtr<Gio::File>::~RefPtr (&D.110845);
                              D.110845 = {CLOBBER};
                            }
                          i = i + 1;
                          <D.110854>:
                          if (i < n_files) goto <D.110853>; else goto <D.110851>;
                          <D.110851>:
                        }
                        if (hint != 0B) goto <D.115932>; else goto <D.115933>;
                        <D.115932>:
                        Glib::ustring::ustring (&hint_str, hint);
                        goto <D.115934>;
                        <D.115933>:
                        Glib::ustring::ustring (&hint_str);
                        <D.115934>:
                        try
                          {
                            D.115935 = obj->D.106831._vptr.Object;
                            D.115936 = D.115935 + 16;
                            D.115937 = *D.115936;
                            OBJ_TYPE_REF(D.115937;(struct Application)obj->2) (obj, &vec_files, &hint_str);
                            return;
                          }
                        finally
                          {
                            Glib::ustring::~ustring (&hint_str);
                          }
                      }
                    finally
                      {
                        std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
                      }
                  }
                finally
                  {
                    vec_files = {CLOBBER};
                    hint_str = {CLOBBER};
                  }
              }
            }
          catch
            {
              catch (NULL)
                {
                  try
                    {
                      D.115938 = __builtin_eh_pointer (0);
                      __cxa_begin_catch (D.115938);
                      Glib::exception_handlers_invoke ();
                    }
                  finally
                    {
                      __cxa_end_catch ();
                    }
                }
            }
        }
        goto <D.115939>;
        <D.115924>:
        <D.115939>:
      }
    }
    goto <D.115940>;
    <D.115918>:
    <D.115940>:
  }
  D.115941 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.115941);
  if (base != 0B) goto <D.115942>; else goto <D.115943>;
  <D.115942>:
  D.115944 = base->open;
  if (D.115944 != 0B) goto <D.115945>; else goto <D.115946>;
  <D.115945>:
  D.115944 = base->open;
  D.115944 (self, files, n_files, hint);
  goto <D.115947>;
  <D.115946>:
  <D.115947>:
  <D.115943>:
}


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

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

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


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

  try
    {
      {

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


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


std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>::size_type, const value_type&, const allocator_type&) [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int; std::vector<_Tp, _Alloc>::value_type = Glib::RefPtr<Gio::File>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::RefPtr<Gio::File> >] (struct vector * const this, size_type __n, const struct value_type & __value, const struct allocator_type & __a)
{
  struct _Vector_base * D.115967;

  D.115967 = &this->D.108979;
  std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_Vector_base (D.115967, __n, __a);
  try
    {
      std::vector<Glib::RefPtr<Gio::File> >::_M_fill_initialize (this, __n, __value);
    }
  catch
    {
      D.115967 = &this->D.108979;
      std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::~_Vector_base (D.115967);
    }
}


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

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


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


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

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

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


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

  try
    {
      {

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


void std::_Vector_base<_Tp, _Alloc>::_M_create_storage(std::size_t) [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct RefPtr * D.115973;
  struct RefPtr * D.115974;
  long unsigned int D.115975;
  struct RefPtr * D.115976;

  D.115973 = std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_M_allocate (this, __n);
  this->_M_impl._M_start = D.115973;
  D.115974 = this->_M_impl._M_start;
  this->_M_impl._M_finish = D.115974;
  D.115974 = this->_M_impl._M_start;
  D.115975 = __n * 8;
  D.115976 = D.115974 + D.115975;
  this->_M_impl._M_end_of_storage = D.115976;
}


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

  if (__n != 0) goto <D.115980>; else goto <D.115981>;
  <D.115980>:
  D.115982 = &this->_M_impl;
  iftmp.55 = __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::File> > >::allocate (D.115982, __n);
  goto <D.115983>;
  <D.115981>:
  iftmp.55 = 0B;
  <D.115983>:
  D.115978 = iftmp.55;
  return D.115978;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::RefPtr<Gio::File>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Gio::File>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.108292)
{
  bool retval.56;
  long unsigned int D.115990;
  struct RefPtr * D.115993;
  long unsigned int D.115994;

  D.115990 = __gnu_cxx::new_allocator<Glib::RefPtr<Gio::File> >::max_size (this);
  retval.56 = D.115990 < __n;
  if (retval.56 != 0) goto <D.115991>; else goto <D.115992>;
  <D.115991>:
  std::__throw_bad_alloc ();
  <D.115992>:
  D.115994 = __n * 8;
  D.115993 = operator new (D.115994);
  return D.115993;
}


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

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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


void std::vector<_Tp, _Alloc>::_M_fill_initialize(std::vector<_Tp, _Alloc>::size_type, const value_type&) [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int; std::vector<_Tp, _Alloc>::value_type = Glib::RefPtr<Gio::File>] (struct vector * const this, size_type __n, const struct value_type & __value)
{
  struct _Vector_base * D.116002;
  struct _Tp_alloc_type & D.116003;
  struct RefPtr * D.116004;
  struct RefPtr * D.116005;

  D.116002 = &this->D.108979;
  D.116003 = std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_M_get_Tp_allocator (D.116002);
  D.116004 = this->D.108979._M_impl._M_start;
  std::__uninitialized_fill_n_a<Glib::RefPtr<Gio::File>*, long unsigned int, Glib::RefPtr<Gio::File>, Glib::RefPtr<Gio::File> > (D.116004, __n, __value, D.116003);
  D.116005 = this->D.108979._M_impl._M_end_of_storage;
  this->D.108979._M_impl._M_finish = D.116005;
}


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

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


void std::__uninitialized_fill_n_a(_ForwardIterator, _Size, const _Tp&, std::allocator<_Tp2>&) [with _ForwardIterator = Glib::RefPtr<Gio::File>*; _Size = long unsigned int; _Tp = Glib::RefPtr<Gio::File>; _Tp2 = Glib::RefPtr<Gio::File>] (struct RefPtr * __first, long unsigned int __n, const struct RefPtr & __x, struct allocator & D.114380)
{
  std::uninitialized_fill_n<Glib::RefPtr<Gio::File>*, long unsigned int, Glib::RefPtr<Gio::File> > (__first, __n, __x);
}


void std::uninitialized_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = Glib::RefPtr<Gio::File>*; _Size = long unsigned int; _Tp = Glib::RefPtr<Gio::File>] (struct RefPtr * __first, long unsigned int __n, const struct RefPtr & __x)
{
  typedef struct _ValueType _ValueType;
  const bool __assignable;

  __assignable = 1;
  std::__uninitialized_fill_n<false>::__uninit_fill_n<Glib::RefPtr<Gio::File>*, long unsigned int, Glib::RefPtr<Gio::File> > (__first, __n, __x);
}


static void std::__uninitialized_fill_n<_TrivialValueType>::__uninit_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = Glib::RefPtr<Gio::File>*; _Size = long unsigned int; _Tp = Glib::RefPtr<Gio::File>; bool _TrivialValueType = false] (struct RefPtr * __first, long unsigned int __n, const struct RefPtr & __x)
{
  struct RefPtr * D.116008;
  void * D.116009;
  struct RefPtr * __cur;

  __cur = __first;
  try
    {
      goto <D.115121>;
      <D.115120>:
      D.116008 = std::__addressof<Glib::RefPtr<Gio::File> > (__cur);
      std::_Construct<Glib::RefPtr<Gio::File>, Glib::RefPtr<Gio::File> > (D.116008, __x);
      __n = __n + 18446744073709551615;
      __cur = __cur + 8;
      <D.115121>:
      if (__n != 0) goto <D.115120>; else goto <D.115118>;
      <D.115118>:
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.116009 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.116009);
              std::_Destroy<Glib::RefPtr<Gio::File>*> (__first, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


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

  D.116013 = __r;
  return D.116013;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::RefPtr<Gio::File>; _T2 = Glib::RefPtr<Gio::File>] (struct RefPtr * __p, const struct RefPtr & __value)
{
  void * D.115295;
  void * D.115296;
  struct RefPtr * iftmp.57;

  D.115295 = __p;
  D.115296 = operator new (8, D.115295);
  if (D.115296 != 0B) goto <D.116016>; else goto <D.116017>;
  <D.116016>:
  try
    {
      Glib::RefPtr<Gio::File>::RefPtr (D.115296, __value);
    }
  catch
    {
      operator delete (D.115296, D.115295);
    }
  iftmp.57 = D.115296;
  goto <D.116018>;
  <D.116017>:
  iftmp.57 = D.115296;
  <D.116018>:
}


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

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


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::File] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct File * D.116023;
  struct File * D.116024;
  int (*__vtbl_ptr_type) () * D.116027;
  int (*__vtbl_ptr_type) () * D.116028;
  long int D.116029;
  sizetype D.116030;
  struct ObjectBase * D.116031;
  int (*__vtbl_ptr_type) () * D.116032;
  int (*__vtbl_ptr_type) () * D.116033;
  int (*__vtbl_ptr_type) () D.116034;

  D.116023 = src->pCppObject_;
  this->pCppObject_ = D.116023;
  D.116024 = this->pCppObject_;
  if (D.116024 != 0B) goto <D.116025>; else goto <D.116026>;
  <D.116025>:
  D.116024 = this->pCppObject_;
  D.116024 = this->pCppObject_;
  D.116027 = D.116024->D.102671._vptr.Interface;
  D.116028 = D.116027 + 18446744073709551592;
  D.116029 = MEM[(long int *)D.116028];
  D.116030 = (sizetype) D.116029;
  D.116031 = D.116024 + D.116030;
  D.116024 = this->pCppObject_;
  D.116024 = this->pCppObject_;
  D.116027 = D.116024->D.102671._vptr.Interface;
  D.116028 = D.116027 + 18446744073709551592;
  D.116029 = MEM[(long int *)D.116028];
  D.116030 = (sizetype) D.116029;
  D.116031 = D.116024 + D.116030;
  D.116032 = D.116031->_vptr.ObjectBase;
  D.116033 = D.116032 + 16;
  D.116034 = *D.116033;
  D.116024 = this->pCppObject_;
  D.116024 = this->pCppObject_;
  D.116027 = D.116024->D.102671._vptr.Interface;
  D.116028 = D.116027 + 18446744073709551592;
  D.116029 = MEM[(long int *)D.116028];
  D.116030 = (sizetype) D.116029;
  D.116031 = D.116024 + D.116030;
  OBJ_TYPE_REF(D.116034;(const struct ObjectBase)D.116031->2) (D.116031);
  goto <D.116035>;
  <D.116026>:
  <D.116035>:
}


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

  try
    {

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


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

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


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

  goto <D.115010>;
  <D.115009>:
  D.116037 = std::__addressof<Glib::RefPtr<Gio::File> > (__first);
  std::_Destroy<Glib::RefPtr<Gio::File> > (D.116037);
  __first = __first + 8;
  <D.115010>:
  if (__first != __last) goto <D.115009>; else goto <D.115007>;
  <D.115007>:
}


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


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >] (struct _Vector_base * const this)
{
  struct RefPtr * D.116038;
  long int D.116039;
  struct RefPtr * D.116040;
  long int D.116041;
  long int D.116042;
  long int D.116043;
  long unsigned int D.116044;
  struct _Vector_impl * D.116045;

  {
    try
      {
        try
          {
            D.116038 = this->_M_impl._M_end_of_storage;
            D.116039 = (long int) D.116038;
            D.116040 = this->_M_impl._M_start;
            D.116041 = (long int) D.116040;
            D.116042 = D.116039 - D.116041;
            D.116043 = D.116042 /[ex] 8;
            D.116044 = (long unsigned int) D.116043;
            D.116040 = this->_M_impl._M_start;
            std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_M_deallocate (this, D.116040, D.116044);
          }
        finally
          {
            D.116045 = &this->_M_impl;
            std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_Vector_impl::~_Vector_impl (D.116045);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114372>:
}


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

  if (__p != 0B) goto <D.116048>; else goto <D.116049>;
  <D.116048>:
  D.116050 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::RefPtr<Gio::File> > >::deallocate (D.116050, __p, __n);
  goto <D.116051>;
  <D.116049>:
  <D.116051>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::RefPtr<Gio::File>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct RefPtr * __p, size_type __n)
{
  __gnu_cxx::new_allocator<Glib::RefPtr<Gio::File> >::deallocate (__a, __p, __n);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = Glib::RefPtr<Gio::File>; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::RefPtr<Gio::File>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct RefPtr * __p, size_type D.108296)
{
  operator delete (__p);
}


std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::operator[](std::vector<_Tp, _Alloc>::size_type) [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::vector<_Tp, _Alloc>::reference = Glib::RefPtr<Gio::File>&; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (struct vector * const this, size_type __n)
{
  struct RefPtr & D.116052;
  struct RefPtr * D.116053;
  long unsigned int D.116054;

  D.116053 = this->D.108979._M_impl._M_start;
  D.116054 = __n * 8;
  D.116052 = D.116053 + D.116054;
  return D.116052;
}


Glib::RefPtr<T_CppObject>& Glib::RefPtr<T_CppObject>::operator=(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::File] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct RefPtr & D.116056;
  struct RefPtr temp;

  try
    {
      Glib::RefPtr<Gio::File>::RefPtr (&temp, src);
      try
        {
          Glib::RefPtr<Gio::File>::swap (this, &temp);
          D.116056 = this;
          return D.116056;
        }
      finally
        {
          Glib::RefPtr<Gio::File>::~RefPtr (&temp);
        }
    }
  finally
    {
      temp = {CLOBBER};
    }
}


void Glib::RefPtr<T_CppObject>::swap(Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::File] (struct RefPtr * const this, struct RefPtr & other)
{
  struct File * D.116061;
  struct File * const temp;

  temp = this->pCppObject_;
  D.116061 = other->pCppObject_;
  this->pCppObject_ = D.116061;
  other->pCppObject_ = temp;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::File] (struct RefPtr * const this)
{
  struct File * D.116062;
  int (*__vtbl_ptr_type) () * D.116065;
  int (*__vtbl_ptr_type) () * D.116066;
  long int D.116067;
  sizetype D.116068;
  struct ObjectBase * D.116069;
  int (*__vtbl_ptr_type) () * D.116070;
  int (*__vtbl_ptr_type) () * D.116071;
  int (*__vtbl_ptr_type) () D.116072;

  {
    try
      {
        D.116062 = this->pCppObject_;
        if (D.116062 != 0B) goto <D.116063>; else goto <D.116064>;
        <D.116063>:
        D.116062 = this->pCppObject_;
        D.116062 = this->pCppObject_;
        D.116065 = D.116062->D.102671._vptr.Interface;
        D.116066 = D.116065 + 18446744073709551592;
        D.116067 = MEM[(long int *)D.116066];
        D.116068 = (sizetype) D.116067;
        D.116069 = D.116062 + D.116068;
        D.116062 = this->pCppObject_;
        D.116062 = this->pCppObject_;
        D.116065 = D.116062->D.102671._vptr.Interface;
        D.116066 = D.116065 + 18446744073709551592;
        D.116067 = MEM[(long int *)D.116066];
        D.116068 = (sizetype) D.116067;
        D.116069 = D.116062 + D.116068;
        D.116070 = D.116069->_vptr.ObjectBase;
        D.116071 = D.116070 + 24;
        D.116072 = *D.116071;
        D.116062 = this->pCppObject_;
        D.116062 = this->pCppObject_;
        D.116065 = D.116062->D.102671._vptr.Interface;
        D.116066 = D.116065 + 18446744073709551592;
        D.116067 = MEM[(long int *)D.116066];
        D.116068 = (sizetype) D.116067;
        D.116069 = D.116062 + D.116068;
        OBJ_TYPE_REF(D.116072;(const struct ObjectBase)D.116069->3) (D.116069);
        goto <D.116073>;
        <D.116064>:
        <D.116073>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.113693>:
}


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >] (struct vector * const this)
{
  struct _Vector_base * D.116075;
  struct _Tp_alloc_type & D.116076;
  struct RefPtr * D.116077;
  struct RefPtr * D.116078;

  {
    try
      {
        try
          {
            D.116075 = &this->D.108979;
            D.116076 = std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::_M_get_Tp_allocator (D.116075);
            D.116077 = this->D.108979._M_impl._M_finish;
            D.116078 = this->D.108979._M_impl._M_start;
            std::_Destroy<Glib::RefPtr<Gio::File>*, Glib::RefPtr<Gio::File> > (D.116078, D.116077, D.116076);
          }
        finally
          {
            D.116075 = &this->D.108979;
            std::_Vector_base<Glib::RefPtr<Gio::File>, std::allocator<Glib::RefPtr<Gio::File> > >::~_Vector_base (D.116075);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.113797>:
}


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


Glib::SignalProxy2<void, const std::vector<Glib::RefPtr<Gio::File> >&, const Glib::ustring&> Gio::Application::signal_open() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.116082;
  int (*__vtbl_ptr_type) () * D.116083;
  long int D.116084;
  sizetype D.116085;
  struct ObjectBase * D.116086;

  D.116082 = this->D.106831._vptr.Object;
  D.116083 = D.116082 + 18446744073709551592;
  D.116084 = MEM[(long int *)D.116083];
  D.116085 = (sizetype) D.116084;
  D.116086 = this + D.116085;
  Glib::SignalProxy2<void, const std::vector<Glib::RefPtr<Gio::File> >&, const Glib::ustring&>::SignalProxy2 (<retval>, D.116086, &Application_signal_open_info);
  return <retval>;
}


void {anonymous}::Application_signal_open_notify_callback(GApplication*, GFile**, gint, const gchar*, void*) (struct GApplication * self, struct GFile * * files, gint n_files, const gchar * hint, void * data)
{
  struct allocator_type D.109114;
  struct value_type D.109112;
  long unsigned int D.116088;
  struct RefPtr D.109116;
  long unsigned int D.116089;
  long unsigned int D.116090;
  struct GFile * * D.116091;
  struct GFile * D.116092;
  long unsigned int D.116093;
  struct RefPtr & D.116094;
  bool retval.58;
  struct ObjectBase * D.116099;
  struct slot2 * D.116104;
  void * D.116105;
  typedef struct SlotType SlotType;
  struct type_vec_files vec_files;
  const struct ustring hint_str;

  try
    {
      std::allocator<Glib::RefPtr<Gio::File> >::allocator (&D.109114);
      try
        {
          Glib::RefPtr<Gio::File>::RefPtr (&D.109112);
          try
            {
              D.116088 = (long unsigned int) n_files;
              std::vector<Glib::RefPtr<Gio::File> >::vector (&vec_files, D.116088, &D.109112, &D.109114);
            }
          finally
            {
              try
                {
                  Glib::RefPtr<Gio::File>::~RefPtr (&D.109112);
                }
              catch
                {
                  std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
                }
              D.109112 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<Glib::RefPtr<Gio::File> >::~allocator (&D.109114);
            }
          catch
            {
              std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
            }
          D.109114 = {CLOBBER};
        }
      try
        {
          {
            int i;

            i = 0;
            goto <D.109126>;
            <D.109125>:
            D.116089 = (long unsigned int) i;
            D.116090 = D.116089 * 8;
            D.116091 = files + D.116090;
            D.116092 = *D.116091;
            D.109116 = Glib::wrap (D.116092, 1); [return slot optimization]
            try
              {
                D.116093 = (long unsigned int) i;
                D.116094 = std::vector<Glib::RefPtr<Gio::File> >::operator[] (&vec_files, D.116093);
                Glib::RefPtr<Gio::File>::operator= (D.116094, &D.109116);
              }
            finally
              {
                Glib::RefPtr<Gio::File>::~RefPtr (&D.109116);
                D.109116 = {CLOBBER};
              }
            i = i + 1;
            <D.109126>:
            if (i < n_files) goto <D.109125>; else goto <D.109123>;
            <D.109123>:
          }
          if (hint != 0B) goto <D.116095>; else goto <D.116096>;
          <D.116095>:
          Glib::ustring::ustring (&hint_str, hint);
          goto <D.116097>;
          <D.116096>:
          Glib::ustring::ustring (&hint_str);
          <D.116097>:
          try
            {
              {
                D.116099 = Glib::ObjectBase::_get_current_wrapper (self);
                retval.58 = D.116099 != 0B;
                if (retval.58 != 0) goto <D.116100>; else goto <D.116101>;
                <D.116100>:
                {
                  try
                    {
                      {
                        {
                          struct slot_base * const slot;

                          slot = Glib::SignalProxyBase::data_to_slot (data);
                          if (slot != 0B) goto <D.116102>; else goto <D.116103>;
                          <D.116102>:
                          D.116104 = &MEM[(struct SlotType *)slot].D.109096;
                          sigc::slot2<void, const std::vector<Glib::RefPtr<Gio::File> >&, const Glib::ustring&>::operator() (D.116104, &vec_files, &hint_str);
                          return;
                          <D.116103>:
                        }
                      }
                    }
                  catch
                    {
                      catch (NULL)
                        {
                          try
                            {
                              D.116105 = __builtin_eh_pointer (0);
                              __cxa_begin_catch (D.116105);
                              Glib::exception_handlers_invoke ();
                            }
                          finally
                            {
                              __cxa_end_catch ();
                            }
                        }
                    }
                }
                goto <D.116106>;
                <D.116101>:
                <D.116106>:
              }
              return;
            }
          finally
            {
              Glib::ustring::~ustring (&hint_str);
            }
        }
      finally
        {
          std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
        }
    }
  finally
    {
      vec_files = {CLOBBER};
      hint_str = {CLOBBER};
    }
}


static sigc::slot_base* Glib::SignalProxyBase::data_to_slot(void*) (void * data)
{
  struct slot_base * D.116122;
  struct slot_base * iftmp.59;
  struct slot_base * D.116124;
  bool D.116125;
  bool D.116126;
  struct SignalProxyConnectionNode * const pConnectionNode;

  pConnectionNode = data;
  D.116124 = &pConnectionNode->slot_;
  D.116125 = sigc::slot_base::blocked (D.116124);
  D.116126 = ~D.116125;
  if (D.116126 != 0) goto <D.116127>; else goto <D.116128>;
  <D.116127>:
  iftmp.59 = &pConnectionNode->slot_;
  goto <D.116129>;
  <D.116128>:
  iftmp.59 = 0B;
  <D.116129>:
  D.116122 = iftmp.59;
  return D.116122;
}


bool sigc::slot_base::blocked() const (const struct slot_base * const this)
{
  bool D.116131;

  D.116131 = this->blocked_;
  return D.116131;
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = void; T_arg1 = const std::vector<Glib::RefPtr<Gio::File> >&; T_arg2 = const Glib::ustring&; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const std::vector<Glib::RefPtr<Gio::File> >&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const Glib::ustring&] (const struct slot2 * const this, const struct vector & _A_a1, const struct ustring & _A_a2)
{
  bool retval.60;
  bool iftmp.61;
  const struct slot_base * D.116137;
  bool D.116138;
  bool D.116139;
  bool D.116141;
  bool D.116142;
  struct rep_type * D.116146;
  void * (*<T605>) (void *) D.116147;

  D.116137 = &this->D.109054;
  D.116138 = sigc::slot_base::empty (D.116137);
  D.116139 = ~D.116138;
  if (D.116139 != 0) goto <D.116140>; else goto <D.116135>;
  <D.116140>:
  D.116137 = &this->D.109054;
  D.116141 = sigc::slot_base::blocked (D.116137);
  D.116142 = ~D.116141;
  if (D.116142 != 0) goto <D.116143>; else goto <D.116135>;
  <D.116143>:
  iftmp.61 = 1;
  goto <D.116136>;
  <D.116135>:
  iftmp.61 = 0;
  <D.116136>:
  retval.60 = iftmp.61;
  if (retval.60 != 0) goto <D.116144>; else goto <D.116145>;
  <D.116144>:
  D.116146 = this->D.109054.rep_;
  D.116147 = D.116146->call_;
  D.116146 = this->D.109054.rep_;
  D.116147 (D.116146, _A_a1, _A_a2);
  return;
  <D.116145>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.116149;
  bool iftmp.62;
  struct rep_type * D.116154;
  void * (*<T605>) (void *) D.116156;

  D.116154 = this->rep_;
  if (D.116154 == 0B) goto <D.116151>; else goto <D.116155>;
  <D.116155>:
  D.116154 = this->rep_;
  D.116156 = D.116154->call_;
  if (D.116156 == 0B) goto <D.116151>; else goto <D.116152>;
  <D.116151>:
  iftmp.62 = 1;
  goto <D.116153>;
  <D.116152>:
  iftmp.62 = 0;
  <D.116153>:
  D.116149 = iftmp.62;
  return D.116149;
}


void {anonymous}::Application_signal_open_callback(GApplication*, GFile**, gint, const gchar*, void*) (struct GApplication * self, struct GFile * * files, gint n_files, const gchar * hint, void * data)
{
  struct allocator_type D.108984;
  struct value_type D.108982;
  long unsigned int D.116158;
  struct RefPtr D.108986;
  long unsigned int D.116159;
  long unsigned int D.116160;
  struct GFile * * D.116161;
  struct GFile * D.116162;
  long unsigned int D.116163;
  struct RefPtr & D.116164;
  bool retval.63;
  struct ObjectBase * D.116169;
  struct slot2 * D.116174;
  void * D.116175;
  typedef struct SlotType SlotType;
  struct type_vec_files vec_files;
  const struct ustring hint_str;

  try
    {
      std::allocator<Glib::RefPtr<Gio::File> >::allocator (&D.108984);
      try
        {
          Glib::RefPtr<Gio::File>::RefPtr (&D.108982);
          try
            {
              D.116158 = (long unsigned int) n_files;
              std::vector<Glib::RefPtr<Gio::File> >::vector (&vec_files, D.116158, &D.108982, &D.108984);
            }
          finally
            {
              try
                {
                  Glib::RefPtr<Gio::File>::~RefPtr (&D.108982);
                }
              catch
                {
                  std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
                }
              D.108982 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<Glib::RefPtr<Gio::File> >::~allocator (&D.108984);
            }
          catch
            {
              std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
            }
          D.108984 = {CLOBBER};
        }
      try
        {
          {
            int i;

            i = 0;
            goto <D.109101>;
            <D.109100>:
            D.116159 = (long unsigned int) i;
            D.116160 = D.116159 * 8;
            D.116161 = files + D.116160;
            D.116162 = *D.116161;
            D.108986 = Glib::wrap (D.116162, 1); [return slot optimization]
            try
              {
                D.116163 = (long unsigned int) i;
                D.116164 = std::vector<Glib::RefPtr<Gio::File> >::operator[] (&vec_files, D.116163);
                Glib::RefPtr<Gio::File>::operator= (D.116164, &D.108986);
              }
            finally
              {
                Glib::RefPtr<Gio::File>::~RefPtr (&D.108986);
                D.108986 = {CLOBBER};
              }
            i = i + 1;
            <D.109101>:
            if (i < n_files) goto <D.109100>; else goto <D.109098>;
            <D.109098>:
          }
          if (hint != 0B) goto <D.116165>; else goto <D.116166>;
          <D.116165>:
          Glib::ustring::ustring (&hint_str, hint);
          goto <D.116167>;
          <D.116166>:
          Glib::ustring::ustring (&hint_str);
          <D.116167>:
          try
            {
              {
                D.116169 = Glib::ObjectBase::_get_current_wrapper (self);
                retval.63 = D.116169 != 0B;
                if (retval.63 != 0) goto <D.116170>; else goto <D.116171>;
                <D.116170>:
                {
                  try
                    {
                      {
                        {
                          struct slot_base * const slot;

                          slot = Glib::SignalProxyBase::data_to_slot (data);
                          if (slot != 0B) goto <D.116172>; else goto <D.116173>;
                          <D.116172>:
                          D.116174 = &MEM[(struct SlotType *)slot].D.109096;
                          sigc::slot2<void, const std::vector<Glib::RefPtr<Gio::File> >&, const Glib::ustring&>::operator() (D.116174, &vec_files, &hint_str);
                          return;
                          <D.116173>:
                        }
                      }
                    }
                  catch
                    {
                      catch (NULL)
                        {
                          try
                            {
                              D.116175 = __builtin_eh_pointer (0);
                              __cxa_begin_catch (D.116175);
                              Glib::exception_handlers_invoke ();
                            }
                          finally
                            {
                              __cxa_end_catch ();
                            }
                        }
                    }
                }
                goto <D.116176>;
                <D.116171>:
                <D.116176>:
              }
              return;
            }
          finally
            {
              Glib::ustring::~ustring (&hint_str);
            }
        }
      finally
        {
          std::vector<Glib::RefPtr<Gio::File> >::~vector (&vec_files);
        }
    }
  finally
    {
      vec_files = {CLOBBER};
      hint_str = {CLOBBER};
    }
}


Glib::SignalProxy2<R, P1, P2>::SignalProxy2(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void; P1 = const std::vector<Glib::RefPtr<Gio::File> >&; P2 = const Glib::ustring&] (struct SignalProxy2 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.116192;

  D.116192 = &this->D.110880;
  Glib::SignalProxyNormal::SignalProxyNormal (D.116192, obj, info);
  try
    {

    }
  catch
    {
      D.116192 = &this->D.110880;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.116192);
    }
}


virtual void Gio::Application::on_open(const type_vec_files&, const Glib::ustring&) (struct Application * const this, const struct type_vec_files & files, const struct ustring & hint)
{
  int (*__vtbl_ptr_type) () * D.116193;
  int (*__vtbl_ptr_type) () * D.116194;
  long int D.116195;
  sizetype D.116196;
  struct ObjectBase * D.116197;
  struct GObject * D.116198;
  struct GTypeClass * D.116199;
  void (*<Tf93a>) (struct GApplication *, struct GFile * *, gint, const gchar *) D.116202;
  const char * D.116205;
  long unsigned int D.116206;
  int D.116207;
  struct ArrayKeeperType D.110978;
  struct GFile * * D.116208;
  struct GApplication * D.116209;
  struct BaseClassType * const base;

  D.116193 = this->D.106831._vptr.Object;
  D.116194 = D.116193 + 18446744073709551592;
  D.116195 = MEM[(long int *)D.116194];
  D.116196 = (sizetype) D.116195;
  D.116197 = this + D.116196;
  D.116198 = D.116197->gobject_;
  D.116199 = MEM[(struct GTypeInstance *)D.116198].g_class;
  base = g_type_class_peek_parent (D.116199);
  if (base != 0B) goto <D.116200>; else goto <D.116201>;
  <D.116200>:
  D.116202 = base->open;
  if (D.116202 != 0B) goto <D.116203>; else goto <D.116204>;
  <D.116203>:
  D.116202 = base->open;
  D.116205 = Glib::ustring::c_str (hint);
  D.116206 = std::vector<Glib::RefPtr<Gio::File> >::size (files);
  D.116207 = (int) D.116206;
  D.110978 = Glib::ArrayHandler<Glib::RefPtr<Gio::File> >::vector_to_array (files); [return slot optimization]
  try
    {
      D.116208 = Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >::data (&D.110978);
      D.116209 = Gio::Application::gobj (this);
      D.116202 (D.116209, D.116208, D.116207, D.116205);
    }
  finally
    {
      Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >::~ArrayKeeper (&D.110978);
      D.110978 = {CLOBBER};
    }
  goto <D.116210>;
  <D.116204>:
  <D.116210>:
  <D.116201>:
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.116214;
  struct RefPtr * D.116215;
  long int D.116216;
  struct RefPtr * D.116217;
  long int D.116218;
  long int D.116219;
  long int D.116220;

  D.116215 = this->D.108979._M_impl._M_finish;
  D.116216 = (long int) D.116215;
  D.116217 = this->D.108979._M_impl._M_start;
  D.116218 = (long int) D.116217;
  D.116219 = D.116216 - D.116218;
  D.116220 = D.116219 /[ex] 8;
  D.116214 = (size_type) D.116220;
  return D.116214;
}


static Glib::ArrayHandler<T, Tr>::ArrayKeeperType Glib::ArrayHandler<T, Tr>::vector_to_array(const VectorType&) [with T = Glib::RefPtr<Gio::File>; Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >; Glib::ArrayHandler<T, Tr>::ArrayKeeperType = Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::RefPtr<Gio::File> >] (const struct VectorType & vector)
{
  long unsigned int D.116223;
  long unsigned int D.116224;
  struct __normal_iterator D.116225;
  struct GFile * * D.116226;

  D.116223 = std::vector<Glib::RefPtr<Gio::File> >::size (vector);
  D.116224 = std::vector<Glib::RefPtr<Gio::File> >::size (vector);
  D.116225 = std::vector<Glib::RefPtr<Gio::File> >::begin (vector);
  D.116226 = Glib::Container_Helpers::create_array<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > > (D.116225, D.116224);
  Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >::ArrayKeeper (<retval>, D.116226, D.116223, 1);
  return <retval>;
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::begin() const [with _Tp = Glib::RefPtr<Gio::File>; _Alloc = std::allocator<Glib::RefPtr<Gio::File> >; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::File>*, std::vector<Glib::RefPtr<Gio::File> > >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::RefPtr<Gio::File>*] (const struct vector * const this)
{
  struct const_iterator D.116229;
  struct const_iterator D.114512;
  const struct RefPtr * const D.114511;
  struct RefPtr * D.116230;

  D.116230 = this->D.108979._M_impl._M_start;
  D.114511 = D.116230;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::File>*, std::vector<Glib::RefPtr<Gio::File> > >::__normal_iterator (&D.114512, &D.114511);
      try
        {
          D.116229 = D.114512;
          return D.116229;
        }
      finally
        {
          D.114512 = {CLOBBER};
        }
    }
  finally
    {
      D.114511 = {CLOBBER};
    }
}


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

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


typename Tr::CType* Glib::Container_Helpers::create_array(typename std::vector<typename Tr::CppType>::const_iterator, std::size_t) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >; typename Tr::CType = _GFile*; typename std::vector<typename Tr::CppType>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::File>*, std::vector<Glib::RefPtr<Gio::File> > >; std::size_t = long unsigned int] (struct const_iterator pbegin, size_t size)
{
  long unsigned int D.116235;
  long unsigned int D.116236;
  long unsigned int D.116237;
  const struct RefPtr & D.116238;
  struct GFile * D.116239;
  struct GFile * * D.116240;
  typedef struct GFile * CType;
  struct GFile * * const array;
  struct GFile * * const array_end;

  D.116235 = size + 1;
  D.116236 = D.116235 * 8;
  array = g_malloc (D.116236);
  D.116237 = size * 8;
  array_end = array + D.116237;
  {
    struct GFile * * pdest;

    pdest = array;
    goto <D.114521>;
    <D.114520>:
    D.116238 = __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::File>*, std::vector<Glib::RefPtr<Gio::File> > >::operator* (&pbegin);
    D.116239 = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >::to_c_type (D.116238);
    *pdest = D.116239;
    __gnu_cxx::__normal_iterator<const Glib::RefPtr<Gio::File>*, std::vector<Glib::RefPtr<Gio::File> > >::operator++ (&pbegin);
    pdest = pdest + 8;
    <D.114521>:
    if (pdest != array_end) goto <D.114520>; else goto <D.114518>;
    <D.114518>:
  }
  *array_end = 0B;
  D.116240 = array;
  return D.116240;
}


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

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


static GFile* Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >::to_c_type(const CppType&) (const struct CppType & item)
{
  struct GFile * D.116246;

  D.116246 = Glib::unwrap<Gio::File> (item);
  return D.116246;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::File; typename T::BaseObjectType = _GFile] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.116249;
  struct BaseObjectType * iftmp.64;
  bool D.116251;
  struct File * D.116254;

  D.116251 = Glib::RefPtr<Gio::File>::operator bool (ptr);
  if (D.116251 != 0) goto <D.116252>; else goto <D.116253>;
  <D.116252>:
  D.116254 = Glib::RefPtr<Gio::File>::operator-> (ptr);
  iftmp.64 = Gio::File::gobj (D.116254);
  goto <D.116255>;
  <D.116253>:
  iftmp.64 = 0B;
  <D.116255>:
  D.116249 = iftmp.64;
  return D.116249;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::File] (const struct RefPtr * const this)
{
  bool D.116257;
  struct File * D.116258;

  D.116258 = this->pCppObject_;
  D.116257 = D.116258 != 0B;
  return D.116257;
}


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

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


GFile* Gio::File::gobj() (struct File * const this)
{
  struct GFile * D.116262;
  int (*__vtbl_ptr_type) () * D.116263;
  int (*__vtbl_ptr_type) () * D.116264;
  long int D.116265;
  sizetype D.116266;
  struct ObjectBase * D.116267;

  D.116263 = this->D.102671._vptr.Interface;
  D.116264 = D.116263 + 18446744073709551592;
  D.116265 = MEM[(long int *)D.116264];
  D.116266 = (sizetype) D.116265;
  D.116267 = this + D.116266;
  D.116262 = D.116267->gobject_;
  return D.116262;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++() [with _Iterator = const Glib::RefPtr<Gio::File>*; _Container = std::vector<Glib::RefPtr<Gio::File> >] (struct __normal_iterator * const this)
{
  const struct RefPtr * D.116269;
  const struct RefPtr * D.116270;
  struct __normal_iterator & D.116271;

  D.116269 = this->_M_current;
  D.116270 = D.116269 + 8;
  this->_M_current = D.116270;
  D.116271 = this;
  return D.116271;
}


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


typename Tr::CType* Glib::Container_Helpers::ArrayKeeper<Tr>::data() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >; typename Tr::CType = _GFile*] (const struct ArrayKeeper * const this)
{
  struct GFile * * D.116273;

  D.116273 = this->array_;
  return D.116273;
}


GApplication* Gio::Application::gobj() (struct Application * const this)
{
  struct GApplication * D.116275;
  int (*__vtbl_ptr_type) () * D.116276;
  int (*__vtbl_ptr_type) () * D.116277;
  long int D.116278;
  sizetype D.116279;
  struct ObjectBase * D.116280;

  D.116276 = this->D.106831._vptr.Object;
  D.116277 = D.116276 + 18446744073709551592;
  D.116278 = MEM[(long int *)D.116277];
  D.116279 = (sizetype) D.116278;
  D.116280 = this + D.116279;
  D.116275 = D.116280->gobject_;
  return D.116275;
}


Glib::Container_Helpers::ArrayKeeper<Tr>::~ArrayKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >] (struct ArrayKeeper * const this)
{
  struct GFile * * D.116282;
  OwnershipType D.116285;
  long unsigned int D.116290;
  long unsigned int D.116291;
  struct GFile * D.116292;

  {
    try
      {
        {
          {
            D.116282 = this->array_;
            if (D.116282 != 0B) goto <D.116283>; else goto <D.116284>;
            <D.116283>:
            D.116285 = this->ownership_;
            if (D.116285 != 0) goto <D.116286>; else goto <D.116287>;
            <D.116286>:
            {
              {
                D.116285 = this->ownership_;
                if (D.116285 != 1) goto <D.116288>; else goto <D.116289>;
                <D.116288>:
                {
                  struct GFile * const * const array_end;

                  D.116282 = this->array_;
                  D.116290 = this->array_size_;
                  D.116291 = D.116290 * 8;
                  array_end = D.116282 + D.116291;
                  {
                    struct GFile * const * p;

                    p = this->array_;
                    goto <D.114019>;
                    <D.114020>:
                    D.116292 = *p;
                    Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >::release_c_type (D.116292);
                    p = p + 8;
                    <D.114019>:
                    if (p != array_end) goto <D.114020>; else goto <D.114021>;
                    <D.114021>:
                  }
                }
                goto <D.116293>;
                <D.116289>:
                <D.116293>:
              }
              D.116282 = this->array_;
              g_free (D.116282);
            }
            goto <D.116294>;
            <D.116287>:
            <D.116294>:
            <D.116284>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114022>:
}


static void Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >::release_c_type(Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> >::CType) (struct GFile * item)
{
  g_object_unref (item);
}


void Gio::Application::open(const type_vec_files&, const Glib::ustring&) (struct Application * const this, const struct type_vec_files & files, const struct ustring & hint)
{
  const char * D.116296;
  long unsigned int D.116297;
  int D.116298;
  struct ArrayKeeperType D.110984;
  struct GFile * * D.116299;
  struct GApplication * D.116300;

  D.116296 = Glib::ustring::c_str (hint);
  D.116297 = std::vector<Glib::RefPtr<Gio::File> >::size (files);
  D.116298 = (int) D.116297;
  D.110984 = Glib::ArrayHandler<Glib::RefPtr<Gio::File> >::vector_to_array (files); [return slot optimization]
  try
    {
      D.116299 = Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >::data (&D.110984);
      D.116300 = Gio::Application::gobj (this);
      g_application_open (D.116300, D.116299, D.116298, D.116296);
    }
  finally
    {
      Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::RefPtr<Gio::File> > >::~ArrayKeeper (&D.110984);
      D.110984 = {CLOBBER};
    }
}


void Gio::Application::open(const Glib::RefPtr<Gio::File>&, const Glib::ustring&) (struct Application * const this, const struct RefPtr & file, const struct ustring & hint)
{
  struct allocator_type D.110994;
  struct value_type D.110992;
  struct RefPtr & D.116303;
  struct type_vec_files files;

  try
    {
      std::allocator<Glib::RefPtr<Gio::File> >::allocator (&D.110994);
      try
        {
          Glib::RefPtr<Gio::File>::RefPtr (&D.110992);
          try
            {
              std::vector<Glib::RefPtr<Gio::File> >::vector (&files, 1, &D.110992, &D.110994);
            }
          finally
            {
              try
                {
                  Glib::RefPtr<Gio::File>::~RefPtr (&D.110992);
                }
              catch
                {
                  std::vector<Glib::RefPtr<Gio::File> >::~vector (&files);
                }
              D.110992 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<Glib::RefPtr<Gio::File> >::~allocator (&D.110994);
            }
          catch
            {
              std::vector<Glib::RefPtr<Gio::File> >::~vector (&files);
            }
          D.110994 = {CLOBBER};
        }
      try
        {
          D.116303 = std::vector<Glib::RefPtr<Gio::File> >::operator[] (&files, 0);
          Glib::RefPtr<Gio::File>::operator= (D.116303, file);
          Gio::Application::open (this, &files, hint);
        }
      finally
        {
          std::vector<Glib::RefPtr<Gio::File> >::~vector (&files);
        }
    }
  finally
    {
      files = {CLOBBER};
    }
}


void Gio::Application::add_main_option_entry(Gio::Application::OptionType, const Glib::ustring&, gchar, const Glib::ustring&, const Glib::ustring&, int) (struct Application * const this, OptionType arg_type, const struct ustring & long_name, gchar short_name, const struct ustring & description, const struct ustring & arg_description, int flags)
{
  int D.116309;

  D.116309 = (int) short_name;
  Gio::Application::add_main_option_entry_private (this, arg_type, long_name, D.116309, description, arg_description, flags);
}


void Gio::Application::add_main_option_entry(const SlotOptionArgString&, const Glib::ustring&, gchar, const Glib::ustring&, const Glib::ustring&, int) (struct Application * const this, const struct SlotOptionArgString & slot, const struct ustring & long_name, gchar short_name, const struct ustring & description, const struct ustring & arg_description, int flags)
{
  bool retval.65;
  struct iterator D.111016;
  void * callback_data.66;
  int D.116313;
  struct OptionArgCallbackData * & D.116314;
  int D.116315;
  struct Lock lock;
  struct iterator iterFind;
  struct OptionArgCallbackData * callback_data;

  try
    {
      Glib::Threads::Mutex::Lock::Lock (&lock, &option_arg_callback_data_mutex);
      try
        {
          iterFind = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::find (&option_arg_callback_data, long_name);
          D.111016 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
          try
            {
              retval.65 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator!= (&iterFind, &D.111016);
            }
          finally
            {
              D.111016 = {CLOBBER};
            }
          if (retval.65 != 0) goto <D.116311>; else goto <D.116312>;
          <D.116311>:
          return;
          <D.116312>:
          callback_data.66 = operator new (32);
          try
            {
              D.116313 = (int) short_name;
              {anonymous}::OptionArgCallbackData::OptionArgCallbackData (callback_data.66, this, D.116313, slot);
            }
          catch
            {
              operator delete (callback_data.66);
            }
          callback_data = callback_data.66;
          D.116314 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::operator[] (&option_arg_callback_data, long_name);
          *D.116314 = callback_data;
          Glib::Threads::Mutex::Lock::release (&lock);
          D.116315 = flags & -17;
          D.116313 = (int) short_name;
          Gio::Application::add_main_option_entry_private (this, 3, long_name, D.116313, description, arg_description, D.116315);
        }
      finally
        {
          Glib::Threads::Mutex::Lock::~Lock (&lock);
        }
    }
  finally
    {
      lock = {CLOBBER};
      iterFind = {CLOBBER};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::find(const key_type&) [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = Glib::ustring] (struct map * const this, const struct key_type & __x)
{
  struct iterator D.116326;
  struct _Rep_type * D.116327;

  D.116327 = &this->_M_t;
  D.116326 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::find (D.116327, __x);
  return D.116326;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::find(const _Key&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this, const struct ustring & __k)
{
  struct _Rb_tree_node * D.116329;
  struct _Rb_tree_node * D.116330;
  struct iterator D.116331;
  struct iterator D.114496;
  bool cleanup.67;
  bool D.116338;
  struct _Rb_tree_node_base * D.116340;
  const struct ustring & D.116341;
  struct less * D.116342;
  bool D.116343;
  struct iterator __j;

  try
    {
      D.116329 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_end (this);
      D.116330 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_begin (this);
      __j = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_lower_bound (this, D.116330, D.116329, __k);
      cleanup.67 = 0;
      try
        {
          D.114496 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::end (this);
          cleanup.67 = 1;
          D.116338 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator== (&__j, &D.114496);
          if (D.116338 != 0) goto <D.116332>; else goto <D.116339>;
          <D.116339>:
          D.116340 = __j._M_node;
          D.116341 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116340);
          D.116342 = &this->_M_impl._M_key_compare;
          D.116343 = std::less<Glib::ustring>::operator() (D.116342, __k, D.116341);
          if (D.116343 != 0) goto <D.116332>; else goto <D.116333>;
          <D.116332>:
          D.116331 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::end (this);
          goto <D.116334>;
          <D.116333>:
          D.116331 = __j;
          <D.116334>:
          return D.116331;
        }
      finally
        {
          if (cleanup.67 != 0) goto <D.116336>; else goto <D.116337>;
          <D.116336>:
          D.114496 = {CLOBBER};
          <D.116337>:
        }
    }
  finally
    {
      __j = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_end() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.116353;

  D.116353 = &this->_M_impl._M_header;
  return D.116353;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.116355;

  D.116355 = this->_M_impl._M_header._M_parent;
  return D.116355;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_lower_bound(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type, std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type, const _Key&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __x, struct _Rb_tree_node * __y, const struct ustring & __k)
{
  bool retval.68;
  const struct ustring & D.116358;
  struct less * D.116359;
  bool D.116360;
  struct iterator D.116364;
  struct iterator D.114779;

  goto <D.114781>;
  <D.114782>:
  D.116358 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (__x);
  D.116359 = &this->_M_impl._M_key_compare;
  D.116360 = std::less<Glib::ustring>::operator() (D.116359, D.116358, __k);
  retval.68 = ~D.116360;
  if (retval.68 != 0) goto <D.116361>; else goto <D.116362>;
  <D.116361>:
  __y = __x;
  __x = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_left (__x);
  goto <D.116363>;
  <D.116362>:
  __x = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_right (__x);
  <D.116363>:
  <D.114781>:
  if (__x != 0B) goto <D.114782>; else goto <D.114780>;
  <D.114780>:
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.114779, __y);
  try
    {
      D.116364 = D.114779;
      return D.116364;
    }
  finally
    {
      D.114779 = {CLOBBER};
    }
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (const struct _Rb_tree_node * __x)
{
  const struct ustring & D.116369;
  const struct value_type & D.116370;
  struct _Select1st D.115030;

  D.116370 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_value (__x);
  try
    {
      D.116369 = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator() (&D.115030, D.116370);
      return D.116369;
    }
  finally
    {
      D.115030 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (const struct _Rb_tree_node * __x)
{
  const struct value_type & D.116374;

  D.116374 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (__x);
  return D.116374;
}


const _Val* std::_Rb_tree_node<_Val>::_M_valptr() const [with _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (const struct _Rb_tree_node * const this)
{
  const struct pair * D.116377;
  const struct pair * D.116378;

  D.116378 = &this->_M_value_field;
  D.116377 = std::__addressof<const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > (D.116378);
  return D.116377;
}


_Tp* std::__addressof(_Tp&) [with _Tp = const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (const struct pair & __r)
{
  const struct pair * D.116380;

  D.116380 = __r;
  return D.116380;
}


const typename _Pair::first_type& std::_Select1st<_Pair>::operator()(const _Pair&) const [with _Pair = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; typename _Pair::first_type = const Glib::ustring] (const struct _Select1st * const this, const struct pair & __x)
{
  const struct first_type & D.116382;

  D.116382 = &__x->first;
  return D.116382;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_left(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.116384;

  D.116384 = __x->_M_left;
  return D.116384;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_right(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.116386;

  D.116386 = __x->_M_right;
  return D.116386;
}


bool std::_Rb_tree_iterator<_Tp>::operator==(const _Self&) const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree_iterator * const this, const struct _Self & __x)
{
  bool D.116388;
  struct _Rb_tree_node_base * D.116389;
  struct _Rb_tree_node_base * D.116390;

  D.116389 = this->_M_node;
  D.116390 = __x->_M_node;
  D.116388 = D.116389 == D.116390;
  return D.116388;
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct ustring & D.116392;
  const struct value_type & D.116393;
  struct _Select1st D.114796;

  D.116393 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_value (__x);
  try
    {
      D.116392 = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator() (&D.114796, D.116393);
      return D.116392;
    }
  finally
    {
      D.114796 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct value_type & D.116397;

  D.116397 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (__x);
  return D.116397;
}


bool std::less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = Glib::ustring] (const struct less * const this, const struct ustring & __x, const struct ustring & __y)
{
  bool D.116400;

  D.116400 = Glib::operator< (__x, __y);
  return D.116400;
}


bool Glib::operator<(const Glib::ustring&, const Glib::ustring&) (const struct ustring & lhs, const struct ustring & rhs)
{
  bool D.116403;
  int D.116404;

  D.116404 = Glib::ustring::compare (lhs, rhs);
  D.116403 = D.116404 < 0;
  return D.116403;
}


{anonymous}::OptionArgCallbackData::OptionArgCallbackData(const Gio::Application*, gchar, const SlotOptionArgString&) (struct OptionArgCallbackData * const this, const struct Application * application, gchar short_name, const struct SlotOptionArgString & slot)
{
  void * D.109316;

  this->application_ = application;
  this->short_name_ = short_name;
  D.109316 = operator new (16);
  try
    {
      sigc::slot<bool, const Glib::ustring&, const Glib::ustring&, bool>::slot (D.109316, slot);
    }
  catch
    {
      operator delete (D.109316);
    }
  this->slot_string_ = D.109316;
  this->slot_filename_ = 0B;
}


sigc::slot<T_return, T_arg1, T_arg2, T_arg3, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, T_arg2, T_arg3, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const Glib::ustring&; T_arg3 = bool] (struct slot * const this, const struct slot & src)
{
  struct slot3 * D.116409;

  D.116409 = &this->D.109303;
  sigc::slot3<bool, const Glib::ustring&, const Glib::ustring&, bool>::slot3 (D.116409, src);
  try
    {

    }
  catch
    {
      D.116409 = &this->D.109303;
      sigc::slot3<bool, const Glib::ustring&, const Glib::ustring&, bool>::~slot3 (D.116409);
    }
}


sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::slot3(const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>&) [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const Glib::ustring&; T_arg3 = bool] (struct slot3 * const this, const struct slot3 & src)
{
  const struct slot_base * D.116410;
  struct slot_base * D.116411;

  D.116410 = &src->D.109261;
  D.116411 = &this->D.109261;
  sigc::slot_base::slot_base (D.116411, D.116410);
  try
    {

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


std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = {anonymous}::OptionArgCallbackData*; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = Glib::ustring] (struct map * const this, const struct key_type & __k)
{
  bool retval.69;
  bool iftmp.70;
  struct iterator D.114031;
  bool cleanup.71;
  bool D.116420;
  struct pair & D.116422;
  const struct ustring * D.116423;
  struct key_compare D.114030;
  bool cleanup.72;
  bool D.116427;
  struct value_type D.114042;
  struct OptionArgCallbackData * const D.114041;
  struct OptionArgCallbackData * & D.116431;
  struct pair & D.116432;
  struct iterator __i;

  try
    {
      __i = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::lower_bound (this, __k);
      cleanup.71 = 0;
      try
        {
          cleanup.72 = 0;
          try
            {
              D.114031 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (this);
              cleanup.71 = 1;
              D.116420 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator== (&__i, &D.114031);
              if (D.116420 != 0) goto <D.116414>; else goto <D.116421>;
              <D.116421>:
              D.116422 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator* (&__i);
              D.116423 = &D.116422->first;
              std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::key_comp (this);
              cleanup.72 = 1;
              D.116427 = std::less<Glib::ustring>::operator() (&D.114030, __k, D.116423);
              if (D.116427 != 0) goto <D.116414>; else goto <D.116415>;
              <D.116414>:
              iftmp.70 = 1;
              goto <D.116416>;
              <D.116415>:
              iftmp.70 = 0;
              <D.116416>:
              retval.69 = iftmp.70;
            }
          finally
            {
              if (cleanup.72 != 0) goto <D.116425>; else goto <D.116426>;
              <D.116425>:
              D.114030 = {CLOBBER};
              <D.116426>:
            }
        }
      finally
        {
          if (cleanup.71 != 0) goto <D.116418>; else goto <D.116419>;
          <D.116418>:
          D.114031 = {CLOBBER};
          <D.116419>:
        }
      if (retval.69 != 0) goto <D.116428>; else goto <D.116429>;
      <D.116428>:
      D.114041 = 0B;
      try
        {
          std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::pair (&D.114042, __k, &D.114041);
          try
            {
              __i = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::insert (this, __i, &D.114042);
            }
          finally
            {
              std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::~pair (&D.114042);
              D.114042 = {CLOBBER};
            }
        }
      finally
        {
          D.114041 = {CLOBBER};
        }
      goto <D.116430>;
      <D.116429>:
      <D.116430>:
      D.116432 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator* (&__i);
      D.116431 = &D.116432->second;
      return D.116431;
    }
  finally
    {
      __i = {CLOBBER};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::lower_bound(const key_type&) [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = Glib::ustring] (struct map * const this, const struct key_type & __x)
{
  struct iterator D.116447;
  struct _Rep_type * D.116448;

  D.116448 = &this->_M_t;
  D.116447 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::lower_bound (D.116448, __x);
  return D.116447;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::lower_bound(const key_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = Glib::ustring] (struct _Rb_tree * const this, const struct key_type & __k)
{
  struct iterator D.116450;
  struct _Rb_tree_node * D.116451;
  struct _Rb_tree_node * D.116452;

  D.116451 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_end (this);
  D.116452 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_begin (this);
  D.116450 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_lower_bound (this, D.116452, D.116451, __k);
  return D.116450;
}


std::map<_Key, _Tp, _Compare, _Alloc>::key_compare std::map<_Key, _Tp, _Compare, _Alloc>::key_comp() const [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::key_compare = std::less<Glib::ustring>] (const struct map * const this)
{
  struct key_compare D.116454;
  const struct _Rep_type * D.116455;

  D.116455 = &this->_M_t;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::key_comp (D.116455);
  return D.116454;
}


_Compare std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_comp() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree * const this)
{
  struct less D.116457;

  return D.116457;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = const Glib::ustring; _T2 = {anonymous}::OptionArgCallbackData*] (struct pair * const this, const struct ustring & __a, struct OptionArgCallbackData * const & __b)
{
  const struct ustring * D.116459;
  struct OptionArgCallbackData * D.116460;

  D.116459 = &this->first;
  Glib::ustring::ustring (D.116459, __a);
  try
    {
      D.116460 = *__b;
      this->second = D.116460;
    }
  catch
    {
      D.116459 = &this->first;
      Glib::ustring::~ustring (D.116459);
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::insert(std::map<_Key, _Tp, _Compare, _Alloc>::iterator, const value_type&) [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::map<_Key, _Tp, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct map * const this, struct iterator __position, const struct value_type & __x)
{
  struct iterator D.116461;
  struct const_iterator D.114539;
  struct _Rep_type * D.116462;

  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&D.114539, &__position);
  try
    {
      D.116462 = &this->_M_t;
      D.116461 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_insert_unique_ (D.116462, D.114539, __x);
      return D.116461;
    }
  finally
    {
      D.114539 = {CLOBBER};
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_unique_(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this, struct const_iterator __position, const struct pair & __v)
{
  struct _Select1st D.114812;
  const struct first_type & D.116466;
  struct _Rb_tree_node_base * D.116467;
  struct iterator D.116470;
  struct _Rb_tree_node_base * D.116471;
  struct iterator D.114834;
  struct pair __res;

  try
    {
      try
        {
          D.116466 = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator() (&D.114812, __v);
          __res = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_insert_hint_unique_pos (this, __position, D.116466);
        }
      finally
        {
          D.114812 = {CLOBBER};
        }
      D.116467 = __res.second;
      if (D.116467 != 0B) goto <D.116468>; else goto <D.116469>;
      <D.116468>:
      D.116467 = __res.second;
      D.116471 = __res.first;
      D.116470 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_insert_ (this, D.116471, D.116467, __v);
      return D.116470;
      <D.116469>:
      D.116471 = __res.first;
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.114834, D.116471);
      try
        {
          D.116470 = D.114834;
          return D.116470;
        }
      finally
        {
          D.114834 = {CLOBBER};
        }
    }
  finally
    {
      __res = {CLOBBER};
    }
}


std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_hint_unique_pos(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, const key_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = Glib::ustring] (struct _Rb_tree * const this, struct const_iterator __position, const struct key_type & __k)
{
  bool retval.73;
  struct _Rb_tree_node_base * D.116478;
  struct _Rb_tree_node * D.116479;
  bool retval.74;
  bool iftmp.75;
  long unsigned int D.116486;
  struct _Rb_tree_node_base * & D.116488;
  struct _Rb_tree_node_base * D.116489;
  const struct ustring & D.116490;
  struct less * D.116491;
  bool D.116492;
  struct pair D.116496;
  struct _Res D.115038;
  struct _Rb_tree_node_base * & D.116497;
  struct _Rb_tree_node_base * const D.115037;
  bool retval.76;
  const struct ustring & D.116499;
  bool retval.77;
  struct _Rb_tree_node_base * & D.116503;
  struct _Rb_tree_node_base * D.116504;
  struct _Res D.115042;
  struct _Rb_tree_node_base * & D.116507;
  struct _Rb_tree_node_base * & D.116508;
  bool retval.78;
  struct _Self & D.116510;
  struct _Rb_tree_node_base * D.116511;
  const struct ustring & D.116512;
  bool retval.79;
  struct _Rb_tree_node_base * D.116516;
  struct _Rb_tree_node * D.116517;
  struct _Res D.115044;
  struct _Rb_tree_node_base * const D.115043;
  struct _Res D.115045;
  bool retval.80;
  const struct ustring & D.116521;
  bool retval.81;
  struct _Rb_tree_node_base * & D.116525;
  struct _Rb_tree_node_base * D.116526;
  struct _Res D.115050;
  struct _Rb_tree_node_base * & D.116529;
  struct _Rb_tree_node_base * const D.115049;
  bool retval.82;
  struct _Self & D.116531;
  struct _Rb_tree_node_base * D.116532;
  const struct ustring & D.116533;
  bool retval.83;
  struct _Rb_tree_node * D.116537;
  struct _Res D.115052;
  struct _Rb_tree_node_base * const D.115051;
  struct _Res D.115053;
  struct _Res D.115056;
  struct _Rb_tree_node_base * const D.115055;
  struct iterator __pos;
  typedef struct _Res _Res;

  try
    {
      __pos = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_const_cast (&__position);
      {
        D.116478 = __pos._M_node;
        D.116479 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_end (this);
        retval.73 = D.116478 == D.116479;
        if (retval.73 != 0) goto <D.116480>; else goto <D.116481>;
        <D.116480>:
        D.116486 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::size (this);
        if (D.116486 != 0) goto <D.116487>; else goto <D.116484>;
        <D.116487>:
        D.116488 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_rightmost (this);
        D.116489 = *D.116488;
        D.116490 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116489);
        D.116491 = &this->_M_impl._M_key_compare;
        D.116492 = std::less<Glib::ustring>::operator() (D.116491, D.116490, __k);
        if (D.116492 != 0) goto <D.116493>; else goto <D.116484>;
        <D.116493>:
        iftmp.75 = 1;
        goto <D.116485>;
        <D.116484>:
        iftmp.75 = 0;
        <D.116485>:
        retval.74 = iftmp.75;
        if (retval.74 != 0) goto <D.116494>; else goto <D.116495>;
        <D.116494>:
        D.116497 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_rightmost (this);
        D.115037 = 0B;
        try
          {
            std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115038, &D.115037, D.116497);
            try
              {
                D.116496 = D.115038;
                return D.116496;
              }
            finally
              {
                D.115038 = {CLOBBER};
              }
          }
        finally
          {
            D.115037 = {CLOBBER};
          }
        <D.116495>:
        D.116496 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_insert_unique_pos (this, __k);
        return D.116496;
        <D.116481>:
        {
          {
            D.116478 = __pos._M_node;
            D.116499 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116478);
            D.116491 = &this->_M_impl._M_key_compare;
            retval.76 = std::less<Glib::ustring>::operator() (D.116491, __k, D.116499);
            if (retval.76 != 0) goto <D.116500>; else goto <D.116501>;
            <D.116500>:
            {
              struct iterator __before;

              try
                {
                  __before = __pos;
                  D.116478 = __pos._M_node;
                  D.116503 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_leftmost (this);
                  D.116504 = *D.116503;
                  retval.77 = D.116478 == D.116504;
                  if (retval.77 != 0) goto <D.116505>; else goto <D.116506>;
                  <D.116505>:
                  D.116507 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_leftmost (this);
                  D.116508 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_leftmost (this);
                  std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115042, D.116508, D.116507);
                  try
                    {
                      D.116496 = D.115042;
                      return D.116496;
                    }
                  finally
                    {
                      D.115042 = {CLOBBER};
                    }
                  <D.116506>:
                  D.116510 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-- (&__before);
                  D.116511 = D.116510->_M_node;
                  D.116512 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116511);
                  D.116491 = &this->_M_impl._M_key_compare;
                  retval.78 = std::less<Glib::ustring>::operator() (D.116491, D.116512, __k);
                  if (retval.78 != 0) goto <D.116513>; else goto <D.116514>;
                  <D.116513>:
                  D.116516 = __before._M_node;
                  D.116517 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_right (D.116516);
                  retval.79 = D.116517 == 0B;
                  if (retval.79 != 0) goto <D.116518>; else goto <D.116519>;
                  <D.116518>:
                  D.115043 = 0B;
                  try
                    {
                      std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115044, &D.115043, &__before._M_node);
                      try
                        {
                          D.116496 = D.115044;
                          return D.116496;
                        }
                      finally
                        {
                          D.115044 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.115043 = {CLOBBER};
                    }
                  <D.116519>:
                  std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115045, &__pos._M_node, &__pos._M_node);
                  try
                    {
                      D.116496 = D.115045;
                      return D.116496;
                    }
                  finally
                    {
                      D.115045 = {CLOBBER};
                    }
                  <D.116514>:
                  D.116496 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_insert_unique_pos (this, __k);
                  return D.116496;
                }
              finally
                {
                  __before = {CLOBBER};
                }
            }
            <D.116501>:
            {
              {
                D.116478 = __pos._M_node;
                D.116521 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116478);
                D.116491 = &this->_M_impl._M_key_compare;
                retval.80 = std::less<Glib::ustring>::operator() (D.116491, D.116521, __k);
                if (retval.80 != 0) goto <D.116522>; else goto <D.116523>;
                <D.116522>:
                {
                  struct iterator __after;

                  try
                    {
                      __after = __pos;
                      D.116478 = __pos._M_node;
                      D.116525 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_rightmost (this);
                      D.116526 = *D.116525;
                      retval.81 = D.116478 == D.116526;
                      if (retval.81 != 0) goto <D.116527>; else goto <D.116528>;
                      <D.116527>:
                      D.116529 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_rightmost (this);
                      D.115049 = 0B;
                      try
                        {
                          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115050, &D.115049, D.116529);
                          try
                            {
                              D.116496 = D.115050;
                              return D.116496;
                            }
                          finally
                            {
                              D.115050 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.115049 = {CLOBBER};
                        }
                      <D.116528>:
                      D.116531 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator++ (&__after);
                      D.116532 = D.116531->_M_node;
                      D.116533 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116532);
                      D.116491 = &this->_M_impl._M_key_compare;
                      retval.82 = std::less<Glib::ustring>::operator() (D.116491, __k, D.116533);
                      if (retval.82 != 0) goto <D.116534>; else goto <D.116535>;
                      <D.116534>:
                      D.116478 = __pos._M_node;
                      D.116537 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_right (D.116478);
                      retval.83 = D.116537 == 0B;
                      if (retval.83 != 0) goto <D.116538>; else goto <D.116539>;
                      <D.116538>:
                      D.115051 = 0B;
                      try
                        {
                          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115052, &D.115051, &__pos._M_node);
                          try
                            {
                              D.116496 = D.115052;
                              return D.116496;
                            }
                          finally
                            {
                              D.115052 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.115051 = {CLOBBER};
                        }
                      <D.116539>:
                      std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115053, &__after._M_node, &__after._M_node);
                      try
                        {
                          D.116496 = D.115053;
                          return D.116496;
                        }
                      finally
                        {
                          D.115053 = {CLOBBER};
                        }
                      <D.116535>:
                      D.116496 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_insert_unique_pos (this, __k);
                      return D.116496;
                    }
                  finally
                    {
                      __after = {CLOBBER};
                    }
                }
                <D.116523>:
                D.115055 = 0B;
                try
                  {
                    std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115056, &__pos._M_node, &D.115055);
                    try
                      {
                        D.116496 = D.115056;
                        return D.116496;
                      }
                    finally
                      {
                        D.115056 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.115055 = {CLOBBER};
                  }
              }
            }
          }
        }
      }
    }
  finally
    {
      __pos = {CLOBBER};
    }
}


std::_Rb_tree_const_iterator<_Tp>::iterator std::_Rb_tree_const_iterator<_Tp>::_M_const_cast() const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree_const_iterator * const this)
{
  struct iterator D.116570;
  struct iterator D.115208;
  const struct _Rb_tree_node_base * D.116571;

  D.116571 = this->_M_node;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.115208, D.116571);
  try
    {
      D.116570 = D.115208;
      return D.116570;
    }
  finally
    {
      D.115208 = {CLOBBER};
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type = long unsigned int] (const struct _Rb_tree * const this)
{
  size_type D.116574;

  D.116574 = this->_M_impl._M_node_count;
  return D.116574;
}


std::_Rb_tree_node_base*& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_leftmost() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node_base * & D.116576;

  D.116576 = &this->_M_impl._M_header._M_left;
  return D.116576;
}


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator--() [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.116578;
  struct _Rb_tree_node_base * D.116579;
  struct _Self & D.116580;

  D.116578 = this->_M_node;
  D.116579 = std::_Rb_tree_decrement (D.116578);
  this->_M_node = D.116579;
  D.116580 = this;
  return D.116580;
}


std::_Rb_tree_node_base*& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_rightmost() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node_base * & D.116582;

  D.116582 = &this->_M_impl._M_header._M_right;
  return D.116582;
}


std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_unique_pos(const key_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = Glib::ustring] (struct _Rb_tree * const this, const struct key_type & __k)
{
  const struct ustring & D.116584;
  struct less * D.116585;
  struct _Rb_tree_node * iftmp.84;
  bool retval.85;
  struct iterator D.115221;
  struct pair D.116595;
  struct _Res D.115224;
  struct _Rb_tree_node_base * const D.115223;
  struct _Rb_tree_node_base * const D.115222;
  bool retval.86;
  struct _Rb_tree_node_base * D.116598;
  const struct ustring & D.116599;
  struct _Res D.115227;
  struct _Rb_tree_node_base * const D.115226;
  struct _Rb_tree_node_base * const D.115225;
  struct _Res D.115229;
  struct _Rb_tree_node_base * const D.115228;
  typedef struct _Res _Res;
  struct _Rb_tree_node * __x;
  struct _Rb_tree_node * __y;
  bool __comp;
  struct iterator __j;

  try
    {
      __x = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_begin (this);
      __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_end (this);
      __comp = 1;
      goto <D.115231>;
      <D.115232>:
      __y = __x;
      D.116584 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (__x);
      D.116585 = &this->_M_impl._M_key_compare;
      __comp = std::less<Glib::ustring>::operator() (D.116585, __k, D.116584);
      if (__comp != 0) goto <D.116587>; else goto <D.116588>;
      <D.116587>:
      iftmp.84 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_left (__x);
      goto <D.116589>;
      <D.116588>:
      iftmp.84 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_right (__x);
      <D.116589>:
      __x = iftmp.84;
      <D.115231>:
      if (__x != 0B) goto <D.115232>; else goto <D.115230>;
      <D.115230>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&__j, __y);
      if (__comp != 0) goto <D.116590>; else goto <D.116591>;
      <D.116590>:
      D.115221 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::begin (this);
      try
        {
          retval.85 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator== (&__j, &D.115221);
        }
      finally
        {
          D.115221 = {CLOBBER};
        }
      if (retval.85 != 0) goto <D.116593>; else goto <D.116594>;
      <D.116593>:
      D.115223 = __y;
      try
        {
          D.115222 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115224, &D.115222, &D.115223);
              try
                {
                  D.116595 = D.115224;
                  return D.116595;
                }
              finally
                {
                  D.115224 = {CLOBBER};
                }
            }
          finally
            {
              D.115222 = {CLOBBER};
            }
        }
      finally
        {
          D.115223 = {CLOBBER};
        }
      <D.116594>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-- (&__j);
      goto <D.116596>;
      <D.116591>:
      <D.116596>:
      D.116598 = __j._M_node;
      D.116599 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (D.116598);
      D.116585 = &this->_M_impl._M_key_compare;
      retval.86 = std::less<Glib::ustring>::operator() (D.116585, D.116599, __k);
      if (retval.86 != 0) goto <D.116600>; else goto <D.116601>;
      <D.116600>:
      D.115226 = __y;
      try
        {
          D.115225 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115227, &D.115225, &D.115226);
              try
                {
                  D.116595 = D.115227;
                  return D.116595;
                }
              finally
                {
                  D.115227 = {CLOBBER};
                }
            }
          finally
            {
              D.115225 = {CLOBBER};
            }
        }
      finally
        {
          D.115226 = {CLOBBER};
        }
      <D.116601>:
      D.115228 = 0B;
      try
        {
          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.115229, &__j._M_node, &D.115228);
          try
            {
              D.116595 = D.115229;
              return D.116595;
            }
          finally
            {
              D.115229 = {CLOBBER};
            }
        }
      finally
        {
          D.115228 = {CLOBBER};
        }
    }
  finally
    {
      __j = {CLOBBER};
    }
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = std::_Rb_tree_node_base*; _T2 = std::_Rb_tree_node_base*] (struct pair * const this, struct _Rb_tree_node_base * const & __a, struct _Rb_tree_node_base * const & __b)
{
  struct _Rb_tree_node_base * D.116617;
  struct _Rb_tree_node_base * D.116618;

  D.116617 = *__a;
  this->first = D.116617;
  D.116618 = *__b;
  this->second = D.116618;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree * const this, struct _Rb_tree_node_base * __x, struct _Rb_tree_node_base * __p, const struct pair & __v)
{
  bool iftmp.87;
  struct _Rb_tree_node * D.116624;
  const struct ustring & D.116626;
  struct _Select1st D.115059;
  bool cleanup.88;
  const struct first_type & D.116630;
  struct less * D.116631;
  bool D.116632;
  struct _Rb_tree_node_base * D.116633;
  int D.116634;
  long unsigned int D.116635;
  long unsigned int D.116636;
  struct iterator D.116637;
  struct iterator D.115061;
  bool __insert_left;
  struct _Rb_tree_node * __z;

  cleanup.88 = 0;
  try
    {
      if (__x != 0B) goto <D.116620>; else goto <D.116623>;
      <D.116623>:
      D.116624 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_end (this);
      if (D.116624 == __p) goto <D.116620>; else goto <D.116625>;
      <D.116625>:
      D.116626 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_key (__p);
      cleanup.88 = 1;
      D.116630 = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator() (&D.115059, __v);
      D.116631 = &this->_M_impl._M_key_compare;
      D.116632 = std::less<Glib::ustring>::operator() (D.116631, D.116630, D.116626);
      if (D.116632 != 0) goto <D.116620>; else goto <D.116621>;
      <D.116620>:
      iftmp.87 = 1;
      goto <D.116622>;
      <D.116621>:
      iftmp.87 = 0;
      <D.116622>:
      __insert_left = iftmp.87;
    }
  finally
    {
      if (cleanup.88 != 0) goto <D.116628>; else goto <D.116629>;
      <D.116628>:
      D.115059 = {CLOBBER};
      <D.116629>:
    }
  __z = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_create_node (this, __v);
  D.116633 = &this->_M_impl._M_header;
  D.116634 = (int) __insert_left;
  std::_Rb_tree_insert_and_rebalance (D.116634, __z, __p, D.116633);
  D.116635 = this->_M_impl._M_node_count;
  D.116636 = D.116635 + 1;
  this->_M_impl._M_node_count = D.116636;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_iterator (&D.115061, __z);
  try
    {
      D.116637 = D.115061;
      return D.116637;
    }
  finally
    {
      D.115061 = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_create_node(const value_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>] (struct _Rb_tree * const this, const struct value_type & __x)
{
  struct pair * D.116646;
  struct allocator_type D.115237;
  void * D.116647;
  struct _Rb_tree_node * D.116648;
  struct _Rb_tree_node * __tmp;

  __tmp = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_node (this);
  try
    {
      D.116646 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (__tmp);
      D.115237 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::get_allocator (this); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::construct (&D.115237, D.116646, __x);
        }
      finally
        {
          std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::~allocator (&D.115237);
          D.115237 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.116647 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.116647);
              std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_put_node (this, __tmp);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.116648 = __tmp;
  return D.116648;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_node() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.116656;
  struct _Node_allocator & D.116657;

  D.116657 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_get_Node_allocator (this);
  D.116656 = __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > > >::allocate (D.116657, 1);
  return D.116656;
}


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::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct _Rb_tree_node * D.116660;

  D.116660 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::allocate (__a, __n, 0B);
  return D.116660;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.109849)
{
  bool retval.89;
  long unsigned int D.116664;
  struct _Rb_tree_node * D.116667;
  long unsigned int D.116668;

  D.116664 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::max_size (this);
  retval.89 = D.116664 < __n;
  if (retval.89 != 0) goto <D.116665>; else goto <D.116666>;
  <D.116665>:
  std::__throw_bad_alloc ();
  <D.116666>:
  D.116668 = __n * 48;
  D.116667 = operator new (D.116668);
  return D.116667;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.116671;
  void * D.116672;

  try
    {
      D.116671 = 384307168202282325;
      return D.116671;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.116672 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.116672);
          
        }
    }
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>*] (struct new_allocator * const this, struct pair * __p, const struct pair & __val)
{
  void * D.115324;
  void * D.115325;
  struct pair * iftmp.90;

  D.115324 = __p;
  D.115325 = operator new (16, D.115324);
  if (D.115325 != 0B) goto <D.116675>; else goto <D.116676>;
  <D.116675>:
  try
    {
      std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::pair (D.115325, __val);
    }
  catch
    {
      operator delete (D.115325, D.115324);
    }
  iftmp.90 = D.115325;
  goto <D.116677>;
  <D.116676>:
  iftmp.90 = D.115325;
  <D.116677>:
}


std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>::pair(const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>&) (struct pair * const this, const struct pair & D.114040)
{
  const struct ustring * D.116679;
  const struct ustring * D.116680;
  struct OptionArgCallbackData * D.116681;

  D.116679 = &D.114040->first;
  D.116680 = &this->first;
  Glib::ustring::ustring (D.116680, D.116679);
  try
    {
      D.116681 = D.114040->second;
      this->second = D.116681;
    }
  catch
    {
      D.116680 = &this->first;
      Glib::ustring::~ustring (D.116680);
    }
}


_Tp& std::_Rb_tree_iterator<_Tp>::operator*() const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_iterator<_Tp>::reference = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>&] (const struct _Rb_tree_iterator * const this)
{
  struct pair & D.116682;
  struct _Rb_tree_node_base * D.116683;

  D.116683 = this->_M_node;
  D.116682 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (D.116683);
  return D.116682;
}


void Glib::Threads::Mutex::Lock::release() (struct Lock * const this)
{
  struct Mutex & D.116686;

  D.116686 = this->mutex_;
  Glib::Threads::Mutex::unlock (D.116686);
  this->locked_ = 0;
}


void Gio::Application::add_main_option_entry_filename(const SlotOptionArgFilename&, const Glib::ustring&, gchar, const Glib::ustring&, const Glib::ustring&, int) (struct Application * const this, const struct SlotOptionArgFilename & slot, const struct ustring & long_name, gchar short_name, const struct ustring & description, const struct ustring & arg_description, int flags)
{
  bool retval.91;
  struct iterator D.111040;
  void * callback_data.92;
  int D.116690;
  struct OptionArgCallbackData * & D.116691;
  int D.116692;
  struct Lock lock;
  struct iterator iterFind;
  struct OptionArgCallbackData * callback_data;

  try
    {
      Glib::Threads::Mutex::Lock::Lock (&lock, &option_arg_callback_data_mutex);
      try
        {
          iterFind = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::find (&option_arg_callback_data, long_name);
          D.111040 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
          try
            {
              retval.91 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator!= (&iterFind, &D.111040);
            }
          finally
            {
              D.111040 = {CLOBBER};
            }
          if (retval.91 != 0) goto <D.116688>; else goto <D.116689>;
          <D.116688>:
          return;
          <D.116689>:
          callback_data.92 = operator new (32);
          try
            {
              D.116690 = (int) short_name;
              {anonymous}::OptionArgCallbackData::OptionArgCallbackData (callback_data.92, this, D.116690, slot);
            }
          catch
            {
              operator delete (callback_data.92);
            }
          callback_data = callback_data.92;
          D.116691 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::operator[] (&option_arg_callback_data, long_name);
          *D.116691 = callback_data;
          Glib::Threads::Mutex::Lock::release (&lock);
          D.116692 = flags | 16;
          D.116690 = (int) short_name;
          Gio::Application::add_main_option_entry_private (this, 3, long_name, D.116690, description, arg_description, D.116692);
        }
      finally
        {
          Glib::Threads::Mutex::Lock::~Lock (&lock);
        }
    }
  finally
    {
      lock = {CLOBBER};
      iterFind = {CLOBBER};
    }
}


{anonymous}::OptionArgCallbackData::OptionArgCallbackData(const Gio::Application*, gchar, const SlotOptionArgFilename&) (struct OptionArgCallbackData * const this, const struct Application * application, gchar short_name, const struct SlotOptionArgFilename & slot)
{
  void * D.109435;

  this->application_ = application;
  this->short_name_ = short_name;
  this->slot_string_ = 0B;
  D.109435 = operator new (16);
  try
    {
      sigc::slot<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::slot (D.109435, slot);
    }
  catch
    {
      operator delete (D.109435);
    }
  this->slot_filename_ = D.109435;
}


sigc::slot<T_return, T_arg1, T_arg2, T_arg3, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, T_arg2, T_arg3, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const std::basic_string<char>&; T_arg3 = bool] (struct slot * const this, const struct slot & src)
{
  struct slot3 * D.116705;

  D.116705 = &this->D.109422;
  sigc::slot3<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::slot3 (D.116705, src);
  try
    {

    }
  catch
    {
      D.116705 = &this->D.109422;
      sigc::slot3<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::~slot3 (D.116705);
    }
}


sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::slot3(const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>&) [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const std::basic_string<char>&; T_arg3 = bool] (struct slot3 * const this, const struct slot3 & src)
{
  const struct slot_base * D.116706;
  struct slot_base * D.116707;

  D.116706 = &src->D.109380;
  D.116707 = &this->D.109380;
  sigc::slot_base::slot_base (D.116707, D.116706);
  try
    {

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


void Gio::Application::add_main_option_entry_private(GOptionArg, const Glib::ustring&, gchar, const Glib::ustring&, const Glib::ustring&, int) (struct Application * const this, GOptionArg arg, const struct ustring & long_name, gchar short_name, const struct ustring & description, const struct ustring & arg_description, int flags)
{
  long unsigned int D.116708;
  const char * D.116709;
  gchar * lname.93;
  gchar * iftmp.94;
  bool D.116712;
  const char * D.116716;
  gchar * iftmp.95;
  bool D.116718;
  const char * D.116722;
  unsigned int quark_extra_application_data.96;
  int (*__vtbl_ptr_type) () * D.116724;
  int (*__vtbl_ptr_type) () * D.116725;
  long int D.116726;
  sizetype D.116727;
  struct ObjectBase * D.116728;
  struct GObject * D.116729;
  void * extra_application_data.97;
  struct vector * D.116733;
  gchar * desc.98;
  gchar * arg_desc.99;
  gchar * lname.100;
  void * D.116745;
  struct GApplication * D.116747;
  struct GOptionEntry array[2];
  gchar * lname;
  gchar * desc;
  gchar * arg_desc;
  struct ExtraApplicationData * extra_application_data;

  try
    {
      D.116708 = 96;
      memset (&array, 0, D.116708);
      D.116709 = Glib::ustring::c_str (long_name);
      lname.93 = g_strdup (D.116709);
      lname = lname.93;
      D.116712 = Glib::ustring::empty (description);
      if (D.116712 != 0) goto <D.116713>; else goto <D.116714>;
      <D.116713>:
      iftmp.94 = 0B;
      goto <D.116715>;
      <D.116714>:
      D.116716 = Glib::ustring::c_str (description);
      iftmp.94 = g_strdup (D.116716);
      <D.116715>:
      desc = iftmp.94;
      D.116718 = Glib::ustring::empty (arg_description);
      if (D.116718 != 0) goto <D.116719>; else goto <D.116720>;
      <D.116719>:
      iftmp.95 = 0B;
      goto <D.116721>;
      <D.116720>:
      D.116722 = Glib::ustring::c_str (arg_description);
      iftmp.95 = g_strdup (D.116722);
      <D.116721>:
      arg_desc = iftmp.95;
      quark_extra_application_data.96 = quark_extra_application_data;
      D.116724 = this->D.106831._vptr.Object;
      D.116725 = D.116724 + 18446744073709551592;
      D.116726 = MEM[(long int *)D.116725];
      D.116727 = (sizetype) D.116726;
      D.116728 = this + D.116727;
      D.116729 = D.116728->gobject_;
      extra_application_data = g_object_get_qdata (D.116729, quark_extra_application_data.96);
      if (extra_application_data == 0B) goto <D.116730>; else goto <D.116731>;
      <D.116730>:
      extra_application_data.97 = operator new (24);
      try
        {
          MEM[(struct ExtraApplicationData *)extra_application_data.97].option_entry_strings.D.108062._M_impl._M_start = 0B;
          MEM[(struct ExtraApplicationData *)extra_application_data.97].option_entry_strings.D.108062._M_impl._M_finish = 0B;
          MEM[(struct ExtraApplicationData *)extra_application_data.97].option_entry_strings.D.108062._M_impl._M_end_of_storage = 0B;
          {anonymous}::ExtraApplicationData::ExtraApplicationData (extra_application_data.97);
        }
      catch
        {
          operator delete (extra_application_data.97);
        }
      extra_application_data = extra_application_data.97;
      quark_extra_application_data.96 = quark_extra_application_data;
      D.116724 = this->D.106831._vptr.Object;
      D.116725 = D.116724 + 18446744073709551592;
      D.116726 = MEM[(long int *)D.116725];
      D.116727 = (sizetype) D.116726;
      D.116728 = this + D.116727;
      D.116729 = D.116728->gobject_;
      g_object_set_qdata_full (D.116729, quark_extra_application_data.96, extra_application_data, Application_delete_extra_application_data);
      goto <D.116732>;
      <D.116731>:
      <D.116732>:
      D.116733 = &extra_application_data->option_entry_strings;
      std::vector<char*>::push_back (D.116733, &lname);
      desc.98 = desc;
      if (desc.98 != 0B) goto <D.116735>; else goto <D.116736>;
      <D.116735>:
      D.116733 = &extra_application_data->option_entry_strings;
      std::vector<char*>::push_back (D.116733, &desc);
      goto <D.116737>;
      <D.116736>:
      <D.116737>:
      arg_desc.99 = arg_desc;
      if (arg_desc.99 != 0B) goto <D.116739>; else goto <D.116740>;
      <D.116739>:
      D.116733 = &extra_application_data->option_entry_strings;
      std::vector<char*>::push_back (D.116733, &arg_desc);
      goto <D.116741>;
      <D.116740>:
      <D.116741>:
      array[0].arg = arg;
      lname.100 = lname;
      array[0].long_name = lname.100;
      array[0].short_name = short_name;
      desc.98 = desc;
      array[0].description = desc.98;
      arg_desc.99 = arg_desc;
      array[0].arg_description = arg_desc.99;
      array[0].flags = flags;
      {
        if (arg == 3) goto <D.116743>; else goto <D.116744>;
        <D.116743>:
        {
          typedef union ._253 ._253;
          union ._253 u;

          try
            {
              u.fp = Application_option_arg_callback;
              D.116745 = u.dp;
              array[0].arg_data = D.116745;
            }
          finally
            {
              u = {CLOBBER};
            }
        }
        goto <D.116746>;
        <D.116744>:
        array[0].arg_data = 0B;
        <D.116746>:
      }
      D.116747 = Gio::Application::gobj (this);
      g_application_add_main_option_entries (D.116747, &array);
    }
  finally
    {
      array = {CLOBBER};
      lname = {CLOBBER};
      desc = {CLOBBER};
      arg_desc = {CLOBBER};
    }
}


gboolean {anonymous}::Application_option_arg_callback(const gchar*, const gchar*, gpointer, GError**) (const gchar * option_name, const gchar * value, void * D.110526, struct GError * * error)
{
  struct iterator D.110637;
  const gchar * D.116760;
  char D.116761;
  const gchar * D.116764;
  const struct _Rb_tree_const_iterator iterFind.101;
  struct iterator D.110650;
  const struct _Rb_tree_const_iterator iterFind.102;
  struct iterator D.110709;
  bool retval.103;
  const struct pair * D.116767;
  struct OptionArgCallbackData * D.116768;
  char D.116769;
  bool retval.104;
  const struct _Self D.110712;
  struct iterator D.110711;
  bool retval.105;
  const struct _Self D.110714;
  struct iterator D.110713;
  struct OptionError D.110725;
  struct ustring D.110715;
  gboolean D.116775;
  bool has_value.106;
  const struct pair * D.116777;
  bool retval.107;
  struct allocator D.110731;
  const gchar * iftmp.108;
  const struct slot3 * D.116785;
  bool D.116786;
  const gchar * iftmp.109;
  const struct slot3 * D.116791;
  bool D.116792;
  register struct Error * err.110;
  void * D.116793;
  void * D.116794;
  const struct ustring cpp_option_name;
  struct Lock lock;
  struct const_iterator iterFind;
  const bool has_value;
  const struct OptionArgCallbackData * const option_arg;

  try
    {
      Glib::ustring::ustring (&cpp_option_name, option_name);
      try
        {
          Glib::Threads::Mutex::Lock::Lock (&lock, &option_arg_callback_data_mutex);
          try
            {
              D.110637 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
              try
                {
                  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&iterFind, &D.110637);
                }
              finally
                {
                  D.110637 = {CLOBBER};
                }
              {
                D.116760 = option_name + 1;
                D.116761 = *D.116760;
                if (D.116761 == 45) goto <D.116762>; else goto <D.116763>;
                <D.116762>:
                {
                  const struct ustring long_option_name;

                  try
                    {
                      D.116764 = option_name + 2;
                      Glib::ustring::ustring (&long_option_name, D.116764);
                      try
                        {
                          D.110650 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::find (&option_arg_callback_data, &long_option_name);
                          try
                            {
                              std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&iterFind.101, &D.110650);
                              try
                                {
                                  iterFind = iterFind.101;
                                }
                              finally
                                {
                                  iterFind.101 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.110650 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          Glib::ustring::~ustring (&long_option_name);
                        }
                    }
                  finally
                    {
                      long_option_name = {CLOBBER};
                    }
                }
                goto <D.116765>;
                <D.116763>:
                {
                  const gchar short_option_name;

                  D.116760 = option_name + 1;
                  short_option_name = *D.116760;
                  D.110709 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::begin (&option_arg_callback_data);
                  try
                    {
                      std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&iterFind.102, &D.110709);
                      try
                        {
                          iterFind = iterFind.102;
                        }
                      finally
                        {
                          iterFind.102 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.110709 = {CLOBBER};
                    }
                  goto <D.110739>;
                  <D.110738>:
                  D.116767 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&iterFind);
                  D.116768 = D.116767->second;
                  D.116769 = {anonymous}::OptionArgCallbackData::get_short_name (D.116768);
                  retval.103 = D.116769 == short_option_name;
                  if (retval.103 != 0) goto <D.110736>; else goto <D.116770>;
                  <D.116770>:
                  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator++ (&iterFind);
                  <D.110739>:
                  D.110711 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
                  try
                    {
                      std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&D.110712, &D.110711);
                      try
                        {
                          retval.104 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator!= (&iterFind, &D.110712);
                        }
                      finally
                        {
                          D.110712 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.110711 = {CLOBBER};
                    }
                  if (retval.104 != 0) goto <D.110738>; else goto <D.110736>;
                  <D.110736>:
                }
                <D.116765>:
              }
              D.110713 = std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::end (&option_arg_callback_data);
              try
                {
                  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_Rb_tree_const_iterator (&D.110714, &D.110713);
                  try
                    {
                      retval.105 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator== (&iterFind, &D.110714);
                    }
                  finally
                    {
                      D.110714 = {CLOBBER};
                    }
                }
              finally
                {
                  D.110713 = {CLOBBER};
                }
              if (retval.105 != 0) goto <D.116773>; else goto <D.116774>;
              <D.116773>:
              D.110715 = Glib::operator+ ("Application_option_arg_callback(): Unknown option ", &cpp_option_name); [return slot optimization]
              try
                {
                  Glib::OptionError::OptionError (&D.110725, 0, &D.110715);
                  try
                    {
                      Glib::Error::propagate (&D.110725.D.82441, error);
                    }
                  finally
                    {
                      Glib::OptionError::~OptionError (&D.110725);
                      D.110725 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::ustring::~ustring (&D.110715);
                  D.110715 = {CLOBBER};
                }
              D.116775 = 0;
              return D.116775;
              <D.116774>:
              has_value.106 = value != 0B;
              has_value = has_value.106;
              D.116777 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::operator-> (&iterFind);
              option_arg = D.116777->second;
              try
                {
                  {
                    {
                      retval.107 = {anonymous}::OptionArgCallbackData::is_filename_option (option_arg);
                      if (retval.107 != 0) goto <D.116779>; else goto <D.116780>;
                      <D.116779>:
                      {
                        const struct SlotOptionArgFilename * the_slot;
                        const struct string cpp_value;

                        try
                          {
                            the_slot = {anonymous}::OptionArgCallbackData::get_slot_filename (option_arg);
                            Glib::Threads::Mutex::Lock::release (&lock);
                            std::allocator<char>::allocator (&D.110731);
                            try
                              {
                                if (value != 0B) goto <D.116782>; else goto <D.116783>;
                                <D.116782>:
                                iftmp.108 = value;
                                goto <D.116784>;
                                <D.116783>:
                                iftmp.108 = "";
                                <D.116784>:
                                std::basic_string<char>::basic_string (&cpp_value, iftmp.108, &D.110731);
                              }
                            finally
                              {
                                try
                                  {
                                    std::allocator<char>::~allocator (&D.110731);
                                  }
                                catch
                                  {
                                    std::basic_string<char>::~basic_string (&cpp_value);
                                  }
                                D.110731 = {CLOBBER};
                              }
                            try
                              {
                                D.116785 = &the_slot->D.109422;
                                D.116786 = sigc::slot3<bool, const Glib::ustring&, const std::basic_string<char>&, bool>::operator() (D.116785, &cpp_option_name, &cpp_value, &has_value);
                                D.116775 = (gboolean) D.116786;
                                return D.116775;
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&cpp_value);
                              }
                          }
                        finally
                          {
                            cpp_value = {CLOBBER};
                          }
                      }
                      <D.116780>:
                      {
                        const struct SlotOptionArgString * the_slot;
                        const struct ustring cpp_value;

                        try
                          {
                            the_slot = {anonymous}::OptionArgCallbackData::get_slot_string (option_arg);
                            Glib::Threads::Mutex::Lock::release (&lock);
                            if (value != 0B) goto <D.116788>; else goto <D.116789>;
                            <D.116788>:
                            iftmp.109 = value;
                            goto <D.116790>;
                            <D.116789>:
                            iftmp.109 = "";
                            <D.116790>:
                            Glib::ustring::ustring (&cpp_value, iftmp.109);
                            try
                              {
                                D.116791 = &the_slot->D.109303;
                                D.116792 = sigc::slot3<bool, const Glib::ustring&, const Glib::ustring&, bool>::operator() (D.116791, &cpp_option_name, &cpp_value, &has_value);
                                D.116775 = (gboolean) D.116792;
                                return D.116775;
                              }
                            finally
                              {
                                Glib::ustring::~ustring (&cpp_value);
                              }
                          }
                        finally
                          {
                            cpp_value = {CLOBBER};
                          }
                      }
                    }
                  }
                }
              catch
                {
                  catch (struct Error)
                    {
                      {
                        struct Error & err;

                        try
                          {
                            D.116793 = __builtin_eh_pointer (0);
                            err.110 = __cxa_begin_catch (D.116793);
                            err = err.110;
                            Glib::Error::propagate (err, error);
                          }
                        finally
                          {
                            __cxa_end_catch ();
                          }
                      }
                    }
                  catch (NULL)
                    {
                      try
                        {
                          D.116794 = __builtin_eh_pointer (0);
                          __cxa_begin_catch (D.116794);
                          Glib::exception_handlers_invoke ();
                        }
                      finally
                        {
                          __cxa_end_catch ();
                        }
                    }
                }
              D.116775 = 0;
              return D.116775;
            }
          finally
            {
              Glib::Threads::Mutex::Lock::~Lock (&lock);
            }
        }
      finally
        {
          Glib::ustring::~ustring (&cpp_option_name);
        }
    }
  finally
    {
      cpp_option_name = {CLOBBER};
      lock = {CLOBBER};
      iterFind = {CLOBBER};
      has_value = {CLOBBER};
    }
}


gchar {anonymous}::OptionArgCallbackData::get_short_name() const (const struct OptionArgCallbackData * const this)
{
  gchar D.116824;

  D.116824 = this->short_name_;
  return D.116824;
}


std::_Rb_tree_const_iterator<_Tp>::_Self& std::_Rb_tree_const_iterator<_Tp>::operator++() [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::_Self = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_const_iterator * const this)
{
  const struct _Rb_tree_node_base * D.116826;
  const struct _Rb_tree_node_base * D.116827;
  struct _Self & D.116828;

  D.116826 = this->_M_node;
  D.116827 = std::_Rb_tree_increment (D.116826);
  this->_M_node = D.116827;
  D.116828 = this;
  return D.116828;
}


bool std::_Rb_tree_const_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::_Self = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree_const_iterator * const this, const struct _Self & __x)
{
  bool D.116830;
  const struct _Rb_tree_node_base * D.116831;
  const struct _Rb_tree_node_base * D.116832;

  D.116831 = this->_M_node;
  D.116832 = __x->_M_node;
  D.116830 = D.116831 != D.116832;
  return D.116830;
}


bool std::_Rb_tree_const_iterator<_Tp>::operator==(const _Self&) const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::_Self = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (const struct _Rb_tree_const_iterator * const this, const struct _Self & __x)
{
  bool D.116834;
  const struct _Rb_tree_node_base * D.116835;
  const struct _Rb_tree_node_base * D.116836;

  D.116835 = this->_M_node;
  D.116836 = __x->_M_node;
  D.116834 = D.116835 == D.116836;
  return D.116834;
}


Glib::ustring Glib::operator+(const char*, const Glib::ustring&) (const char * lhs, const struct ustring & rhs)
{
  struct ustring temp [value-expr: *<retval>];

  Glib::ustring::ustring (<retval>, lhs);
  try
    {
      Glib::ustring::operator+= (<retval>, rhs);
      return <retval>;
    }
  catch
    {
      Glib::ustring::~ustring (<retval>);
    }
}


const _Tp* std::_Rb_tree_const_iterator<_Tp>::operator->() const [with _Tp = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; std::_Rb_tree_const_iterator<_Tp>::pointer = const std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>*] (const struct _Rb_tree_const_iterator * const this)
{
  const struct pair * D.116841;
  const struct _Rb_tree_node_base * D.116842;

  D.116842 = this->_M_node;
  D.116841 = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >::_M_valptr (D.116842);
  return D.116841;
}


bool {anonymous}::OptionArgCallbackData::is_filename_option() const (const struct OptionArgCallbackData * const this)
{
  bool D.116845;
  struct SlotOptionArgFilename * D.116846;

  D.116846 = this->slot_filename_;
  D.116845 = D.116846 != 0B;
  return D.116845;
}


const SlotOptionArgFilename* {anonymous}::OptionArgCallbackData::get_slot_filename() const (const struct OptionArgCallbackData * const this)
{
  const struct SlotOptionArgFilename * D.116848;

  D.116848 = this->slot_filename_;
  return D.116848;
}


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

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

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


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

  try
    {
      {

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


T_return sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::operator()(sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_) const [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const std::basic_string<char>&; T_arg3 = bool; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_ = const Glib::ustring&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_ = const std::basic_string<char>&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_ = const bool&] (const struct slot3 * const this, const struct ustring & _A_a1, const struct basic_string & _A_a2, const bool & _A_a3)
{
  bool retval.111;
  bool iftmp.112;
  const struct slot_base * D.116856;
  bool D.116857;
  bool D.116858;
  bool D.116860;
  bool D.116861;
  bool D.116865;
  struct rep_type * D.116866;
  void * (*<T605>) (void *) D.116867;

  D.116856 = &this->D.109380;
  D.116857 = sigc::slot_base::empty (D.116856);
  D.116858 = ~D.116857;
  if (D.116858 != 0) goto <D.116859>; else goto <D.116854>;
  <D.116859>:
  D.116856 = &this->D.109380;
  D.116860 = sigc::slot_base::blocked (D.116856);
  D.116861 = ~D.116860;
  if (D.116861 != 0) goto <D.116862>; else goto <D.116854>;
  <D.116862>:
  iftmp.112 = 1;
  goto <D.116855>;
  <D.116854>:
  iftmp.112 = 0;
  <D.116855>:
  retval.111 = iftmp.112;
  if (retval.111 != 0) goto <D.116863>; else goto <D.116864>;
  <D.116863>:
  D.116866 = this->D.109380.rep_;
  D.116867 = D.116866->call_;
  D.116866 = this->D.109380.rep_;
  D.116865 = D.116867 (D.116866, _A_a1, _A_a2, _A_a3);
  return D.116865;
  <D.116864>:
  D.116865 = 0;
  return D.116865;
}


const SlotOptionArgString* {anonymous}::OptionArgCallbackData::get_slot_string() const (const struct OptionArgCallbackData * const this)
{
  const struct SlotOptionArgString * D.116870;

  D.116870 = this->slot_string_;
  return D.116870;
}


T_return sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::operator()(sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_) const [with T_return = bool; T_arg1 = const Glib::ustring&; T_arg2 = const Glib::ustring&; T_arg3 = bool; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_ = const Glib::ustring&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_ = const Glib::ustring&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_ = const bool&] (const struct slot3 * const this, const struct ustring & _A_a1, const struct ustring & _A_a2, const bool & _A_a3)
{
  bool retval.113;
  bool iftmp.114;
  const struct slot_base * D.116876;
  bool D.116877;
  bool D.116878;
  bool D.116880;
  bool D.116881;
  bool D.116885;
  struct rep_type * D.116886;
  void * (*<T605>) (void *) D.116887;

  D.116876 = &this->D.109261;
  D.116877 = sigc::slot_base::empty (D.116876);
  D.116878 = ~D.116877;
  if (D.116878 != 0) goto <D.116879>; else goto <D.116874>;
  <D.116879>:
  D.116876 = &this->D.109261;
  D.116880 = sigc::slot_base::blocked (D.116876);
  D.116881 = ~D.116880;
  if (D.116881 != 0) goto <D.116882>; else goto <D.116874>;
  <D.116882>:
  iftmp.114 = 1;
  goto <D.116875>;
  <D.116874>:
  iftmp.114 = 0;
  <D.116875>:
  retval.113 = iftmp.114;
  if (retval.113 != 0) goto <D.116883>; else goto <D.116884>;
  <D.116883>:
  D.116886 = this->D.109261.rep_;
  D.116887 = D.116886->call_;
  D.116886 = this->D.109261.rep_;
  D.116885 = D.116887 (D.116886, _A_a1, _A_a2, _A_a3);
  return D.116885;
  <D.116884>:
  D.116885 = 0;
  return D.116885;
}


Glib::OptionError::~OptionError() (struct OptionError * const this)
{
  struct Error * D.116890;
  int D.116891;

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

          }
        finally
          {
            D.116890 = &this->D.82441;
            Glib::Error::~Error (D.116890);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.115435>:
  D.116891 = 0;
  if (D.116891 != 0) goto <D.116892>; else goto <D.116893>;
  <D.116892>:
  operator delete (this);
  goto <D.116894>;
  <D.116893>:
  <D.116894>:
}


virtual Glib::OptionError::~OptionError() (struct OptionError * const this)
{
  Glib::OptionError::~OptionError (this);
  <D.115439>:
  operator delete (this);
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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.113379;
  struct _Rep * D.116897;
  struct _Alloc_hider * D.116898;

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


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

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


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

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


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

  try
    {
      {

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


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.116908;
  char * D.116909;

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


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

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


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.115;
  struct _Rep & D.116915;
  bool D.116916;
  long int D.116917;
  long int D.116918;
  bool retval.116;
  _Atomic_word * D.116922;
  int D.116923;

  D.116915 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.116916 = D.116915 != this;
  D.116917 = (long int) D.116916;
  D.116918 = __builtin_expect (D.116917, 0);
  retval.115 = D.116918 != 0;
  if (retval.115 != 0) goto <D.116919>; else goto <D.116920>;
  <D.116919>:
  D.116922 = &this->D.18966._M_refcount;
  D.116923 = __gnu_cxx::__exchange_and_add_dispatch (D.116922, -1);
  retval.116 = D.116923 <= 0;
  if (retval.116 != 0) goto <D.116924>; else goto <D.116925>;
  <D.116924>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.116926>;
  <D.116925>:
  <D.116926>:
  goto <D.116927>;
  <D.116920>:
  <D.116927>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.117;
  int D.116932;
  _Atomic_word D.116935;

  D.116932 = __gthread_active_p ();
  retval.117 = D.116932 != 0;
  if (retval.117 != 0) goto <D.116933>; else goto <D.116934>;
  <D.116933>:
  D.116935 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.116935;
  <D.116934>:
  D.116935 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.116935;
}


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

  D.116938 = __gthrw___pthread_key_create != 0B;
  D.116937 = (int) D.116938;
  return D.116937;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.116940;
  unsigned int __val.118;
  unsigned int D.116942;

  __val.118 = (unsigned int) __val;
  D.116942 = __atomic_fetch_add_4 (__mem, __val.118, 4);
  D.116940 = (_Atomic_word) D.116942;
  return D.116940;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.116944;
  int D.116945;
  _Atomic_word D.116946;
  _Atomic_word __result;

  __result = *__mem;
  D.116944 = *__mem;
  D.116945 = D.116944 + __val;
  *__mem = D.116945;
  D.116946 = __result;
  return D.116946;
}


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.113373>:
}


void {anonymous}::Application_delete_extra_application_data(gpointer) (void * data)
{
  struct ExtraApplicationData * extra_application_data.119;
  struct ExtraApplicationData * extra_application_data;

  extra_application_data = data;
  extra_application_data.119 = extra_application_data;
  if (extra_application_data.119 != 0B) goto <D.116949>; else goto <D.116950>;
  <D.116949>:
  {anonymous}::ExtraApplicationData::~ExtraApplicationData (extra_application_data.119);
  operator delete (extra_application_data.119);
  goto <D.116951>;
  <D.116950>:
  <D.116951>:
}


{anonymous}::ExtraApplicationData::~ExtraApplicationData() (struct ExtraApplicationData * const this)
{
  struct vector * D.116952;
  char * & D.116953;
  char * D.116954;
  char * & D.116955;
  bool retval.120;
  struct iterator D.108217;

  {
    try
      {
        try
          {
            {
              {
                struct iterator iter;

                try
                  {
                    D.116952 = &this->option_entry_strings;
                    iter = std::vector<char*>::begin (D.116952);
                    goto <D.108215>;
                    <D.108216>:
                    D.116953 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::operator* (&iter);
                    D.116954 = *D.116953;
                    g_free (D.116954);
                    D.116955 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::operator* (&iter);
                    *D.116955 = 0B;
                    __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::operator++ (&iter);
                    <D.108215>:
                    D.116952 = &this->option_entry_strings;
                    D.108217 = std::vector<char*>::end (D.116952);
                    try
                      {
                        retval.120 = __gnu_cxx::operator!=<char**, std::vector<char*> > (&iter, &D.108217);
                      }
                    finally
                      {
                        D.108217 = {CLOBBER};
                      }
                    if (retval.120 != 0) goto <D.108216>; else goto <D.108218>;
                    <D.108218>:
                  }
                finally
                  {
                    iter = {CLOBBER};
                  }
              }
            }
          }
        finally
          {
            D.116952 = &this->option_entry_strings;
            std::vector<char*>::~vector (D.116952);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.108219>:
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::begin() [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = char**] (struct vector * const this)
{
  struct iterator D.116962;
  struct iterator D.113727;
  char * * * D.116963;

  D.116963 = &this->D.108062._M_impl._M_start;
  __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::__normal_iterator (&D.113727, D.116963);
  try
    {
      D.116962 = D.113727;
      return D.116962;
    }
  finally
    {
      D.113727 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = char**; _Container = std::vector<char*>] (struct __normal_iterator * const this, char * * const & __i)
{
  char * * D.116966;

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


__gnu_cxx::__normal_iterator<_Iterator, _Container>::reference __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator*() const [with _Iterator = char**; _Container = std::vector<char*>; __gnu_cxx::__normal_iterator<_Iterator, _Container>::reference = char*&] (const struct __normal_iterator * const this)
{
  char * & D.116967;

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


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++() [with _Iterator = char**; _Container = std::vector<char*>] (struct __normal_iterator * const this)
{
  char * * D.116969;
  char * * D.116970;
  struct __normal_iterator & D.116971;

  D.116969 = this->_M_current;
  D.116970 = D.116969 + 8;
  this->_M_current = D.116970;
  D.116971 = this;
  return D.116971;
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::end() [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = char**] (struct vector * const this)
{
  struct iterator D.116973;
  struct iterator D.113729;
  char * * * D.116974;

  D.116974 = &this->D.108062._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::__normal_iterator (&D.113729, D.116974);
  try
    {
      D.116973 = D.113729;
      return D.116973;
    }
  finally
    {
      D.113729 = {CLOBBER};
    }
}


bool __gnu_cxx::operator!=(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = char**; _Container = std::vector<char*>] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  bool D.116977;
  char * * const & D.116978;
  char * * D.116979;
  char * * const & D.116980;
  char * * D.116981;

  D.116978 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (__lhs);
  D.116979 = *D.116978;
  D.116980 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (__rhs);
  D.116981 = *D.116980;
  D.116977 = D.116979 != D.116981;
  return D.116977;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = char**; _Container = std::vector<char*>] (const struct __normal_iterator * const this)
{
  char * * const & D.116983;

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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = char*; _Alloc = std::allocator<char*>] (struct vector * const this)
{
  struct _Vector_base * D.116985;
  struct _Tp_alloc_type & D.116986;
  char * * D.116987;
  char * * D.116988;

  {
    try
      {
        try
          {
            D.116985 = &this->D.108062;
            D.116986 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.116985);
            D.116987 = this->D.108062._M_impl._M_finish;
            D.116988 = this->D.108062._M_impl._M_start;
            std::_Destroy<char**, char*> (D.116988, D.116987, D.116986);
          }
        finally
          {
            D.116985 = &this->D.108062;
            std::_Vector_base<char*, std::allocator<char*> >::~_Vector_base (D.116985);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.113723>:
}


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

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


void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = char**; _Tp = char*] (char * * __first, char * * __last, struct allocator & D.113716)
{
  std::_Destroy<char**> (__first, __last);
}


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

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


static void std::_Destroy_aux<true>::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = char**] (char * * D.114718, char * * D.114719)
{
  GIMPLE_NOP
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = char*; _Alloc = std::allocator<char*>] (struct _Vector_base * const this)
{
  char * * D.116993;
  long int D.116994;
  char * * D.116995;
  long int D.116996;
  long int D.116997;
  long int D.116998;
  long unsigned int D.116999;
  struct _Vector_impl * D.117000;

  {
    try
      {
        try
          {
            D.116993 = this->_M_impl._M_end_of_storage;
            D.116994 = (long int) D.116993;
            D.116995 = this->_M_impl._M_start;
            D.116996 = (long int) D.116995;
            D.116997 = D.116994 - D.116996;
            D.116998 = D.116997 /[ex] 8;
            D.116999 = (long unsigned int) D.116998;
            D.116995 = this->_M_impl._M_start;
            std::_Vector_base<char*, std::allocator<char*> >::_M_deallocate (this, D.116995, D.116999);
          }
        finally
          {
            D.117000 = &this->_M_impl;
            std::_Vector_base<char*, std::allocator<char*> >::_Vector_impl::~_Vector_impl (D.117000);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114336>:
}


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

  if (__p != 0B) goto <D.117003>; else goto <D.117004>;
  <D.117003>:
  D.117005 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<char*> >::deallocate (D.117005, __p, __n);
  goto <D.117006>;
  <D.117004>:
  <D.117006>:
}


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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


void* memset(void*, int, size_t) (void * __dest, int __ch, size_t __len)
{
  int D.117011;
  int D.117016;
  void * D.117018;
  long unsigned int D.117019;
  void * D.117020;

  try
    {
      D.117011 = __builtin_constant_p (__len);
      if (D.117011 != 0) goto <D.117012>; else goto <D.117013>;
      <D.117012>:
      if (__len == 0) goto <D.117014>; else goto <D.117015>;
      <D.117014>:
      D.117016 = __builtin_constant_p (__ch);
      if (D.117016 == 0) goto <D.117009>; else goto <D.117017>;
      <D.117017>:
      if (__ch != 0) goto <D.117009>; else goto <D.117010>;
      <D.117009>:
      __warn_memset_zero_len ();
      D.117018 = __dest;
      return D.117018;
      <D.117010>:
      <D.117015>:
      <D.117013>:
      D.117019 = __builtin_object_size (__dest, 0);
      D.117018 = __builtin___memset_chk (__dest, __ch, __len, D.117019);
      return D.117018;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.117020 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.117020);
          
        }
    }
}


{anonymous}::ExtraApplicationData::ExtraApplicationData() (struct ExtraApplicationData * const this)
{
  struct vector * D.117024;

  D.117024 = &this->option_entry_strings;
  std::vector<char*>::vector (D.117024);
  try
    {

    }
  catch
    {
      D.117024 = &this->option_entry_strings;
      std::vector<char*>::~vector (D.117024);
    }
}


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

  D.117025 = &this->D.108062;
  std::_Vector_base<char*, std::allocator<char*> >::_Vector_base (D.117025);
  try
    {

    }
  catch
    {
      D.117025 = &this->D.108062;
      std::_Vector_base<char*, std::allocator<char*> >::~_Vector_base (D.117025);
    }
}


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

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

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


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


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

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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::value_type = char*] (struct vector * const this, char * const & __x)
{
  char * * D.117029;
  char * * D.117030;
  struct _Vector_impl * D.117033;
  char * * D.117034;
  struct __normal_iterator D.117036;

  D.117029 = this->D.108062._M_impl._M_finish;
  D.117030 = this->D.108062._M_impl._M_end_of_storage;
  if (D.117029 != D.117030) goto <D.117031>; else goto <D.117032>;
  <D.117031>:
  D.117029 = this->D.108062._M_impl._M_finish;
  D.117033 = &this->D.108062._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<char*> >::construct<char*> (D.117033, D.117029, __x);
  D.117029 = this->D.108062._M_impl._M_finish;
  D.117034 = D.117029 + 8;
  this->D.108062._M_impl._M_finish = D.117034;
  goto <D.117035>;
  <D.117032>:
  D.117036 = std::vector<char*>::end (this);
  std::vector<char*>::_M_insert_aux (this, D.117036, __x);
  <D.117035>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::construct(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, const _Tp&) [with _Tp = char*; _Alloc = std::allocator<char*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = char**] (struct allocator & __a, char * * __p, char * const & __arg)
{
  __gnu_cxx::new_allocator<char*>::construct (__a, __p, __arg);
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = char*; __gnu_cxx::new_allocator<_Tp>::pointer = char**] (struct new_allocator * const this, char * * __p, char * const & __val)
{
  void * D.114839;
  void * D.114840;
  char * * iftmp.121;
  char * D.117040;

  D.114839 = __p;
  D.114840 = operator new (8, D.114839);
  if (D.114840 != 0B) goto <D.117038>; else goto <D.117039>;
  <D.117038>:
  try
    {
      D.117040 = *__val;
      MEM[(char * *)D.114840] = D.117040;
    }
  catch
    {
      operator delete (D.114840, D.114839);
    }
  iftmp.121 = D.114840;
  goto <D.117041>;
  <D.117039>:
  iftmp.121 = D.114840;
  <D.117041>:
}


void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = char**] (struct vector * const this, struct iterator __position, char * const & __x)
{
  char * * D.117042;
  char * * D.117043;
  char * const * D.117046;
  struct _Vector_impl * D.117047;
  char * * D.117048;
  char * * D.117049;
  char * * D.117050;
  char * * const & D.117051;
  char * * D.117052;
  char * & D.117053;
  struct iterator D.114557;
  long int D.117055;
  struct _Vector_base * D.117056;
  long unsigned int D.117057;
  char * * D.117058;
  struct _Tp_alloc_type & D.117059;
  char * * const & D.117060;
  char * * D.117061;
  char * * D.117062;
  struct _Tp_alloc_type & D.117063;
  char * * const & D.117064;
  char * * D.117065;
  void * D.117066;
  struct _Tp_alloc_type & D.117070;
  struct _Tp_alloc_type & D.117071;
  long int D.117072;
  long int D.117073;
  long int D.117074;
  long int D.117075;
  long unsigned int D.117076;
  long unsigned int D.117077;
  char * * D.117078;

  {
    D.117042 = this->D.108062._M_impl._M_finish;
    D.117043 = this->D.108062._M_impl._M_end_of_storage;
    if (D.117042 != D.117043) goto <D.117044>; else goto <D.117045>;
    <D.117044>:
    {
      char * __x_copy;

      D.117042 = this->D.108062._M_impl._M_finish;
      D.117046 = D.117042 + 18446744073709551608;
      D.117042 = this->D.108062._M_impl._M_finish;
      D.117047 = &this->D.108062._M_impl;
      __gnu_cxx::__alloc_traits<std::allocator<char*> >::construct<char*> (D.117047, D.117042, D.117046);
      D.117042 = this->D.108062._M_impl._M_finish;
      D.117048 = D.117042 + 8;
      this->D.108062._M_impl._M_finish = D.117048;
      __x_copy = *__x;
      D.117042 = this->D.108062._M_impl._M_finish;
      D.117049 = D.117042 + 18446744073709551608;
      D.117042 = this->D.108062._M_impl._M_finish;
      D.117050 = D.117042 + 18446744073709551600;
      D.117051 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (&__position);
      D.117052 = *D.117051;
      std::copy_backward<char**, char**> (D.117052, D.117050, D.117049);
      D.117053 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::operator* (&__position);
      *D.117053 = __x_copy;
    }
    goto <D.117054>;
    <D.117045>:
    {
      const size_type __len;
      const size_type __elems_before;
      char * * __new_start;
      char * * __new_finish;

      __len = std::vector<char*>::_M_check_len (this, 1, "vector::_M_insert_aux");
      D.114557 = std::vector<char*>::begin (this);
      try
        {
          D.117055 = __gnu_cxx::operator-<char**, std::vector<char*> > (&__position, &D.114557);
          __elems_before = (const size_type) D.117055;
        }
      finally
        {
          D.114557 = {CLOBBER};
        }
      D.117056 = &this->D.108062;
      __new_start = std::_Vector_base<char*, std::allocator<char*> >::_M_allocate (D.117056, __len);
      __new_finish = __new_start;
      try
        {
          D.117057 = __elems_before * 8;
          D.117058 = __new_start + D.117057;
          D.117047 = &this->D.108062._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<char*> >::construct<char*> (D.117047, D.117058, __x);
          __new_finish = 0B;
          D.117056 = &this->D.108062;
          D.117059 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.117056);
          D.117060 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (&__position);
          D.117061 = *D.117060;
          D.117062 = this->D.108062._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<char**, char**, std::allocator<char*> > (D.117062, D.117061, __new_start, D.117059);
          __new_finish = __new_finish + 8;
          D.117056 = &this->D.108062;
          D.117063 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.117056);
          D.117042 = this->D.108062._M_impl._M_finish;
          D.117064 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (&__position);
          D.117065 = *D.117064;
          __new_finish = std::__uninitialized_move_if_noexcept_a<char**, char**, std::allocator<char*> > (D.117065, D.117042, __new_finish, D.117063);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117066 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117066);
                  if (__new_finish == 0B) goto <D.117067>; else goto <D.117068>;
                  <D.117067>:
                  D.117057 = __elems_before * 8;
                  D.117058 = __new_start + D.117057;
                  D.117047 = &this->D.108062._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<char*> >::destroy (D.117047, D.117058);
                  goto <D.117069>;
                  <D.117068>:
                  D.117056 = &this->D.108062;
                  D.117070 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.117056);
                  std::_Destroy<char**, char*> (__new_start, __new_finish, D.117070);
                  <D.117069>:
                  D.117056 = &this->D.108062;
                  std::_Vector_base<char*, std::allocator<char*> >::_M_deallocate (D.117056, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.117056 = &this->D.108062;
      D.117071 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.117056);
      D.117042 = this->D.108062._M_impl._M_finish;
      D.117062 = this->D.108062._M_impl._M_start;
      std::_Destroy<char**, char*> (D.117062, D.117042, D.117071);
      D.117043 = this->D.108062._M_impl._M_end_of_storage;
      D.117072 = (long int) D.117043;
      D.117062 = this->D.108062._M_impl._M_start;
      D.117073 = (long int) D.117062;
      D.117074 = D.117072 - D.117073;
      D.117075 = D.117074 /[ex] 8;
      D.117076 = (long unsigned int) D.117075;
      D.117062 = this->D.108062._M_impl._M_start;
      D.117056 = &this->D.108062;
      std::_Vector_base<char*, std::allocator<char*> >::_M_deallocate (D.117056, D.117062, D.117076);
      this->D.108062._M_impl._M_start = __new_start;
      this->D.108062._M_impl._M_finish = __new_finish;
      D.117077 = __len * 8;
      D.117078 = __new_start + D.117077;
      this->D.108062._M_impl._M_end_of_storage = D.117078;
    }
    <D.117054>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = char**; _BI2 = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117086;
  char * * D.117087;
  char * * D.117088;

  D.117087 = std::__miter_base<char**> (__last);
  D.117088 = std::__miter_base<char**> (__first);
  D.117086 = std::__copy_move_backward_a2<false, char**, char**> (D.117088, D.117087, __result);
  return D.117086;
}


typename std::_Miter_base<_Iterator>::iterator_type std::__miter_base(_Iterator) [with _Iterator = char**; typename std::_Miter_base<_Iterator>::iterator_type = char**] (char * * __it)
{
  char * * D.117093;

  D.117093 = std::_Iter_base<char**, false>::_S_base (__it);
  return D.117093;
}


static std::_Iter_base<_Iterator, _HasBase>::iterator_type std::_Iter_base<_Iterator, _HasBase>::_S_base(_Iterator) [with _Iterator = char**; bool _HasBase = false; std::_Iter_base<_Iterator, _HasBase>::iterator_type = char**] (char * * __it)
{
  char * * D.117095;

  D.117095 = __it;
  return D.117095;
}


_BI2 std::__copy_move_backward_a2(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = char**; _BI2 = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117097;
  char * * D.117098;
  char * * D.117099;
  char * * D.117100;

  D.117098 = std::__niter_base<char**> (__result);
  D.117099 = std::__niter_base<char**> (__last);
  D.117100 = std::__niter_base<char**> (__first);
  D.117097 = std::__copy_move_backward_a<false, char**, char**> (D.117100, D.117099, D.117098);
  return D.117097;
}


typename std::_Niter_base<_Iterator>::iterator_type std::__niter_base(_Iterator) [with _Iterator = char**; typename std::_Niter_base<_Iterator>::iterator_type = char**] (char * * __it)
{
  char * * D.117103;

  D.117103 = std::_Iter_base<char**, false>::_S_base (__it);
  return D.117103;
}


_BI2 std::__copy_move_backward_a(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = char**; _BI2 = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117105;
  typedef char * _ValueType1;
  typedef char * _ValueType2;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.117105 = std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<char*> (__first, __last, __result);
  return D.117105;
}


static _Tp* std::__copy_move_backward<_IsMove, true, std::random_access_iterator_tag>::__copy_move_b(const _Tp*, const _Tp*, _Tp*) [with _Tp = char*; bool _IsMove = false] (char * const * __first, char * const * __last, char * * __result)
{
  long int __last.122;
  long int __first.123;
  long int D.117109;
  long unsigned int _Num.124;
  long unsigned int D.117113;
  sizetype D.117114;
  char * * D.117115;
  char * * D.117117;
  const ptrdiff_t _Num;

  __last.122 = (long int) __last;
  __first.123 = (long int) __first;
  D.117109 = __last.122 - __first.123;
  _Num = D.117109 /[ex] 8;
  if (_Num != 0) goto <D.117110>; else goto <D.117111>;
  <D.117110>:
  _Num.124 = (long unsigned int) _Num;
  D.117113 = _Num.124 * 8;
  _Num.124 = (long unsigned int) _Num;
  D.117113 = _Num.124 * 8;
  D.117114 = -D.117113;
  D.117115 = __result + D.117114;
  __builtin_memmove (D.117115, __first, D.117113);
  goto <D.117116>;
  <D.117111>:
  <D.117116>:
  _Num.124 = (long unsigned int) _Num;
  D.117113 = _Num.124 * 8;
  D.117114 = -D.117113;
  D.117117 = __result + D.117114;
  return D.117117;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::_M_check_len(std::vector<_Tp, _Alloc>::size_type, const char*) const [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n, const char * __s)
{
  bool retval.125;
  long unsigned int D.117120;
  long unsigned int D.117121;
  long unsigned int D.117122;
  long unsigned int __n.126;
  long unsigned int D.117126;
  const long unsigned int D.114864;
  long unsigned int D.117127;
  const long unsigned int & D.117128;
  long unsigned int D.117129;
  size_type D.117130;
  size_type iftmp.127;
  long unsigned int D.117135;
  long unsigned int D.117137;
  const size_type __len;

  D.117120 = std::vector<char*>::max_size (this);
  D.117121 = std::vector<char*>::size (this);
  D.117122 = D.117120 - D.117121;
  __n.126 = __n;
  retval.125 = D.117122 < __n.126;
  if (retval.125 != 0) goto <D.117124>; else goto <D.117125>;
  <D.117124>:
  std::__throw_length_error (__s);
  <D.117125>:
  D.117126 = std::vector<char*>::size (this);
  D.117127 = std::vector<char*>::size (this);
  D.114864 = D.117127;
  try
    {
      D.117128 = std::max<long unsigned int> (&D.114864, &__n);
      D.117129 = *D.117128;
      __len = D.117126 + D.117129;
    }
  finally
    {
      D.114864 = {CLOBBER};
    }
  D.117135 = std::vector<char*>::size (this);
  if (D.117135 > __len) goto <D.117132>; else goto <D.117136>;
  <D.117136>:
  D.117137 = std::vector<char*>::max_size (this);
  if (D.117137 < __len) goto <D.117132>; else goto <D.117133>;
  <D.117132>:
  iftmp.127 = std::vector<char*>::max_size (this);
  goto <D.117134>;
  <D.117133>:
  iftmp.127 = __len;
  <D.117134>:
  D.117130 = iftmp.127;
  return D.117130;
}


const _Tp& std::max(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.117142;
  long unsigned int D.117143;
  const long unsigned int & D.117146;

  D.117142 = *__a;
  D.117143 = *__b;
  if (D.117142 < D.117143) goto <D.117144>; else goto <D.117145>;
  <D.117144>:
  D.117146 = __b;
  return D.117146;
  <D.117145>:
  D.117146 = __a;
  return D.117146;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.117148;
  char * * D.117149;
  long int D.117150;
  char * * D.117151;
  long int D.117152;
  long int D.117153;
  long int D.117154;

  D.117149 = this->D.108062._M_impl._M_finish;
  D.117150 = (long int) D.117149;
  D.117151 = this->D.108062._M_impl._M_start;
  D.117152 = (long int) D.117151;
  D.117153 = D.117150 - D.117152;
  D.117154 = D.117153 /[ex] 8;
  D.117148 = (size_type) D.117154;
  return D.117148;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::max_size() const [with _Tp = char*; _Alloc = std::allocator<char*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.117156;
  const struct _Vector_base * D.117157;
  const struct _Tp_alloc_type & D.117158;

  D.117157 = &this->D.108062;
  D.117158 = std::_Vector_base<char*, std::allocator<char*> >::_M_get_Tp_allocator (D.117157);
  D.117156 = __gnu_cxx::__alloc_traits<std::allocator<char*> >::max_size (D.117158);
  return D.117156;
}


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

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


static __gnu_cxx::__alloc_traits<_Alloc>::size_type __gnu_cxx::__alloc_traits<_Alloc>::max_size(const _Alloc&) [with _Alloc = std::allocator<char*>; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (const struct allocator & __a)
{
  size_type D.117162;

  D.117162 = __gnu_cxx::new_allocator<char*>::max_size (__a);
  return D.117162;
}


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

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


typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type __gnu_cxx::operator-(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = char**; _Container = std::vector<char*>; typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type = long int] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  difference_type D.117167;
  char * * const & D.117168;
  char * * D.117169;
  long int D.117170;
  char * * const & D.117171;
  char * * D.117172;
  long int D.117173;
  long int D.117174;

  D.117168 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (__lhs);
  D.117169 = *D.117168;
  D.117170 = (long int) D.117169;
  D.117171 = __gnu_cxx::__normal_iterator<char**, std::vector<char*> >::base (__rhs);
  D.117172 = *D.117171;
  D.117173 = (long int) D.117172;
  D.117174 = D.117170 - D.117173;
  D.117167 = D.117174 /[ex] 8;
  return D.117167;
}


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

  if (__n != 0) goto <D.117178>; else goto <D.117179>;
  <D.117178>:
  D.117180 = &this->_M_impl;
  iftmp.128 = __gnu_cxx::__alloc_traits<std::allocator<char*> >::allocate (D.117180, __n);
  goto <D.117181>;
  <D.117179>:
  iftmp.128 = 0B;
  <D.117181>:
  D.117176 = iftmp.128;
  return D.117176;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = char*; __gnu_cxx::new_allocator<_Tp>::pointer = char**; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.107375)
{
  bool retval.129;
  long unsigned int D.117188;
  char * * D.117191;
  long unsigned int D.117192;

  D.117188 = __gnu_cxx::new_allocator<char*>::max_size (this);
  retval.129 = D.117188 < __n;
  if (retval.129 != 0) goto <D.117189>; else goto <D.117190>;
  <D.117189>:
  std::__throw_bad_alloc ();
  <D.117190>:
  D.117192 = __n * 8;
  D.117191 = operator new (D.117192);
  return D.117191;
}


_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = char**; _ForwardIterator = char**; _Allocator = std::allocator<char*>] (char * * __first, char * * __last, char * * __result, struct allocator & __alloc)
{
  char * * D.117195;

  D.117195 = std::__uninitialized_copy_a<char**, char**, char*> (__first, __last, __result, __alloc);
  return D.117195;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = char**; _ForwardIterator = char**; _Tp = char*] (char * * __first, char * * __last, char * * __result, struct allocator & D.114873)
{
  char * * D.117198;

  D.117198 = std::uninitialized_copy<char**, char**> (__first, __last, __result);
  return D.117198;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = char**; _ForwardIterator = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117201;
  typedef char * _ValueType1;
  typedef char * _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.117201 = std::__uninitialized_copy<true>::__uninit_copy<char**, char**> (__first, __last, __result);
  return D.117201;
}


static _ForwardIterator std::__uninitialized_copy<true>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = char**; _ForwardIterator = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117204;

  D.117204 = std::copy<char**, char**> (__first, __last, __result);
  return D.117204;
}


_OI std::copy(_II, _II, _OI) [with _II = char**; _OI = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117207;
  char * * D.117208;
  char * * D.117209;

  D.117208 = std::__miter_base<char**> (__last);
  D.117209 = std::__miter_base<char**> (__first);
  D.117207 = std::__copy_move_a2<false, char**, char**> (D.117209, D.117208, __result);
  return D.117207;
}


_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = char**; _OI = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117214;
  char * * D.117215;
  char * * D.117216;
  char * * D.117217;

  D.117215 = std::__niter_base<char**> (__result);
  D.117216 = std::__niter_base<char**> (__last);
  D.117217 = std::__niter_base<char**> (__first);
  D.117214 = std::__copy_move_a<false, char**, char**> (D.117217, D.117216, D.117215);
  return D.117214;
}


_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = char**; _OI = char**] (char * * __first, char * * __last, char * * __result)
{
  char * * D.117220;
  typedef char * _ValueTypeI;
  typedef char * _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.117220 = std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<char*> (__first, __last, __result);
  return D.117220;
}


static _Tp* std::__copy_move<_IsMove, true, std::random_access_iterator_tag>::__copy_m(const _Tp*, const _Tp*, _Tp*) [with _Tp = char*; bool _IsMove = false] (char * const * __first, char * const * __last, char * * __result)
{
  long int __last.130;
  long int __first.131;
  long int D.117224;
  long unsigned int _Num.132;
  long unsigned int D.117228;
  char * * D.117230;
  const ptrdiff_t _Num;

  __last.130 = (long int) __last;
  __first.131 = (long int) __first;
  D.117224 = __last.130 - __first.131;
  _Num = D.117224 /[ex] 8;
  if (_Num != 0) goto <D.117225>; else goto <D.117226>;
  <D.117225>:
  _Num.132 = (long unsigned int) _Num;
  D.117228 = _Num.132 * 8;
  __builtin_memmove (__result, __first, D.117228);
  goto <D.117229>;
  <D.117226>:
  <D.117229>:
  _Num.132 = (long unsigned int) _Num;
  D.117228 = _Num.132 * 8;
  D.117230 = __result + D.117228;
  return D.117230;
}


static void __gnu_cxx::__alloc_traits<_Alloc>::destroy(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer) [with _Alloc = std::allocator<char*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = char**] (struct allocator & __a, char * * __p)
{
  __gnu_cxx::new_allocator<char*>::destroy (__a, __p);
}


void __gnu_cxx::new_allocator<_Tp>::destroy(__gnu_cxx::new_allocator<_Tp>::pointer) [with _Tp = char*; __gnu_cxx::new_allocator<_Tp>::pointer = char**] (struct new_allocator * const this, char * * __p)
{
  GIMPLE_NOP
}


Glib::RefPtr<Gio::Application> Glib::wrap(GApplication*, bool) (struct GApplication * object, bool take_copy)
{
  struct Application * iftmp.133;
  int D.117234;
  struct ObjectBase * D.117235;

  D.117234 = (int) take_copy;
  D.117235 = Glib::wrap_auto (object, D.117234);
  if (D.117235 == 0B) goto <D.117236>; else goto <D.117237>;
  <D.117236>:
  iftmp.133 = 0B;
  goto <D.117238>;
  <D.117237>:
  iftmp.133 = __dynamic_cast (D.117235, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
  <D.117238>:
  Glib::RefPtr<Gio::Application>::RefPtr (<retval>, iftmp.133);
  return <retval>;
}


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


const Glib::Class& Gio::Application_Class::init() (struct Application_Class * const this)
{
  long unsigned int D.117241;
  long unsigned int D.117244;
  struct Class * D.117245;
  long unsigned int D.117246;
  long unsigned int D.117247;
  const struct Class & D.117249;

  D.117241 = this->D.106921.gtype_;
  if (D.117241 == 0) goto <D.117242>; else goto <D.117243>;
  <D.117242>:
  this->D.106921.class_init_func_ = class_init_function;
  D.117244 = g_application_get_type ();
  D.117245 = &this->D.106921;
  Glib::Class::register_derived_type (D.117245, D.117244);
  D.117245 = &this->D.106921;
  D.117246 = Glib::Class::get_type (D.117245);
  Gio::ActionGroup::add_interface (D.117246);
  D.117245 = &this->D.106921;
  D.117247 = Glib::Class::get_type (D.117245);
  Gio::ActionMap::add_interface (D.117247);
  goto <D.117248>;
  <D.117243>:
  <D.117248>:
  D.117249 = &this->D.106921;
  return D.117249;
}


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

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


static void Gio::Application_Class::class_init_function(void*, void*) (void * g_class, void * class_data)
{
  struct BaseClassType * const klass;

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
  klass->local_command_line = local_command_line_vfunc_callback;
  klass->before_emit = before_emit_vfunc_callback;
  klass->after_emit = after_emit_vfunc_callback;
  klass->quit_mainloop = quit_mainloop_vfunc_callback;
  klass->run_mainloop = run_mainloop_vfunc_callback;
  klass->startup = startup_callback;
  klass->activate = activate_callback;
  klass->command_line = command_line_callback;
  klass->open = open_callback;
}


static gboolean Gio::Application_Class::local_command_line_vfunc_callback(GApplication*, gchar***, int*) (struct GApplication * self, gchar * * * arguments, int * exit_status)
{
  bool retval.134;
  bool iftmp.135;
  bool D.117259;
  struct CppObjectType * const iftmp.136;
  gboolean D.117269;
  int (*__vtbl_ptr_type) () * D.117270;
  int (*__vtbl_ptr_type) () * D.117271;
  int (*__vtbl_ptr_type) () D.117272;
  bool D.117273;
  void * D.117274;
  struct GTypeClass * D.117277;
  gboolean (*<Tf944>) (struct GApplication *, gchar * * *, int *) D.117280;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117258>; else goto <D.117256>;
    <D.117258>:
    D.117259 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117259 != 0) goto <D.117260>; else goto <D.117256>;
    <D.117260>:
    iftmp.135 = 1;
    goto <D.117257>;
    <D.117256>:
    iftmp.135 = 0;
    <D.117257>:
    retval.134 = iftmp.135;
    if (retval.134 != 0) goto <D.117261>; else goto <D.117262>;
    <D.117261>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117264>; else goto <D.117265>;
      <D.117264>:
      iftmp.136 = 0B;
      goto <D.117266>;
      <D.117265>:
      iftmp.136 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117266>:
      obj = iftmp.136;
      if (obj != 0B) goto <D.117267>; else goto <D.117268>;
      <D.117267>:
      try
        {
          D.117270 = obj->D.106831._vptr.Object;
          D.117271 = D.117270 + 24;
          D.117272 = *D.117271;
          D.117273 = OBJ_TYPE_REF(D.117272;(struct Application)obj->3) (obj, arguments, exit_status);
          D.117269 = (gboolean) D.117273;
          return D.117269;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117274 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117274);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117275>;
      <D.117268>:
      <D.117275>:
    }
    goto <D.117276>;
    <D.117262>:
    <D.117276>:
  }
  D.117277 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117277);
  {
    if (base != 0B) goto <D.117278>; else goto <D.117279>;
    <D.117278>:
    D.117280 = base->local_command_line;
    if (D.117280 != 0B) goto <D.117281>; else goto <D.117282>;
    <D.117281>:
    {
      gboolean retval;

      D.117280 = base->local_command_line;
      retval = D.117280 (self, arguments, exit_status);
      D.117269 = retval;
      return D.117269;
    }
    <D.117282>:
    <D.117279>:
  }
  D.117269 = 0;
  return D.117269;
}


static void Gio::Application_Class::before_emit_vfunc_callback(GApplication*, GVariant*) (struct GApplication * self, struct GVariant * platform_data)
{
  bool retval.137;
  bool iftmp.138;
  bool D.117297;
  struct CppObjectType * const iftmp.139;
  int (*__vtbl_ptr_type) () * D.117307;
  int (*__vtbl_ptr_type) () * D.117308;
  int (*__vtbl_ptr_type) () D.117309;
  struct VariantBase D.111946;
  void * D.117310;
  struct GTypeClass * D.117313;
  void (*<Tf948>) (struct GApplication *, struct GVariant *) D.117316;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117296>; else goto <D.117294>;
    <D.117296>:
    D.117297 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117297 != 0) goto <D.117298>; else goto <D.117294>;
    <D.117298>:
    iftmp.138 = 1;
    goto <D.117295>;
    <D.117294>:
    iftmp.138 = 0;
    <D.117295>:
    retval.137 = iftmp.138;
    if (retval.137 != 0) goto <D.117299>; else goto <D.117300>;
    <D.117299>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117302>; else goto <D.117303>;
      <D.117302>:
      iftmp.139 = 0B;
      goto <D.117304>;
      <D.117303>:
      iftmp.139 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117304>:
      obj = iftmp.139;
      if (obj != 0B) goto <D.117305>; else goto <D.117306>;
      <D.117305>:
      try
        {
          D.117307 = obj->D.106831._vptr.Object;
          D.117308 = D.117307 + 32;
          D.117309 = *D.117308;
          D.111946 = Glib::wrap (platform_data, 1); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.117309;(struct Application)obj->4) (obj, &D.111946);
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.111946);
              D.111946 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117310 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117310);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117311>;
      <D.117306>:
      <D.117311>:
    }
    goto <D.117312>;
    <D.117300>:
    <D.117312>:
  }
  D.117313 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117313);
  if (base != 0B) goto <D.117314>; else goto <D.117315>;
  <D.117314>:
  D.117316 = base->before_emit;
  if (D.117316 != 0B) goto <D.117317>; else goto <D.117318>;
  <D.117317>:
  D.117316 = base->before_emit;
  D.117316 (self, platform_data);
  goto <D.117319>;
  <D.117318>:
  <D.117319>:
  <D.117315>:
}


static void Gio::Application_Class::after_emit_vfunc_callback(GApplication*, GVariant*) (struct GApplication * self, struct GVariant * platform_data)
{
  bool retval.140;
  bool iftmp.141;
  bool D.117333;
  struct CppObjectType * const iftmp.142;
  int (*__vtbl_ptr_type) () * D.117343;
  int (*__vtbl_ptr_type) () * D.117344;
  int (*__vtbl_ptr_type) () D.117345;
  struct VariantBase D.111955;
  void * D.117346;
  struct GTypeClass * D.117349;
  void (*<Tf948>) (struct GApplication *, struct GVariant *) D.117352;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117332>; else goto <D.117330>;
    <D.117332>:
    D.117333 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117333 != 0) goto <D.117334>; else goto <D.117330>;
    <D.117334>:
    iftmp.141 = 1;
    goto <D.117331>;
    <D.117330>:
    iftmp.141 = 0;
    <D.117331>:
    retval.140 = iftmp.141;
    if (retval.140 != 0) goto <D.117335>; else goto <D.117336>;
    <D.117335>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117338>; else goto <D.117339>;
      <D.117338>:
      iftmp.142 = 0B;
      goto <D.117340>;
      <D.117339>:
      iftmp.142 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117340>:
      obj = iftmp.142;
      if (obj != 0B) goto <D.117341>; else goto <D.117342>;
      <D.117341>:
      try
        {
          D.117343 = obj->D.106831._vptr.Object;
          D.117344 = D.117343 + 40;
          D.117345 = *D.117344;
          D.111955 = Glib::wrap (platform_data, 1); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.117345;(struct Application)obj->5) (obj, &D.111955);
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.111955);
              D.111955 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117346 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117346);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117347>;
      <D.117342>:
      <D.117347>:
    }
    goto <D.117348>;
    <D.117336>:
    <D.117348>:
  }
  D.117349 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117349);
  if (base != 0B) goto <D.117350>; else goto <D.117351>;
  <D.117350>:
  D.117352 = base->after_emit;
  if (D.117352 != 0B) goto <D.117353>; else goto <D.117354>;
  <D.117353>:
  D.117352 = base->after_emit;
  D.117352 (self, platform_data);
  goto <D.117355>;
  <D.117354>:
  <D.117355>:
  <D.117351>:
}


static void Gio::Application_Class::quit_mainloop_vfunc_callback(GApplication*) (struct GApplication * self)
{
  bool retval.143;
  bool iftmp.144;
  bool D.117369;
  struct CppObjectType * const iftmp.145;
  int (*__vtbl_ptr_type) () * D.117379;
  int (*__vtbl_ptr_type) () * D.117380;
  int (*__vtbl_ptr_type) () D.117381;
  void * D.117382;
  struct GTypeClass * D.117385;
  void (*<Tf930>) (struct GApplication *) D.117388;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117368>; else goto <D.117366>;
    <D.117368>:
    D.117369 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117369 != 0) goto <D.117370>; else goto <D.117366>;
    <D.117370>:
    iftmp.144 = 1;
    goto <D.117367>;
    <D.117366>:
    iftmp.144 = 0;
    <D.117367>:
    retval.143 = iftmp.144;
    if (retval.143 != 0) goto <D.117371>; else goto <D.117372>;
    <D.117371>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117374>; else goto <D.117375>;
      <D.117374>:
      iftmp.145 = 0B;
      goto <D.117376>;
      <D.117375>:
      iftmp.145 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117376>:
      obj = iftmp.145;
      if (obj != 0B) goto <D.117377>; else goto <D.117378>;
      <D.117377>:
      try
        {
          D.117379 = obj->D.106831._vptr.Object;
          D.117380 = D.117379 + 48;
          D.117381 = *D.117380;
          OBJ_TYPE_REF(D.117381;(struct Application)obj->6) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117382 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117382);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117383>;
      <D.117378>:
      <D.117383>:
    }
    goto <D.117384>;
    <D.117372>:
    <D.117384>:
  }
  D.117385 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117385);
  if (base != 0B) goto <D.117386>; else goto <D.117387>;
  <D.117386>:
  D.117388 = base->quit_mainloop;
  if (D.117388 != 0B) goto <D.117389>; else goto <D.117390>;
  <D.117389>:
  D.117388 = base->quit_mainloop;
  D.117388 (self);
  goto <D.117391>;
  <D.117390>:
  <D.117391>:
  <D.117387>:
}


static void Gio::Application_Class::run_mainloop_vfunc_callback(GApplication*) (struct GApplication * self)
{
  bool retval.146;
  bool iftmp.147;
  bool D.117404;
  struct CppObjectType * const iftmp.148;
  int (*__vtbl_ptr_type) () * D.117414;
  int (*__vtbl_ptr_type) () * D.117415;
  int (*__vtbl_ptr_type) () D.117416;
  void * D.117417;
  struct GTypeClass * D.117420;
  void (*<Tf930>) (struct GApplication *) D.117423;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117403>; else goto <D.117401>;
    <D.117403>:
    D.117404 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117404 != 0) goto <D.117405>; else goto <D.117401>;
    <D.117405>:
    iftmp.147 = 1;
    goto <D.117402>;
    <D.117401>:
    iftmp.147 = 0;
    <D.117402>:
    retval.146 = iftmp.147;
    if (retval.146 != 0) goto <D.117406>; else goto <D.117407>;
    <D.117406>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117409>; else goto <D.117410>;
      <D.117409>:
      iftmp.148 = 0B;
      goto <D.117411>;
      <D.117410>:
      iftmp.148 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117411>:
      obj = iftmp.148;
      if (obj != 0B) goto <D.117412>; else goto <D.117413>;
      <D.117412>:
      try
        {
          D.117414 = obj->D.106831._vptr.Object;
          D.117415 = D.117414 + 56;
          D.117416 = *D.117415;
          OBJ_TYPE_REF(D.117416;(struct Application)obj->7) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117417 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117417);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117418>;
      <D.117413>:
      <D.117418>:
    }
    goto <D.117419>;
    <D.117407>:
    <D.117419>:
  }
  D.117420 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117420);
  if (base != 0B) goto <D.117421>; else goto <D.117422>;
  <D.117421>:
  D.117423 = base->run_mainloop;
  if (D.117423 != 0B) goto <D.117424>; else goto <D.117425>;
  <D.117424>:
  D.117423 = base->run_mainloop;
  D.117423 (self);
  goto <D.117426>;
  <D.117425>:
  <D.117426>:
  <D.117422>:
}


static void Gio::Application_Class::startup_callback(GApplication*) (struct GApplication * self)
{
  bool retval.149;
  bool iftmp.150;
  bool D.117439;
  struct CppObjectType * const iftmp.151;
  int (*__vtbl_ptr_type) () * D.117449;
  int (*__vtbl_ptr_type) () * D.117450;
  int (*__vtbl_ptr_type) () D.117451;
  void * D.117452;
  struct GTypeClass * D.117455;
  void (*<Tf930>) (struct GApplication *) D.117458;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117438>; else goto <D.117436>;
    <D.117438>:
    D.117439 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117439 != 0) goto <D.117440>; else goto <D.117436>;
    <D.117440>:
    iftmp.150 = 1;
    goto <D.117437>;
    <D.117436>:
    iftmp.150 = 0;
    <D.117437>:
    retval.149 = iftmp.150;
    if (retval.149 != 0) goto <D.117441>; else goto <D.117442>;
    <D.117441>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117444>; else goto <D.117445>;
      <D.117444>:
      iftmp.151 = 0B;
      goto <D.117446>;
      <D.117445>:
      iftmp.151 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117446>:
      obj = iftmp.151;
      if (obj != 0B) goto <D.117447>; else goto <D.117448>;
      <D.117447>:
      try
        {
          D.117449 = obj->D.106831._vptr.Object;
          D.117450 = D.117449 + 64;
          D.117451 = *D.117450;
          OBJ_TYPE_REF(D.117451;(struct Application)obj->8) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117452 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117452);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117453>;
      <D.117448>:
      <D.117453>:
    }
    goto <D.117454>;
    <D.117442>:
    <D.117454>:
  }
  D.117455 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117455);
  if (base != 0B) goto <D.117456>; else goto <D.117457>;
  <D.117456>:
  D.117458 = base->startup;
  if (D.117458 != 0B) goto <D.117459>; else goto <D.117460>;
  <D.117459>:
  D.117458 = base->startup;
  D.117458 (self);
  goto <D.117461>;
  <D.117460>:
  <D.117461>:
  <D.117457>:
}


static void Gio::Application_Class::activate_callback(GApplication*) (struct GApplication * self)
{
  bool retval.152;
  bool iftmp.153;
  bool D.117474;
  struct CppObjectType * const iftmp.154;
  int (*__vtbl_ptr_type) () * D.117484;
  int (*__vtbl_ptr_type) () * D.117485;
  int (*__vtbl_ptr_type) () D.117486;
  void * D.117487;
  struct GTypeClass * D.117490;
  void (*<Tf930>) (struct GApplication *) D.117493;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117473>; else goto <D.117471>;
    <D.117473>:
    D.117474 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117474 != 0) goto <D.117475>; else goto <D.117471>;
    <D.117475>:
    iftmp.153 = 1;
    goto <D.117472>;
    <D.117471>:
    iftmp.153 = 0;
    <D.117472>:
    retval.152 = iftmp.153;
    if (retval.152 != 0) goto <D.117476>; else goto <D.117477>;
    <D.117476>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117479>; else goto <D.117480>;
      <D.117479>:
      iftmp.154 = 0B;
      goto <D.117481>;
      <D.117480>:
      iftmp.154 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117481>:
      obj = iftmp.154;
      if (obj != 0B) goto <D.117482>; else goto <D.117483>;
      <D.117482>:
      try
        {
          D.117484 = obj->D.106831._vptr.Object;
          D.117485 = D.117484 + 72;
          D.117486 = *D.117485;
          OBJ_TYPE_REF(D.117486;(struct Application)obj->9) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117487 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117487);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117488>;
      <D.117483>:
      <D.117488>:
    }
    goto <D.117489>;
    <D.117477>:
    <D.117489>:
  }
  D.117490 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117490);
  if (base != 0B) goto <D.117491>; else goto <D.117492>;
  <D.117491>:
  D.117493 = base->activate;
  if (D.117493 != 0B) goto <D.117494>; else goto <D.117495>;
  <D.117494>:
  D.117493 = base->activate;
  D.117493 (self);
  goto <D.117496>;
  <D.117495>:
  <D.117496>:
  <D.117492>:
}


static gint Gio::Application_Class::command_line_callback(GApplication*, GApplicationCommandLine*) (struct GApplication * self, struct GApplicationCommandLine * p0)
{
  bool retval.155;
  bool iftmp.156;
  bool D.117509;
  struct CppObjectType * const iftmp.157;
  gint D.117519;
  int (*__vtbl_ptr_type) () * D.117520;
  int (*__vtbl_ptr_type) () * D.117521;
  int (*__vtbl_ptr_type) () D.117522;
  struct RefPtr D.111992;
  void * D.117523;
  struct GTypeClass * D.117526;
  int (*<Tf940>) (struct GApplication *, struct GApplicationCommandLine *) D.117529;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.117508>; else goto <D.117506>;
    <D.117508>:
    D.117509 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.117509 != 0) goto <D.117510>; else goto <D.117506>;
    <D.117510>:
    iftmp.156 = 1;
    goto <D.117507>;
    <D.117506>:
    iftmp.156 = 0;
    <D.117507>:
    retval.155 = iftmp.156;
    if (retval.155 != 0) goto <D.117511>; else goto <D.117512>;
    <D.117511>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.117514>; else goto <D.117515>;
      <D.117514>:
      iftmp.157 = 0B;
      goto <D.117516>;
      <D.117515>:
      iftmp.157 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
      <D.117516>:
      obj = iftmp.157;
      if (obj != 0B) goto <D.117517>; else goto <D.117518>;
      <D.117517>:
      try
        {
          D.117520 = obj->D.106831._vptr.Object;
          D.117521 = D.117520 + 80;
          D.117522 = *D.117521;
          D.111992 = Glib::wrap (p0, 1); [return slot optimization]
          try
            {
              D.117519 = OBJ_TYPE_REF(D.117522;(struct Application)obj->10) (obj, &D.111992);
              return D.117519;
            }
          finally
            {
              Glib::RefPtr<Gio::ApplicationCommandLine>::~RefPtr (&D.111992);
              D.111992 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.117523 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.117523);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.117524>;
      <D.117518>:
      <D.117524>:
    }
    goto <D.117525>;
    <D.117512>:
    <D.117525>:
  }
  D.117526 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.117526);
  if (base != 0B) goto <D.117527>; else goto <D.117528>;
  <D.117527>:
  D.117529 = base->command_line;
  if (D.117529 != 0B) goto <D.117530>; else goto <D.117531>;
  <D.117530>:
  D.117529 = base->command_line;
  D.117519 = D.117529 (self, p0);
  return D.117519;
  <D.117531>:
  <D.117528>:
  D.117519 = 0;
  return D.117519;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::ApplicationCommandLine] (struct RefPtr * const this)
{
  struct ApplicationCommandLine * D.117543;
  int (*__vtbl_ptr_type) () * D.117546;
  int (*__vtbl_ptr_type) () * D.117547;
  long int D.117548;
  sizetype D.117549;
  struct ObjectBase * D.117550;
  int (*__vtbl_ptr_type) () * D.117551;
  int (*__vtbl_ptr_type) () * D.117552;
  int (*__vtbl_ptr_type) () D.117553;

  {
    try
      {
        D.117543 = this->pCppObject_;
        if (D.117543 != 0B) goto <D.117544>; else goto <D.117545>;
        <D.117544>:
        D.117543 = this->pCppObject_;
        D.117543 = this->pCppObject_;
        D.117546 = D.117543->D.103022._vptr.Object;
        D.117547 = D.117546 + 18446744073709551592;
        D.117548 = MEM[(long int *)D.117547];
        D.117549 = (sizetype) D.117548;
        D.117550 = D.117543 + D.117549;
        D.117543 = this->pCppObject_;
        D.117543 = this->pCppObject_;
        D.117546 = D.117543->D.103022._vptr.Object;
        D.117547 = D.117546 + 18446744073709551592;
        D.117548 = MEM[(long int *)D.117547];
        D.117549 = (sizetype) D.117548;
        D.117550 = D.117543 + D.117549;
        D.117551 = D.117550->_vptr.ObjectBase;
        D.117552 = D.117551 + 24;
        D.117553 = *D.117552;
        D.117543 = this->pCppObject_;
        D.117543 = this->pCppObject_;
        D.117546 = D.117543->D.103022._vptr.Object;
        D.117547 = D.117546 + 18446744073709551592;
        D.117548 = MEM[(long int *)D.117547];
        D.117549 = (sizetype) D.117548;
        D.117550 = D.117543 + D.117549;
        OBJ_TYPE_REF(D.117553;(const struct ObjectBase)D.117550->3) (D.117550);
        goto <D.117554>;
        <D.117545>:
        <D.117554>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114113>:
}


static Glib::ObjectBase* Gio::Application_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.117556;
  struct ObjectBase * iftmp.158;
  void * D.111999;
  void * D.117558;
  int (*__vtbl_ptr_type) () * D.117561;
  int (*__vtbl_ptr_type) () * D.117562;
  long int D.117563;
  sizetype D.117564;

  D.111999 = operator new (64);
  try
    {
      Gio::Application::Application (D.111999, object);
    }
  catch
    {
      operator delete (D.111999);
    }
  D.117558 = D.111999;
  if (D.117558 != 0B) goto <D.117559>; else goto <D.117560>;
  <D.117559>:
  D.117561 = MEM[(struct Application *)D.117558].D.106831._vptr.Object;
  D.117562 = D.117561 + 18446744073709551592;
  D.117563 = MEM[(long int *)D.117562];
  D.117564 = (sizetype) D.117563;
  iftmp.158 = D.117558 + D.117564;
  goto <D.117565>;
  <D.117560>:
  iftmp.158 = 0B;
  <D.117565>:
  D.117556 = iftmp.158;
  return D.117556;
}


GApplication* Gio::Application::gobj_copy() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.117569;
  int (*__vtbl_ptr_type) () * D.117570;
  long int D.117571;
  sizetype D.117572;
  struct ObjectBase * D.117573;
  int (*__vtbl_ptr_type) () * D.117574;
  int (*__vtbl_ptr_type) () * D.117575;
  int (*__vtbl_ptr_type) () D.117576;
  struct GApplication * D.117577;

  D.117569 = this->D.106831._vptr.Object;
  D.117570 = D.117569 + 18446744073709551592;
  D.117571 = MEM[(long int *)D.117570];
  D.117572 = (sizetype) D.117571;
  D.117573 = this + D.117572;
  D.117569 = this->D.106831._vptr.Object;
  D.117570 = D.117569 + 18446744073709551592;
  D.117571 = MEM[(long int *)D.117570];
  D.117572 = (sizetype) D.117571;
  D.117573 = this + D.117572;
  D.117574 = D.117573->_vptr.ObjectBase;
  D.117575 = D.117574 + 16;
  D.117576 = *D.117575;
  D.117569 = this->D.106831._vptr.Object;
  D.117570 = D.117569 + 18446744073709551592;
  D.117571 = MEM[(long int *)D.117570];
  D.117572 = (sizetype) D.117571;
  D.117573 = this + D.117572;
  OBJ_TYPE_REF(D.117576;(const struct ObjectBase)D.117573->2) (D.117573);
  D.117577 = Gio::Application::gobj (this);
  return D.117577;
}


Gio::Application::Application(const Glib::ConstructParams&) (struct Application * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.117581;
  const void * * iftmp.159;
  struct ObjectBase * D.117589;
  const void * * iftmp.160;
  struct Object * D.117595;
  const void * * iftmp.161;
  struct ActionGroup * D.117600;
  const void * * iftmp.162;
  struct ActionMap * D.117605;
  int (*__vtbl_ptr_type) () * iftmp.163;
  sizetype iftmp.164;
  int (*__vtbl_ptr_type) () * D.117613;
  int (*__vtbl_ptr_type) () * D.117614;
  long int D.117615;
  struct ObjectBase * D.117617;
  int (*__vtbl_ptr_type) () * iftmp.165;
  int (*__vtbl_ptr_type) () * iftmp.166;
  int (*__vtbl_ptr_type) () * iftmp.167;
  const void * * iftmp.168;
  const void * * iftmp.169;
  const void * * iftmp.170;
  const void * * iftmp.171;

  if (0 != 0) goto <D.117579>; else goto <D.117580>;
  <D.117579>:
  D.117581 = &this->D.106838;
  sigc::trackable::trackable (D.117581);
  goto <D.117582>;
  <D.117580>:
  <D.117582>:
  try
    {
      if (0 != 0) goto <D.117583>; else goto <D.117584>;
      <D.117583>:
      if (0 == 0) goto <D.117586>; else goto <D.117587>;
      <D.117586>:
      iftmp.159 = __vtt_parm + 112;
      goto <D.117588>;
      <D.117587>:
      iftmp.159 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.117588>:
      D.117589 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.117589, iftmp.159);
      goto <D.117590>;
      <D.117584>:
      <D.117590>:
      try
        {
          if (0 == 0) goto <D.117592>; else goto <D.117593>;
          <D.117592>:
          iftmp.160 = __vtt_parm + 8;
          goto <D.117594>;
          <D.117593>:
          iftmp.160 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
          <D.117594>:
          D.117595 = &this->D.106831;
          Glib::Object::Object (D.117595, iftmp.160, construct_params);
          try
            {
              if (0 == 0) goto <D.117597>; else goto <D.117598>;
              <D.117597>:
              iftmp.161 = __vtt_parm + 24;
              goto <D.117599>;
              <D.117598>:
              iftmp.161 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.117599>:
              D.117600 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.117600, iftmp.161);
              try
                {
                  if (0 == 0) goto <D.117602>; else goto <D.117603>;
                  <D.117602>:
                  iftmp.162 = __vtt_parm + 56;
                  goto <D.117604>;
                  <D.117603>:
                  iftmp.162 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.117604>:
                  D.117605 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.117605, iftmp.162);
                  try
                    {
                      if (0 == 0) goto <D.117607>; else goto <D.117608>;
                      <D.117607>:
                      iftmp.163 = *__vtt_parm;
                      goto <D.117609>;
                      <D.117608>:
                      iftmp.163 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.117609>:
                      this->D.106831._vptr.Object = iftmp.163;
                      if (0 == 0) goto <D.117611>; else goto <D.117612>;
                      <D.117611>:
                      D.117613 = this->D.106831._vptr.Object;
                      D.117614 = D.117613 + 18446744073709551592;
                      D.117615 = MEM[(long int *)D.117614];
                      iftmp.164 = (sizetype) D.117615;
                      goto <D.117616>;
                      <D.117612>:
                      iftmp.164 = 24;
                      <D.117616>:
                      D.117617 = this + iftmp.164;
                      if (0 == 0) goto <D.117619>; else goto <D.117620>;
                      <D.117619>:
                      iftmp.165 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.117621>;
                      <D.117620>:
                      iftmp.165 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.117621>:
                      D.117617->_vptr.ObjectBase = iftmp.165;
                      if (0 == 0) goto <D.117623>; else goto <D.117624>;
                      <D.117623>:
                      iftmp.166 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.117625>;
                      <D.117624>:
                      iftmp.166 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.117625>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.166;
                      if (0 == 0) goto <D.117627>; else goto <D.117628>;
                      <D.117627>:
                      iftmp.167 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.117629>;
                      <D.117628>:
                      iftmp.167 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.117629>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.167;
                    }
                  catch
                    {
                      if (0 == 0) goto <D.117631>; else goto <D.117632>;
                      <D.117631>:
                      iftmp.168 = __vtt_parm + 56;
                      goto <D.117633>;
                      <D.117632>:
                      iftmp.168 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.117633>:
                      D.117605 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.117605, iftmp.168);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.117635>; else goto <D.117636>;
                  <D.117635>:
                  iftmp.169 = __vtt_parm + 24;
                  goto <D.117637>;
                  <D.117636>:
                  iftmp.169 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.117637>:
                  D.117600 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.117600, iftmp.169);
                }
            }
          catch
            {
              if (0 == 0) goto <D.117639>; else goto <D.117640>;
              <D.117639>:
              iftmp.170 = __vtt_parm + 8;
              goto <D.117641>;
              <D.117640>:
              iftmp.170 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.117641>:
              D.117595 = &this->D.106831;
              Glib::Object::~Object (D.117595, iftmp.170);
            }
        }
      catch
        {
          if (0 != 0) goto <D.117642>; else goto <D.117643>;
          <D.117642>:
          if (0 == 0) goto <D.117645>; else goto <D.117646>;
          <D.117645>:
          iftmp.171 = __vtt_parm + 112;
          goto <D.117647>;
          <D.117646>:
          iftmp.171 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.117647>:
          D.117589 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.117589, iftmp.171);
          goto <D.117648>;
          <D.117643>:
          <D.117648>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.117649>; else goto <D.117650>;
      <D.117649>:
      D.117581 = &this->D.106838;
      sigc::trackable::~trackable (D.117581);
      goto <D.117651>;
      <D.117650>:
      <D.117651>:
    }
}


Gio::Application::Application(const Glib::ConstructParams&) (struct Application * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.117658;
  const void * * iftmp.172;
  struct ObjectBase * D.117666;
  const void * * iftmp.173;
  struct Object * D.117672;
  const void * * iftmp.174;
  struct ActionGroup * D.117677;
  const void * * iftmp.175;
  struct ActionMap * D.117682;
  int (*__vtbl_ptr_type) () * iftmp.176;
  const void * * D.117686;
  sizetype iftmp.177;
  int (*__vtbl_ptr_type) () * D.117691;
  int (*__vtbl_ptr_type) () * D.117692;
  long int D.117693;
  struct ObjectBase * D.117695;
  int (*__vtbl_ptr_type) () * iftmp.178;
  int (*__vtbl_ptr_type) () * iftmp.179;
  int (*__vtbl_ptr_type) () * iftmp.180;
  const void * * iftmp.181;
  const void * * iftmp.182;
  const void * * iftmp.183;
  const void * * iftmp.184;

  if (1 != 0) goto <D.117656>; else goto <D.117657>;
  <D.117656>:
  D.117658 = &this->D.106838;
  sigc::trackable::trackable (D.117658);
  goto <D.117659>;
  <D.117657>:
  <D.117659>:
  try
    {
      if (1 != 0) goto <D.117660>; else goto <D.117661>;
      <D.117660>:
      if (1 == 0) goto <D.117663>; else goto <D.117664>;
      <D.117663>:
      iftmp.172 = 112B;
      goto <D.117665>;
      <D.117664>:
      iftmp.172 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.117665>:
      D.117666 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.117666, iftmp.172);
      goto <D.117667>;
      <D.117661>:
      <D.117667>:
      try
        {
          if (1 == 0) goto <D.117669>; else goto <D.117670>;
          <D.117669>:
          iftmp.173 = 8B;
          goto <D.117671>;
          <D.117670>:
          iftmp.173 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
          <D.117671>:
          D.117672 = &this->D.106831;
          Glib::Object::Object (D.117672, iftmp.173, construct_params);
          try
            {
              if (1 == 0) goto <D.117674>; else goto <D.117675>;
              <D.117674>:
              iftmp.174 = 24B;
              goto <D.117676>;
              <D.117675>:
              iftmp.174 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.117676>:
              D.117677 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.117677, iftmp.174);
              try
                {
                  if (1 == 0) goto <D.117679>; else goto <D.117680>;
                  <D.117679>:
                  iftmp.175 = 56B;
                  goto <D.117681>;
                  <D.117680>:
                  iftmp.175 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.117681>:
                  D.117682 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.117682, iftmp.175);
                  try
                    {
                      if (1 == 0) goto <D.117684>; else goto <D.117685>;
                      <D.117684>:
                      D.117686 = 0B;
                      iftmp.176 = *D.117686;
                      goto <D.117687>;
                      <D.117685>:
                      iftmp.176 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.117687>:
                      this->D.106831._vptr.Object = iftmp.176;
                      if (1 == 0) goto <D.117689>; else goto <D.117690>;
                      <D.117689>:
                      D.117691 = this->D.106831._vptr.Object;
                      D.117692 = D.117691 + 18446744073709551592;
                      D.117693 = MEM[(long int *)D.117692];
                      iftmp.177 = (sizetype) D.117693;
                      goto <D.117694>;
                      <D.117690>:
                      iftmp.177 = 24;
                      <D.117694>:
                      D.117695 = this + iftmp.177;
                      if (1 == 0) goto <D.117697>; else goto <D.117698>;
                      <D.117697>:
                      iftmp.178 = MEM[(const void * *)0B + 88B];
                      goto <D.117699>;
                      <D.117698>:
                      iftmp.178 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.117699>:
                      D.117695->_vptr.ObjectBase = iftmp.178;
                      if (1 == 0) goto <D.117701>; else goto <D.117702>;
                      <D.117701>:
                      iftmp.179 = MEM[(const void * *)0B + 96B];
                      goto <D.117703>;
                      <D.117702>:
                      iftmp.179 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.117703>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.179;
                      if (1 == 0) goto <D.117705>; else goto <D.117706>;
                      <D.117705>:
                      iftmp.180 = MEM[(const void * *)0B + 104B];
                      goto <D.117707>;
                      <D.117706>:
                      iftmp.180 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.117707>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.180;
                    }
                  catch
                    {
                      if (1 == 0) goto <D.117709>; else goto <D.117710>;
                      <D.117709>:
                      iftmp.181 = 56B;
                      goto <D.117711>;
                      <D.117710>:
                      iftmp.181 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.117711>:
                      D.117682 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.117682, iftmp.181);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.117713>; else goto <D.117714>;
                  <D.117713>:
                  iftmp.182 = 24B;
                  goto <D.117715>;
                  <D.117714>:
                  iftmp.182 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.117715>:
                  D.117677 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.117677, iftmp.182);
                }
            }
          catch
            {
              if (1 == 0) goto <D.117717>; else goto <D.117718>;
              <D.117717>:
              iftmp.183 = 8B;
              goto <D.117719>;
              <D.117718>:
              iftmp.183 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.117719>:
              D.117672 = &this->D.106831;
              Glib::Object::~Object (D.117672, iftmp.183);
            }
        }
      catch
        {
          if (1 != 0) goto <D.117720>; else goto <D.117721>;
          <D.117720>:
          if (1 == 0) goto <D.117723>; else goto <D.117724>;
          <D.117723>:
          iftmp.184 = 112B;
          goto <D.117725>;
          <D.117724>:
          iftmp.184 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.117725>:
          D.117666 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.117666, iftmp.184);
          goto <D.117726>;
          <D.117721>:
          <D.117726>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.117727>; else goto <D.117728>;
      <D.117727>:
      D.117658 = &this->D.106838;
      sigc::trackable::~trackable (D.117658);
      goto <D.117729>;
      <D.117728>:
      <D.117729>:
    }
}


Gio::Application::Application(GApplication*) (struct Application * const this, const void * * __vtt_parm, struct GApplication * castitem)
{
  struct trackable * D.117736;
  const void * * iftmp.185;
  struct ObjectBase * D.117744;
  const void * * iftmp.186;
  struct Object * D.117750;
  const void * * iftmp.187;
  struct ActionGroup * D.117755;
  const void * * iftmp.188;
  struct ActionMap * D.117760;
  int (*__vtbl_ptr_type) () * iftmp.189;
  sizetype iftmp.190;
  int (*__vtbl_ptr_type) () * D.117768;
  int (*__vtbl_ptr_type) () * D.117769;
  long int D.117770;
  struct ObjectBase * D.117772;
  int (*__vtbl_ptr_type) () * iftmp.191;
  int (*__vtbl_ptr_type) () * iftmp.192;
  int (*__vtbl_ptr_type) () * iftmp.193;
  const void * * iftmp.194;
  const void * * iftmp.195;
  const void * * iftmp.196;
  const void * * iftmp.197;

  if (0 != 0) goto <D.117734>; else goto <D.117735>;
  <D.117734>:
  D.117736 = &this->D.106838;
  sigc::trackable::trackable (D.117736);
  goto <D.117737>;
  <D.117735>:
  <D.117737>:
  try
    {
      if (0 != 0) goto <D.117738>; else goto <D.117739>;
      <D.117738>:
      if (0 == 0) goto <D.117741>; else goto <D.117742>;
      <D.117741>:
      iftmp.185 = __vtt_parm + 112;
      goto <D.117743>;
      <D.117742>:
      iftmp.185 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.117743>:
      D.117744 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.117744, iftmp.185);
      goto <D.117745>;
      <D.117739>:
      <D.117745>:
      try
        {
          if (0 == 0) goto <D.117747>; else goto <D.117748>;
          <D.117747>:
          iftmp.186 = __vtt_parm + 8;
          goto <D.117749>;
          <D.117748>:
          iftmp.186 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
          <D.117749>:
          D.117750 = &this->D.106831;
          Glib::Object::Object (D.117750, iftmp.186, castitem);
          try
            {
              if (0 == 0) goto <D.117752>; else goto <D.117753>;
              <D.117752>:
              iftmp.187 = __vtt_parm + 24;
              goto <D.117754>;
              <D.117753>:
              iftmp.187 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.117754>:
              D.117755 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.117755, iftmp.187);
              try
                {
                  if (0 == 0) goto <D.117757>; else goto <D.117758>;
                  <D.117757>:
                  iftmp.188 = __vtt_parm + 56;
                  goto <D.117759>;
                  <D.117758>:
                  iftmp.188 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.117759>:
                  D.117760 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.117760, iftmp.188);
                  try
                    {
                      if (0 == 0) goto <D.117762>; else goto <D.117763>;
                      <D.117762>:
                      iftmp.189 = *__vtt_parm;
                      goto <D.117764>;
                      <D.117763>:
                      iftmp.189 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.117764>:
                      this->D.106831._vptr.Object = iftmp.189;
                      if (0 == 0) goto <D.117766>; else goto <D.117767>;
                      <D.117766>:
                      D.117768 = this->D.106831._vptr.Object;
                      D.117769 = D.117768 + 18446744073709551592;
                      D.117770 = MEM[(long int *)D.117769];
                      iftmp.190 = (sizetype) D.117770;
                      goto <D.117771>;
                      <D.117767>:
                      iftmp.190 = 24;
                      <D.117771>:
                      D.117772 = this + iftmp.190;
                      if (0 == 0) goto <D.117774>; else goto <D.117775>;
                      <D.117774>:
                      iftmp.191 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.117776>;
                      <D.117775>:
                      iftmp.191 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.117776>:
                      D.117772->_vptr.ObjectBase = iftmp.191;
                      if (0 == 0) goto <D.117778>; else goto <D.117779>;
                      <D.117778>:
                      iftmp.192 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.117780>;
                      <D.117779>:
                      iftmp.192 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.117780>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.192;
                      if (0 == 0) goto <D.117782>; else goto <D.117783>;
                      <D.117782>:
                      iftmp.193 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.117784>;
                      <D.117783>:
                      iftmp.193 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.117784>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.193;
                    }
                  catch
                    {
                      if (0 == 0) goto <D.117786>; else goto <D.117787>;
                      <D.117786>:
                      iftmp.194 = __vtt_parm + 56;
                      goto <D.117788>;
                      <D.117787>:
                      iftmp.194 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.117788>:
                      D.117760 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.117760, iftmp.194);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.117790>; else goto <D.117791>;
                  <D.117790>:
                  iftmp.195 = __vtt_parm + 24;
                  goto <D.117792>;
                  <D.117791>:
                  iftmp.195 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.117792>:
                  D.117755 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.117755, iftmp.195);
                }
            }
          catch
            {
              if (0 == 0) goto <D.117794>; else goto <D.117795>;
              <D.117794>:
              iftmp.196 = __vtt_parm + 8;
              goto <D.117796>;
              <D.117795>:
              iftmp.196 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.117796>:
              D.117750 = &this->D.106831;
              Glib::Object::~Object (D.117750, iftmp.196);
            }
        }
      catch
        {
          if (0 != 0) goto <D.117797>; else goto <D.117798>;
          <D.117797>:
          if (0 == 0) goto <D.117800>; else goto <D.117801>;
          <D.117800>:
          iftmp.197 = __vtt_parm + 112;
          goto <D.117802>;
          <D.117801>:
          iftmp.197 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.117802>:
          D.117744 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.117744, iftmp.197);
          goto <D.117803>;
          <D.117798>:
          <D.117803>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.117804>; else goto <D.117805>;
      <D.117804>:
      D.117736 = &this->D.106838;
      sigc::trackable::~trackable (D.117736);
      goto <D.117806>;
      <D.117805>:
      <D.117806>:
    }
}


Gio::Application::Application(GApplication*) (struct Application * const this, struct GApplication * castitem)
{
  struct trackable * D.117813;
  const void * * iftmp.198;
  struct ObjectBase * D.117821;
  const void * * iftmp.199;
  struct Object * D.117827;
  const void * * iftmp.200;
  struct ActionGroup * D.117832;
  const void * * iftmp.201;
  struct ActionMap * D.117837;
  int (*__vtbl_ptr_type) () * iftmp.202;
  const void * * D.117841;
  sizetype iftmp.203;
  int (*__vtbl_ptr_type) () * D.117846;
  int (*__vtbl_ptr_type) () * D.117847;
  long int D.117848;
  struct ObjectBase * D.117850;
  int (*__vtbl_ptr_type) () * iftmp.204;
  int (*__vtbl_ptr_type) () * iftmp.205;
  int (*__vtbl_ptr_type) () * iftmp.206;
  const void * * iftmp.207;
  const void * * iftmp.208;
  const void * * iftmp.209;
  const void * * iftmp.210;

  if (1 != 0) goto <D.117811>; else goto <D.117812>;
  <D.117811>:
  D.117813 = &this->D.106838;
  sigc::trackable::trackable (D.117813);
  goto <D.117814>;
  <D.117812>:
  <D.117814>:
  try
    {
      if (1 != 0) goto <D.117815>; else goto <D.117816>;
      <D.117815>:
      if (1 == 0) goto <D.117818>; else goto <D.117819>;
      <D.117818>:
      iftmp.198 = 112B;
      goto <D.117820>;
      <D.117819>:
      iftmp.198 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
      <D.117820>:
      D.117821 = &this->D.106837;
      Glib::ObjectBase::ObjectBase (D.117821, iftmp.198);
      goto <D.117822>;
      <D.117816>:
      <D.117822>:
      try
        {
          if (1 == 0) goto <D.117824>; else goto <D.117825>;
          <D.117824>:
          iftmp.199 = 8B;
          goto <D.117826>;
          <D.117825>:
          iftmp.199 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
          <D.117826>:
          D.117827 = &this->D.106831;
          Glib::Object::Object (D.117827, iftmp.199, castitem);
          try
            {
              if (1 == 0) goto <D.117829>; else goto <D.117830>;
              <D.117829>:
              iftmp.200 = 24B;
              goto <D.117831>;
              <D.117830>:
              iftmp.200 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
              <D.117831>:
              D.117832 = &this->D.106832;
              Gio::ActionGroup::ActionGroup (D.117832, iftmp.200);
              try
                {
                  if (1 == 0) goto <D.117834>; else goto <D.117835>;
                  <D.117834>:
                  iftmp.201 = 56B;
                  goto <D.117836>;
                  <D.117835>:
                  iftmp.201 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                  <D.117836>:
                  D.117837 = &this->D.106833;
                  Gio::ActionMap::ActionMap (D.117837, iftmp.201);
                  try
                    {
                      if (1 == 0) goto <D.117839>; else goto <D.117840>;
                      <D.117839>:
                      D.117841 = 0B;
                      iftmp.202 = *D.117841;
                      goto <D.117842>;
                      <D.117840>:
                      iftmp.202 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 32B];
                      <D.117842>:
                      this->D.106831._vptr.Object = iftmp.202;
                      if (1 == 0) goto <D.117844>; else goto <D.117845>;
                      <D.117844>:
                      D.117846 = this->D.106831._vptr.Object;
                      D.117847 = D.117846 + 18446744073709551592;
                      D.117848 = MEM[(long int *)D.117847];
                      iftmp.203 = (sizetype) D.117848;
                      goto <D.117849>;
                      <D.117845>:
                      iftmp.203 = 24;
                      <D.117849>:
                      D.117850 = this + iftmp.203;
                      if (1 == 0) goto <D.117852>; else goto <D.117853>;
                      <D.117852>:
                      iftmp.204 = MEM[(const void * *)0B + 88B];
                      goto <D.117854>;
                      <D.117853>:
                      iftmp.204 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 408B];
                      <D.117854>:
                      D.117850->_vptr.ObjectBase = iftmp.204;
                      if (1 == 0) goto <D.117856>; else goto <D.117857>;
                      <D.117856>:
                      iftmp.205 = MEM[(const void * *)0B + 96B];
                      goto <D.117858>;
                      <D.117857>:
                      iftmp.205 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 152B];
                      <D.117858>:
                      this->D.106832.D.96606._vptr.Interface = iftmp.205;
                      if (1 == 0) goto <D.117860>; else goto <D.117861>;
                      <D.117860>:
                      iftmp.206 = MEM[(const void * *)0B + 104B];
                      goto <D.117862>;
                      <D.117861>:
                      iftmp.206 = &MEM[(void *)&_ZTVN3Gio11ApplicationE + 304B];
                      <D.117862>:
                      this->D.106833.D.97343._vptr.Interface = iftmp.206;
                    }
                  catch
                    {
                      if (1 == 0) goto <D.117864>; else goto <D.117865>;
                      <D.117864>:
                      iftmp.207 = 56B;
                      goto <D.117866>;
                      <D.117865>:
                      iftmp.207 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 56B];
                      <D.117866>:
                      D.117837 = &this->D.106833;
                      Gio::ActionMap::~ActionMap (D.117837, iftmp.207);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.117868>; else goto <D.117869>;
                  <D.117868>:
                  iftmp.208 = 24B;
                  goto <D.117870>;
                  <D.117869>:
                  iftmp.208 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 24B];
                  <D.117870>:
                  D.117832 = &this->D.106832;
                  Gio::ActionGroup::~ActionGroup (D.117832, iftmp.208);
                }
            }
          catch
            {
              if (1 == 0) goto <D.117872>; else goto <D.117873>;
              <D.117872>:
              iftmp.209 = 8B;
              goto <D.117874>;
              <D.117873>:
              iftmp.209 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 8B];
              <D.117874>:
              D.117827 = &this->D.106831;
              Glib::Object::~Object (D.117827, iftmp.209);
            }
        }
      catch
        {
          if (1 != 0) goto <D.117875>; else goto <D.117876>;
          <D.117875>:
          if (1 == 0) goto <D.117878>; else goto <D.117879>;
          <D.117878>:
          iftmp.210 = 112B;
          goto <D.117880>;
          <D.117879>:
          iftmp.210 = &MEM[(void *)&_ZTTN3Gio11ApplicationE + 112B];
          <D.117880>:
          D.117821 = &this->D.106837;
          Glib::ObjectBase::~ObjectBase (D.117821, iftmp.210);
          goto <D.117881>;
          <D.117876>:
          <D.117881>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.117882>; else goto <D.117883>;
      <D.117882>:
      D.117813 = &this->D.106838;
      sigc::trackable::~trackable (D.117813);
      goto <D.117884>;
      <D.117883>:
      <D.117884>:
    }
}


static GType Gio::Application::get_type() ()
{
  GType D.117889;
  const struct Class & D.117890;

  D.117890 = Gio::Application_Class::init (&application_class_);
  D.117889 = Glib::Class::get_type (D.117890);
  return D.117889;
}


static GType Gio::Application::get_base_type() ()
{
  GType D.117893;

  D.117893 = g_application_get_type ();
  return D.117893;
}


static Glib::RefPtr<Gio::Application> Gio::Application::create(const Glib::ustring&, Gio::ApplicationFlags) (const struct ustring & application_id, ApplicationFlags flags)
{
  void * D.112031;

  D.112031 = operator new (64);
  try
    {
      Gio::Application::Application (D.112031, application_id, flags);
    }
  catch
    {
      operator delete (D.112031);
    }
  Glib::RefPtr<Gio::Application>::RefPtr (<retval>, D.112031);
  return <retval>;
}


static bool Gio::Application::id_is_valid(const Glib::ustring&) (const struct ustring & application_id)
{
  bool D.117900;
  const char * D.117901;
  int D.117902;

  D.117901 = Glib::ustring::c_str (application_id);
  D.117902 = g_application_id_is_valid (D.117901);
  D.117900 = D.117902 != 0;
  return D.117900;
}


Glib::ustring Gio::Application::get_id() const (const struct Application * const this)
{
  const struct GApplication * D.117907;
  const gchar * D.117908;

  D.117907 = Gio::Application::gobj (this);
  D.117908 = g_application_get_application_id (D.117907);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.117908); [return slot optimization]
  return <retval>;
}


const GApplication* Gio::Application::gobj() const (const struct Application * const this)
{
  const struct GApplication * D.117911;
  int (*__vtbl_ptr_type) () * D.117912;
  int (*__vtbl_ptr_type) () * D.117913;
  long int D.117914;
  sizetype D.117915;
  const struct ObjectBase * D.117916;

  D.117912 = this->D.106831._vptr.Object;
  D.117913 = D.117912 + 18446744073709551592;
  D.117914 = MEM[(long int *)D.117913];
  D.117915 = (sizetype) D.117914;
  D.117916 = this + D.117915;
  D.117911 = D.117916->gobject_;
  return D.117911;
}


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

  if (str != 0B) goto <D.117919>; else goto <D.117920>;
  <D.117919>:
  D.117921 = <retval>;
  Glib::ustring::ustring (D.117921, str);
  goto <D.117922>;
  <D.117920>:
  D.117921 = <retval>;
  Glib::ustring::ustring (D.117921);
  <D.117922>:
  return <retval>;
}


void Gio::Application::set_id(const Glib::ustring&) (struct Application * const this, const struct ustring & application_id)
{
  const char * D.117924;
  struct GApplication * D.117925;

  D.117924 = Glib::ustring::c_str (application_id);
  D.117925 = Gio::Application::gobj (this);
  g_application_set_application_id (D.117925, D.117924);
}


Glib::RefPtr<Gio::DBus::Connection> Gio::Application::get_dbus_connection() (struct Application * const this)
{
  struct GApplication * D.117928;
  struct GDBusConnection * D.117929;
  bool retval.211;
  struct Connection * D.117933;
  int (*__vtbl_ptr_type) () * D.117934;
  int (*__vtbl_ptr_type) () * D.117935;
  long int D.117936;
  sizetype D.117937;
  struct ObjectBase * D.117938;
  int (*__vtbl_ptr_type) () * D.117939;
  int (*__vtbl_ptr_type) () * D.117940;
  int (*__vtbl_ptr_type) () D.117941;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.117928 = Gio::Application::gobj (this);
  D.117929 = g_application_get_dbus_connection (D.117928);
  *<retval> = Glib::wrap (D.117929, 0); [return slot optimization]
  try
    {
      retval.211 = Glib::RefPtr<Gio::DBus::Connection>::operator bool (<retval>);
      if (retval.211 != 0) goto <D.117931>; else goto <D.117932>;
      <D.117931>:
      D.117933 = Glib::RefPtr<Gio::DBus::Connection>::operator-> (<retval>);
      D.117934 = D.117933->D.106283._vptr.Object;
      D.117935 = D.117934 + 18446744073709551592;
      D.117936 = MEM[(long int *)D.117935];
      D.117937 = (sizetype) D.117936;
      D.117938 = D.117933 + D.117937;
      D.117934 = D.117933->D.106283._vptr.Object;
      D.117935 = D.117934 + 18446744073709551592;
      D.117936 = MEM[(long int *)D.117935];
      D.117937 = (sizetype) D.117936;
      D.117938 = D.117933 + D.117937;
      D.117939 = D.117938->_vptr.ObjectBase;
      D.117940 = D.117939 + 16;
      D.117941 = *D.117940;
      D.117934 = D.117933->D.106283._vptr.Object;
      D.117935 = D.117934 + 18446744073709551592;
      D.117936 = MEM[(long int *)D.117935];
      D.117937 = (sizetype) D.117936;
      D.117938 = D.117933 + D.117937;
      OBJ_TYPE_REF(D.117941;(const struct ObjectBase)D.117938->2) (D.117938);
      goto <D.117942>;
      <D.117932>:
      <D.117942>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::DBus::Connection>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::DBus::Connection] (const struct RefPtr * const this)
{
  bool D.117946;
  struct Connection * D.117947;

  D.117947 = this->pCppObject_;
  D.117946 = D.117947 != 0B;
  return D.117946;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::DBus::Connection] (struct RefPtr * const this)
{
  struct Connection * D.117951;
  int (*__vtbl_ptr_type) () * D.117954;
  int (*__vtbl_ptr_type) () * D.117955;
  long int D.117956;
  sizetype D.117957;
  struct ObjectBase * D.117958;
  int (*__vtbl_ptr_type) () * D.117959;
  int (*__vtbl_ptr_type) () * D.117960;
  int (*__vtbl_ptr_type) () D.117961;

  {
    try
      {
        D.117951 = this->pCppObject_;
        if (D.117951 != 0B) goto <D.117952>; else goto <D.117953>;
        <D.117952>:
        D.117951 = this->pCppObject_;
        D.117951 = this->pCppObject_;
        D.117954 = D.117951->D.106283._vptr.Object;
        D.117955 = D.117954 + 18446744073709551592;
        D.117956 = MEM[(long int *)D.117955];
        D.117957 = (sizetype) D.117956;
        D.117958 = D.117951 + D.117957;
        D.117951 = this->pCppObject_;
        D.117951 = this->pCppObject_;
        D.117954 = D.117951->D.106283._vptr.Object;
        D.117955 = D.117954 + 18446744073709551592;
        D.117956 = MEM[(long int *)D.117955];
        D.117957 = (sizetype) D.117956;
        D.117958 = D.117951 + D.117957;
        D.117959 = D.117958->_vptr.ObjectBase;
        D.117960 = D.117959 + 24;
        D.117961 = *D.117960;
        D.117951 = this->pCppObject_;
        D.117951 = this->pCppObject_;
        D.117954 = D.117951->D.106283._vptr.Object;
        D.117955 = D.117954 + 18446744073709551592;
        D.117956 = MEM[(long int *)D.117955];
        D.117957 = (sizetype) D.117956;
        D.117958 = D.117951 + D.117957;
        OBJ_TYPE_REF(D.117961;(const struct ObjectBase)D.117958->3) (D.117958);
        goto <D.117962>;
        <D.117953>:
        <D.117962>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114144>:
}


Glib::RefPtr<const Gio::DBus::Connection> Gio::Application::get_dbus_connection() const (const struct Application * const this)
{
  struct RefPtr D.112311;

  D.112311 = Gio::Application::get_dbus_connection (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::Connection>::RefPtr<Gio::DBus::Connection> (<retval>, &D.112311);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::Connection>::~RefPtr (&D.112311);
      D.112311 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::DBus::Connection; T_CppObject = const Gio::DBus::Connection] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Connection * D.117968;
  const struct Connection * D.117969;
  int (*__vtbl_ptr_type) () * D.117972;
  int (*__vtbl_ptr_type) () * D.117973;
  long int D.117974;
  sizetype D.117975;
  const struct ObjectBase * D.117976;
  int (*__vtbl_ptr_type) () * D.117977;
  int (*__vtbl_ptr_type) () * D.117978;
  int (*__vtbl_ptr_type) () D.117979;

  D.117968 = Glib::RefPtr<Gio::DBus::Connection>::operator-> (src);
  this->pCppObject_ = D.117968;
  D.117969 = this->pCppObject_;
  if (D.117969 != 0B) goto <D.117970>; else goto <D.117971>;
  <D.117970>:
  D.117969 = this->pCppObject_;
  D.117969 = this->pCppObject_;
  D.117972 = D.117969->D.106283._vptr.Object;
  D.117973 = D.117972 + 18446744073709551592;
  D.117974 = MEM[(long int *)D.117973];
  D.117975 = (sizetype) D.117974;
  D.117976 = D.117969 + D.117975;
  D.117969 = this->pCppObject_;
  D.117969 = this->pCppObject_;
  D.117972 = D.117969->D.106283._vptr.Object;
  D.117973 = D.117972 + 18446744073709551592;
  D.117974 = MEM[(long int *)D.117973];
  D.117975 = (sizetype) D.117974;
  D.117976 = D.117969 + D.117975;
  D.117977 = D.117976->_vptr.ObjectBase;
  D.117978 = D.117977 + 16;
  D.117979 = *D.117978;
  D.117969 = this->pCppObject_;
  D.117969 = this->pCppObject_;
  D.117972 = D.117969->D.106283._vptr.Object;
  D.117973 = D.117972 + 18446744073709551592;
  D.117974 = MEM[(long int *)D.117973];
  D.117975 = (sizetype) D.117974;
  D.117976 = D.117969 + D.117975;
  OBJ_TYPE_REF(D.117979;(const struct ObjectBase)D.117976->2) (D.117976);
  goto <D.117980>;
  <D.117971>:
  <D.117980>:
}


Glib::ustring Gio::Application::get_dbus_object_path() const (const struct Application * const this)
{
  const struct GApplication * D.117982;
  const gchar * D.117983;

  D.117982 = Gio::Application::gobj (this);
  D.117983 = g_application_get_dbus_object_path (D.117982);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.117983); [return slot optimization]
  return <retval>;
}


guint Gio::Application::get_inactivity_timeout() const (const struct Application * const this)
{
  guint D.117986;
  const struct GApplication * D.117987;

  D.117987 = Gio::Application::gobj (this);
  D.117986 = g_application_get_inactivity_timeout (D.117987);
  return D.117986;
}


void Gio::Application::set_inactivity_timeout(guint) (struct Application * const this, guint inactivity_timeout)
{
  struct GApplication * D.117990;

  D.117990 = Gio::Application::gobj (this);
  g_application_set_inactivity_timeout (D.117990, inactivity_timeout);
}


Gio::ApplicationFlags Gio::Application::get_flags() const (const struct Application * const this)
{
  ApplicationFlags D.117991;
  const struct GApplication * D.117992;

  D.117992 = Gio::Application::gobj (this);
  D.117991 = g_application_get_flags (D.117992);
  return D.117991;
}


void Gio::Application::set_flags(Gio::ApplicationFlags) (struct Application * const this, ApplicationFlags flags)
{
  struct GApplication * D.117995;

  D.117995 = Gio::Application::gobj (this);
  g_application_set_flags (D.117995, flags);
}


void Gio::Application::set_action_group(const Glib::RefPtr<Gio::ActionGroup>&) (struct Application * const this, const struct RefPtr & action_group)
{
  struct BaseObjectType * D.117996;
  struct GApplication * D.117997;

  D.117996 = Glib::unwrap<Gio::ActionGroup> (action_group);
  D.117997 = Gio::Application::gobj (this);
  g_application_set_action_group (D.117997, D.117996);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::ActionGroup; typename T::BaseObjectType = _GActionGroup] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.117999;
  struct BaseObjectType * iftmp.212;
  bool D.118001;
  struct ActionGroup * D.118004;

  D.118001 = Glib::RefPtr<Gio::ActionGroup>::operator bool (ptr);
  if (D.118001 != 0) goto <D.118002>; else goto <D.118003>;
  <D.118002>:
  D.118004 = Glib::RefPtr<Gio::ActionGroup>::operator-> (ptr);
  iftmp.212 = Gio::ActionGroup::gobj (D.118004);
  goto <D.118005>;
  <D.118003>:
  iftmp.212 = 0B;
  <D.118005>:
  D.117999 = iftmp.212;
  return D.117999;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::ActionGroup] (const struct RefPtr * const this)
{
  bool D.118007;
  struct ActionGroup * D.118008;

  D.118008 = this->pCppObject_;
  D.118007 = D.118008 != 0B;
  return D.118007;
}


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

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


GActionGroup* Gio::ActionGroup::gobj() (struct ActionGroup * const this)
{
  struct GActionGroup * D.118012;
  int (*__vtbl_ptr_type) () * D.118013;
  int (*__vtbl_ptr_type) () * D.118014;
  long int D.118015;
  sizetype D.118016;
  struct ObjectBase * D.118017;

  D.118013 = this->D.96606._vptr.Interface;
  D.118014 = D.118013 + 18446744073709551592;
  D.118015 = MEM[(long int *)D.118014];
  D.118016 = (sizetype) D.118015;
  D.118017 = this + D.118016;
  D.118012 = D.118017->gobject_;
  return D.118012;
}


bool Gio::Application::is_registered() const (const struct Application * const this)
{
  bool D.118019;
  const struct GApplication * D.118020;
  int D.118021;

  D.118020 = Gio::Application::gobj (this);
  D.118021 = g_application_get_is_registered (D.118020);
  D.118019 = D.118021 != 0;
  return D.118019;
}


bool Gio::Application::is_remote() const (const struct Application * const this)
{
  bool D.118024;
  const struct GApplication * D.118025;
  int D.118026;

  D.118025 = Gio::Application::gobj (this);
  D.118026 = g_application_get_is_remote (D.118025);
  D.118024 = D.118026 != 0;
  return D.118024;
}


bool Gio::Application::register_application(const Glib::RefPtr<Gio::Cancellable>&) (struct Application * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.118029;
  struct GApplication * D.118030;
  int D.118031;
  struct GError * gerror.213;
  bool D.118035;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.118029 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.118030 = Gio::Application::gobj (this);
      D.118031 = g_application_register (D.118030, D.118029, &gerror);
      retvalue = D.118031 != 0;
      gerror.213 = gerror;
      if (gerror.213 != 0B) goto <D.118033>; else goto <D.118034>;
      <D.118033>:
      gerror.213 = gerror;
      Glib::Error::throw_exception (gerror.213);
      <D.118034>:
      D.118035 = retvalue;
      return D.118035;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.118041;
  struct BaseObjectType * iftmp.214;
  bool D.118043;
  struct Cancellable * D.118046;

  D.118043 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.118043 != 0) goto <D.118044>; else goto <D.118045>;
  <D.118044>:
  D.118046 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.214 = Gio::Cancellable::gobj (D.118046);
  goto <D.118047>;
  <D.118045>:
  iftmp.214 = 0B;
  <D.118047>:
  D.118041 = iftmp.214;
  return D.118041;
}


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

  D.118050 = this->pCppObject_;
  D.118049 = D.118050 != 0B;
  return D.118049;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.118054;
  int (*__vtbl_ptr_type) () * D.118055;
  int (*__vtbl_ptr_type) () * D.118056;
  long int D.118057;
  sizetype D.118058;
  struct ObjectBase * D.118059;

  D.118055 = this->D.98318._vptr.Object;
  D.118056 = D.118055 + 18446744073709551592;
  D.118057 = MEM[(long int *)D.118056];
  D.118058 = (sizetype) D.118057;
  D.118059 = this + D.118058;
  D.118054 = D.118059->gobject_;
  return D.118054;
}


bool Gio::Application::register_application() (struct Application * const this)
{
  struct GApplication * D.118061;
  int D.118062;
  struct GError * gerror.215;
  bool D.118066;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.118061 = Gio::Application::gobj (this);
      D.118062 = g_application_register (D.118061, 0B, &gerror);
      retvalue = D.118062 != 0;
      gerror.215 = gerror;
      if (gerror.215 != 0B) goto <D.118064>; else goto <D.118065>;
      <D.118064>:
      gerror.215 = gerror;
      Glib::Error::throw_exception (gerror.215);
      <D.118065>:
      D.118066 = retvalue;
      return D.118066;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::Application::hold() (struct Application * const this)
{
  struct GApplication * D.118071;

  D.118071 = Gio::Application::gobj (this);
  g_application_hold (D.118071);
}


void Gio::Application::release() (struct Application * const this)
{
  struct GApplication * D.118072;

  D.118072 = Gio::Application::gobj (this);
  g_application_release (D.118072);
}


void Gio::Application::activate() (struct Application * const this)
{
  struct GApplication * D.118073;

  D.118073 = Gio::Application::gobj (this);
  g_application_activate (D.118073);
}


int Gio::Application::run(int, char**) (struct Application * const this, int argc, char * * argv)
{
  int D.118074;
  struct GApplication * D.118075;

  D.118075 = Gio::Application::gobj (this);
  D.118074 = g_application_run (D.118075, argc, argv);
  return D.118074;
}


void Gio::Application::quit() (struct Application * const this)
{
  struct GApplication * D.118078;

  D.118078 = Gio::Application::gobj (this);
  g_application_quit (D.118078);
}


static void Gio::Application::set_default(const Glib::RefPtr<Gio::Application>&) (const struct RefPtr & application)
{
  struct BaseObjectType * D.118079;

  D.118079 = Glib::unwrap<Gio::Application> (application);
  g_application_set_default (D.118079);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Application; typename T::BaseObjectType = _GApplication] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.118081;
  struct BaseObjectType * iftmp.216;
  bool D.118083;
  struct Application * D.118086;

  D.118083 = Glib::RefPtr<Gio::Application>::operator bool (ptr);
  if (D.118083 != 0) goto <D.118084>; else goto <D.118085>;
  <D.118084>:
  D.118086 = Glib::RefPtr<Gio::Application>::operator-> (ptr);
  iftmp.216 = Gio::Application::gobj (D.118086);
  goto <D.118087>;
  <D.118085>:
  iftmp.216 = 0B;
  <D.118087>:
  D.118081 = iftmp.216;
  return D.118081;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Application] (const struct RefPtr * const this)
{
  bool D.118089;
  struct Application * D.118090;

  D.118090 = this->pCppObject_;
  D.118089 = D.118090 != 0B;
  return D.118089;
}


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

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


static Glib::RefPtr<Gio::Application> Gio::Application::get_default() ()
{
  struct GApplication * D.118095;

  D.118095 = g_application_get_default ();
  *<retval> = Glib::wrap (D.118095, 0); [return slot optimization]
  return <retval>;
}


void Gio::Application::mark_busy() (struct Application * const this)
{
  struct GApplication * D.118098;

  D.118098 = Gio::Application::gobj (this);
  g_application_mark_busy (D.118098);
}


void Gio::Application::unmark_busy() (struct Application * const this)
{
  struct GApplication * D.118099;

  D.118099 = Gio::Application::gobj (this);
  g_application_unmark_busy (D.118099);
}


void Gio::Application::send_notification(const Glib::ustring&, const Glib::RefPtr<Gio::Notification>&) (struct Application * const this, const struct ustring & id, const struct RefPtr & notification)
{
  struct BaseObjectType * D.118100;
  const char * iftmp.217;
  bool D.118102;
  struct GApplication * D.118106;

  D.118100 = Glib::unwrap<Gio::Notification> (notification);
  D.118102 = Glib::ustring::empty (id);
  if (D.118102 != 0) goto <D.118103>; else goto <D.118104>;
  <D.118103>:
  iftmp.217 = 0B;
  goto <D.118105>;
  <D.118104>:
  iftmp.217 = Glib::ustring::c_str (id);
  <D.118105>:
  D.118106 = Gio::Application::gobj (this);
  g_application_send_notification (D.118106, iftmp.217, D.118100);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Notification; typename T::BaseObjectType = _GNotification] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.118110;
  struct BaseObjectType * iftmp.218;
  bool D.118112;
  struct Notification * D.118115;

  D.118112 = Glib::RefPtr<Gio::Notification>::operator bool (ptr);
  if (D.118112 != 0) goto <D.118113>; else goto <D.118114>;
  <D.118113>:
  D.118115 = Glib::RefPtr<Gio::Notification>::operator-> (ptr);
  iftmp.218 = Gio::Notification::gobj (D.118115);
  goto <D.118116>;
  <D.118114>:
  iftmp.218 = 0B;
  <D.118116>:
  D.118110 = iftmp.218;
  return D.118110;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Notification] (const struct RefPtr * const this)
{
  bool D.118118;
  struct Notification * D.118119;

  D.118119 = this->pCppObject_;
  D.118118 = D.118119 != 0B;
  return D.118118;
}


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

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


GNotification* Gio::Notification::gobj() (struct Notification * const this)
{
  struct GNotification * D.118123;
  int (*__vtbl_ptr_type) () * D.118124;
  int (*__vtbl_ptr_type) () * D.118125;
  long int D.118126;
  sizetype D.118127;
  struct ObjectBase * D.118128;

  D.118124 = this->D.106481._vptr.Object;
  D.118125 = D.118124 + 18446744073709551592;
  D.118126 = MEM[(long int *)D.118125];
  D.118127 = (sizetype) D.118126;
  D.118128 = this + D.118127;
  D.118123 = D.118128->gobject_;
  return D.118123;
}


void Gio::Application::send_notification(const Glib::RefPtr<Gio::Notification>&) (struct Application * const this, const struct RefPtr & notification)
{
  struct BaseObjectType * D.118130;
  struct GApplication * D.118131;

  D.118130 = Glib::unwrap<Gio::Notification> (notification);
  D.118131 = Gio::Application::gobj (this);
  g_application_send_notification (D.118131, 0B, D.118130);
}


void Gio::Application::withdraw_notification(const Glib::ustring&) (struct Application * const this, const struct ustring & id)
{
  const char * D.118133;
  struct GApplication * D.118134;

  D.118133 = Glib::ustring::c_str (id);
  D.118134 = Gio::Application::gobj (this);
  g_application_withdraw_notification (D.118134, D.118133);
}


Glib::SignalProxy0<void> Gio::Application::signal_startup() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118137;
  int (*__vtbl_ptr_type) () * D.118138;
  long int D.118139;
  sizetype D.118140;
  struct ObjectBase * D.118141;

  D.118137 = this->D.106831._vptr.Object;
  D.118138 = D.118137 + 18446744073709551592;
  D.118139 = MEM[(long int *)D.118138];
  D.118140 = (sizetype) D.118139;
  D.118141 = this + D.118140;
  Glib::SignalProxy0<void>::SignalProxy0 (<retval>, D.118141, &Application_signal_startup_info);
  return <retval>;
}


Glib::SignalProxy0<R>::SignalProxy0(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void] (struct SignalProxy0 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.118143;

  D.118143 = &this->D.112819;
  Glib::SignalProxyNormal::SignalProxyNormal (D.118143, obj, info);
  try
    {

    }
  catch
    {
      D.118143 = &this->D.112819;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.118143);
    }
}


Glib::SignalProxy0<void> Gio::Application::signal_activate() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118145;
  int (*__vtbl_ptr_type) () * D.118146;
  long int D.118147;
  sizetype D.118148;
  struct ObjectBase * D.118149;

  D.118145 = this->D.106831._vptr.Object;
  D.118146 = D.118145 + 18446744073709551592;
  D.118147 = MEM[(long int *)D.118146];
  D.118148 = (sizetype) D.118147;
  D.118149 = this + D.118148;
  Glib::SignalProxy0<void>::SignalProxy0 (<retval>, D.118149, &Application_signal_activate_info);
  return <retval>;
}


Glib::SignalProxy1<int, const Glib::RefPtr<Gio::ApplicationCommandLine>&> Gio::Application::signal_command_line() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118152;
  int (*__vtbl_ptr_type) () * D.118153;
  long int D.118154;
  sizetype D.118155;
  struct ObjectBase * D.118156;

  D.118152 = this->D.106831._vptr.Object;
  D.118153 = D.118152 + 18446744073709551592;
  D.118154 = MEM[(long int *)D.118153];
  D.118155 = (sizetype) D.118154;
  D.118156 = this + D.118155;
  Glib::SignalProxy1<int, const Glib::RefPtr<Gio::ApplicationCommandLine>&>::SignalProxy1 (<retval>, D.118156, &Application_signal_command_line_info);
  return <retval>;
}


gint {anonymous}::Application_signal_command_line_notify_callback(GApplication*, GApplicationCommandLine*, void*) (struct GApplication * self, struct GApplicationCommandLine * p0, void * data)
{
  struct Application * iftmp.219;
  struct ObjectBase * D.118159;
  struct RefPtr D.111433;
  struct slot1 * D.118167;
  void * D.118169;
  gint D.118171;
  typedef struct SlotType SlotType;
  struct Application * obj;
  typedef RType RType;

  D.118159 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.118159 == 0B) goto <D.118160>; else goto <D.118161>;
  <D.118160>:
  iftmp.219 = 0B;
  goto <D.118162>;
  <D.118161>:
  iftmp.219 = __dynamic_cast (D.118159, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
  <D.118162>:
  obj = iftmp.219;
  {
    if (obj != 0B) goto <D.118163>; else goto <D.118164>;
    <D.118163>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.118165>; else goto <D.118166>;
              <D.118165>:
              D.111433 = Glib::wrap (p0, 1); [return slot optimization]
              try
                {
                  D.118167 = &MEM[(struct SlotType *)slot].D.111431;
                  sigc::slot1<void, const Glib::RefPtr<Gio::ApplicationCommandLine>&>::operator() (D.118167, &D.111433);
                }
              finally
                {
                  Glib::RefPtr<Gio::ApplicationCommandLine>::~RefPtr (&D.111433);
                  D.111433 = {CLOBBER};
                }
              goto <D.118168>;
              <D.118166>:
              <D.118168>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.118169 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.118169);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.118170>;
    <D.118164>:
    <D.118170>:
  }
  D.118171 = 0;
  return D.118171;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = const Glib::RefPtr<Gio::ApplicationCommandLine>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = const Glib::RefPtr<Gio::ApplicationCommandLine>&] (const struct slot1 * const this, const struct RefPtr & _A_a1)
{
  bool retval.220;
  bool iftmp.221;
  const struct slot_base * D.118182;
  bool D.118183;
  bool D.118184;
  bool D.118186;
  bool D.118187;
  struct rep_type * D.118191;
  void * (*<T605>) (void *) D.118192;

  D.118182 = &this->D.111389;
  D.118183 = sigc::slot_base::empty (D.118182);
  D.118184 = ~D.118183;
  if (D.118184 != 0) goto <D.118185>; else goto <D.118180>;
  <D.118185>:
  D.118182 = &this->D.111389;
  D.118186 = sigc::slot_base::blocked (D.118182);
  D.118187 = ~D.118186;
  if (D.118187 != 0) goto <D.118188>; else goto <D.118180>;
  <D.118188>:
  iftmp.221 = 1;
  goto <D.118181>;
  <D.118180>:
  iftmp.221 = 0;
  <D.118181>:
  retval.220 = iftmp.221;
  if (retval.220 != 0) goto <D.118189>; else goto <D.118190>;
  <D.118189>:
  D.118191 = this->D.111389.rep_;
  D.118192 = D.118191->call_;
  D.118191 = this->D.111389.rep_;
  D.118192 (D.118191, _A_a1);
  return;
  <D.118190>:
  return;
}


gint {anonymous}::Application_signal_command_line_callback(GApplication*, GApplicationCommandLine*, void*) (struct GApplication * self, struct GApplicationCommandLine * p0, void * data)
{
  struct Application * iftmp.222;
  struct ObjectBase * D.118195;
  gint D.118203;
  struct RefPtr D.111327;
  struct slot1 * D.118204;
  void * D.118205;
  typedef struct SlotType SlotType;
  struct Application * obj;
  typedef RType RType;

  D.118195 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.118195 == 0B) goto <D.118196>; else goto <D.118197>;
  <D.118196>:
  iftmp.222 = 0B;
  goto <D.118198>;
  <D.118197>:
  iftmp.222 = __dynamic_cast (D.118195, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
  <D.118198>:
  obj = iftmp.222;
  {
    if (obj != 0B) goto <D.118199>; else goto <D.118200>;
    <D.118199>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.118201>; else goto <D.118202>;
              <D.118201>:
              D.111327 = Glib::wrap (p0, 1); [return slot optimization]
              try
                {
                  D.118204 = &MEM[(struct SlotType *)slot].D.111201;
                  D.118203 = sigc::slot1<int, const Glib::RefPtr<Gio::ApplicationCommandLine>&>::operator() (D.118204, &D.111327);
                  return D.118203;
                }
              finally
                {
                  Glib::RefPtr<Gio::ApplicationCommandLine>::~RefPtr (&D.111327);
                  D.111327 = {CLOBBER};
                }
              <D.118202>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.118205 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.118205);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.118206>;
    <D.118200>:
    <D.118206>:
  }
  D.118203 = 0;
  return D.118203;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = int; T_arg1 = const Glib::RefPtr<Gio::ApplicationCommandLine>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = const Glib::RefPtr<Gio::ApplicationCommandLine>&] (const struct slot1 * const this, const struct RefPtr & _A_a1)
{
  bool retval.223;
  bool iftmp.224;
  const struct slot_base * D.118219;
  bool D.118220;
  bool D.118221;
  bool D.118223;
  bool D.118224;
  int D.118228;
  struct rep_type * D.118229;
  void * (*<T605>) (void *) D.118230;

  D.118219 = &this->D.111159;
  D.118220 = sigc::slot_base::empty (D.118219);
  D.118221 = ~D.118220;
  if (D.118221 != 0) goto <D.118222>; else goto <D.118217>;
  <D.118222>:
  D.118219 = &this->D.111159;
  D.118223 = sigc::slot_base::blocked (D.118219);
  D.118224 = ~D.118223;
  if (D.118224 != 0) goto <D.118225>; else goto <D.118217>;
  <D.118225>:
  iftmp.224 = 1;
  goto <D.118218>;
  <D.118217>:
  iftmp.224 = 0;
  <D.118218>:
  retval.223 = iftmp.224;
  if (retval.223 != 0) goto <D.118226>; else goto <D.118227>;
  <D.118226>:
  D.118229 = this->D.111159.rep_;
  D.118230 = D.118229->call_;
  D.118229 = this->D.111159.rep_;
  D.118228 = D.118230 (D.118229, _A_a1);
  return D.118228;
  <D.118227>:
  D.118228 = 0;
  return D.118228;
}


Glib::SignalProxy1<R, P1>::SignalProxy1(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = int; P1 = const Glib::RefPtr<Gio::ApplicationCommandLine>&] (struct SignalProxy1 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.118233;

  D.118233 = &this->D.112877;
  Glib::SignalProxyNormal::SignalProxyNormal (D.118233, obj, info);
  try
    {

    }
  catch
    {
      D.118233 = &this->D.112877;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.118233);
    }
}


Glib::SignalProxy1<int, const Glib::RefPtr<Glib::VariantDict>&> Gio::Application::signal_handle_local_options() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118235;
  int (*__vtbl_ptr_type) () * D.118236;
  long int D.118237;
  sizetype D.118238;
  struct ObjectBase * D.118239;

  D.118235 = this->D.106831._vptr.Object;
  D.118236 = D.118235 + 18446744073709551592;
  D.118237 = MEM[(long int *)D.118236];
  D.118238 = (sizetype) D.118237;
  D.118239 = this + D.118238;
  Glib::SignalProxy1<int, const Glib::RefPtr<Glib::VariantDict>&>::SignalProxy1 (<retval>, D.118239, &Application_signal_handle_local_options_info);
  return <retval>;
}


gint {anonymous}::Application_signal_handle_local_options_notify_callback(GApplication*, GVariantDict*, void*) (struct GApplication * self, struct GVariantDict * p0, void * data)
{
  struct Application * iftmp.225;
  struct ObjectBase * D.118242;
  struct RefPtr D.111777;
  struct slot1 * D.118250;
  void * D.118252;
  gint D.118254;
  typedef struct SlotType SlotType;
  struct Application * obj;
  typedef RType RType;

  D.118242 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.118242 == 0B) goto <D.118243>; else goto <D.118244>;
  <D.118243>:
  iftmp.225 = 0B;
  goto <D.118245>;
  <D.118244>:
  iftmp.225 = __dynamic_cast (D.118242, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
  <D.118245>:
  obj = iftmp.225;
  {
    if (obj != 0B) goto <D.118246>; else goto <D.118247>;
    <D.118246>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.118248>; else goto <D.118249>;
              <D.118248>:
              D.111777 = Glib::wrap (p0, 1); [return slot optimization]
              try
                {
                  D.118250 = &MEM[(struct SlotType *)slot].D.111775;
                  sigc::slot1<void, const Glib::RefPtr<Glib::VariantDict>&>::operator() (D.118250, &D.111777);
                }
              finally
                {
                  Glib::RefPtr<Glib::VariantDict>::~RefPtr (&D.111777);
                  D.111777 = {CLOBBER};
                }
              goto <D.118251>;
              <D.118249>:
              <D.118251>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.118252 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.118252);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.118253>;
    <D.118247>:
    <D.118253>:
  }
  D.118254 = 0;
  return D.118254;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = const Glib::RefPtr<Glib::VariantDict>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = const Glib::RefPtr<Glib::VariantDict>&] (const struct slot1 * const this, const struct RefPtr & _A_a1)
{
  bool retval.226;
  bool iftmp.227;
  const struct slot_base * D.118265;
  bool D.118266;
  bool D.118267;
  bool D.118269;
  bool D.118270;
  struct rep_type * D.118274;
  void * (*<T605>) (void *) D.118275;

  D.118265 = &this->D.111733;
  D.118266 = sigc::slot_base::empty (D.118265);
  D.118267 = ~D.118266;
  if (D.118267 != 0) goto <D.118268>; else goto <D.118263>;
  <D.118268>:
  D.118265 = &this->D.111733;
  D.118269 = sigc::slot_base::blocked (D.118265);
  D.118270 = ~D.118269;
  if (D.118270 != 0) goto <D.118271>; else goto <D.118263>;
  <D.118271>:
  iftmp.227 = 1;
  goto <D.118264>;
  <D.118263>:
  iftmp.227 = 0;
  <D.118264>:
  retval.226 = iftmp.227;
  if (retval.226 != 0) goto <D.118272>; else goto <D.118273>;
  <D.118272>:
  D.118274 = this->D.111733.rep_;
  D.118275 = D.118274->call_;
  D.118274 = this->D.111733.rep_;
  D.118275 (D.118274, _A_a1);
  return;
  <D.118273>:
  return;
}


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

  {
    try
      {
        D.118277 = this->pCppObject_;
        if (D.118277 != 0B) goto <D.118278>; else goto <D.118279>;
        <D.118278>:
        D.118277 = this->pCppObject_;
        Glib::VariantDict::unreference (D.118277);
        goto <D.118280>;
        <D.118279>:
        <D.118280>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114122>:
}


gint {anonymous}::Application_signal_handle_local_options_callback(GApplication*, GVariantDict*, void*) (struct GApplication * self, struct GVariantDict * p0, void * data)
{
  struct Application * iftmp.228;
  struct ObjectBase * D.118283;
  gint D.118291;
  struct RefPtr D.111671;
  struct slot1 * D.118292;
  void * D.118293;
  typedef struct SlotType SlotType;
  struct Application * obj;
  typedef RType RType;

  D.118283 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.118283 == 0B) goto <D.118284>; else goto <D.118285>;
  <D.118284>:
  iftmp.228 = 0B;
  goto <D.118286>;
  <D.118285>:
  iftmp.228 = __dynamic_cast (D.118283, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11ApplicationE, -1);
  <D.118286>:
  obj = iftmp.228;
  {
    if (obj != 0B) goto <D.118287>; else goto <D.118288>;
    <D.118287>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.118289>; else goto <D.118290>;
              <D.118289>:
              D.111671 = Glib::wrap (p0, 1); [return slot optimization]
              try
                {
                  D.118292 = &MEM[(struct SlotType *)slot].D.111545;
                  D.118291 = sigc::slot1<int, const Glib::RefPtr<Glib::VariantDict>&>::operator() (D.118292, &D.111671);
                  return D.118291;
                }
              finally
                {
                  Glib::RefPtr<Glib::VariantDict>::~RefPtr (&D.111671);
                  D.111671 = {CLOBBER};
                }
              <D.118290>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.118293 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.118293);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.118294>;
    <D.118288>:
    <D.118294>:
  }
  D.118291 = 0;
  return D.118291;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = int; T_arg1 = const Glib::RefPtr<Glib::VariantDict>&; sigc::slot1<T_return, T_arg1>::arg1_type_ = const Glib::RefPtr<Glib::VariantDict>&] (const struct slot1 * const this, const struct RefPtr & _A_a1)
{
  bool retval.229;
  bool iftmp.230;
  const struct slot_base * D.118307;
  bool D.118308;
  bool D.118309;
  bool D.118311;
  bool D.118312;
  int D.118316;
  struct rep_type * D.118317;
  void * (*<T605>) (void *) D.118318;

  D.118307 = &this->D.111503;
  D.118308 = sigc::slot_base::empty (D.118307);
  D.118309 = ~D.118308;
  if (D.118309 != 0) goto <D.118310>; else goto <D.118305>;
  <D.118310>:
  D.118307 = &this->D.111503;
  D.118311 = sigc::slot_base::blocked (D.118307);
  D.118312 = ~D.118311;
  if (D.118312 != 0) goto <D.118313>; else goto <D.118305>;
  <D.118313>:
  iftmp.230 = 1;
  goto <D.118306>;
  <D.118305>:
  iftmp.230 = 0;
  <D.118306>:
  retval.229 = iftmp.230;
  if (retval.229 != 0) goto <D.118314>; else goto <D.118315>;
  <D.118314>:
  D.118317 = this->D.111503.rep_;
  D.118318 = D.118317->call_;
  D.118317 = this->D.111503.rep_;
  D.118316 = D.118318 (D.118317, _A_a1);
  return D.118316;
  <D.118315>:
  D.118316 = 0;
  return D.118316;
}


Glib::SignalProxy1<R, P1>::SignalProxy1(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = int; P1 = const Glib::RefPtr<Glib::VariantDict>&] (struct SignalProxy1 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.118321;

  D.118321 = &this->D.112931;
  Glib::SignalProxyNormal::SignalProxyNormal (D.118321, obj, info);
  try
    {

    }
  catch
    {
      D.118321 = &this->D.112931;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.118321);
    }
}


Glib::PropertyProxy_WriteOnly<Glib::RefPtr<Gio::ActionGroup> > Gio::Application::property_action_group() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118323;
  int (*__vtbl_ptr_type) () * D.118324;
  long int D.118325;
  sizetype D.118326;
  struct ObjectBase * D.118327;

  D.118323 = this->D.106831._vptr.Object;
  D.118324 = D.118323 + 18446744073709551592;
  D.118325 = MEM[(long int *)D.118324];
  D.118326 = (sizetype) D.118325;
  D.118327 = this + D.118326;
  Glib::PropertyProxy_WriteOnly<Glib::RefPtr<Gio::ActionGroup> >::PropertyProxy_WriteOnly (<retval>, D.118327, "action-group");
  return <retval>;
}


Glib::PropertyProxy_WriteOnly<T>::PropertyProxy_WriteOnly(Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::ActionGroup>] (struct PropertyProxy_WriteOnly * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.118329;

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


Glib::PropertyProxy<Glib::ustring> Gio::Application::property_application_id() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118331;
  int (*__vtbl_ptr_type) () * D.118332;
  long int D.118333;
  sizetype D.118334;
  struct ObjectBase * D.118335;

  D.118331 = this->D.106831._vptr.Object;
  D.118332 = D.118331 + 18446744073709551592;
  D.118333 = MEM[(long int *)D.118332];
  D.118334 = (sizetype) D.118333;
  D.118335 = this + D.118334;
  Glib::PropertyProxy<Glib::ustring>::PropertyProxy (<retval>, D.118335, "application-id");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::Application::property_application_id() const (const struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118339;
  int (*__vtbl_ptr_type) () * D.118340;
  long int D.118341;
  sizetype D.118342;
  const struct ObjectBase * D.118343;

  D.118339 = this->D.106831._vptr.Object;
  D.118340 = D.118339 + 18446744073709551592;
  D.118341 = MEM[(long int *)D.118340];
  D.118342 = (sizetype) D.118341;
  D.118343 = this + D.118342;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.118343, "application-id");
  return <retval>;
}


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

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


Glib::PropertyProxy<Gio::ApplicationFlags> Gio::Application::property_flags() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118347;
  int (*__vtbl_ptr_type) () * D.118348;
  long int D.118349;
  sizetype D.118350;
  struct ObjectBase * D.118351;

  D.118347 = this->D.106831._vptr.Object;
  D.118348 = D.118347 + 18446744073709551592;
  D.118349 = MEM[(long int *)D.118348];
  D.118350 = (sizetype) D.118349;
  D.118351 = this + D.118350;
  Glib::PropertyProxy<Gio::ApplicationFlags>::PropertyProxy (<retval>, D.118351, "flags");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Gio::ApplicationFlags> Gio::Application::property_flags() const (const struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118355;
  int (*__vtbl_ptr_type) () * D.118356;
  long int D.118357;
  sizetype D.118358;
  const struct ObjectBase * D.118359;

  D.118355 = this->D.106831._vptr.Object;
  D.118356 = D.118355 + 18446744073709551592;
  D.118357 = MEM[(long int *)D.118356];
  D.118358 = (sizetype) D.118357;
  D.118359 = this + D.118358;
  Glib::PropertyProxy_ReadOnly<Gio::ApplicationFlags>::PropertyProxy_ReadOnly (<retval>, D.118359, "flags");
  return <retval>;
}


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

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


Glib::PropertyProxy<unsigned int> Gio::Application::property_inactivity_timeout() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118363;
  int (*__vtbl_ptr_type) () * D.118364;
  long int D.118365;
  sizetype D.118366;
  struct ObjectBase * D.118367;

  D.118363 = this->D.106831._vptr.Object;
  D.118364 = D.118363 + 18446744073709551592;
  D.118365 = MEM[(long int *)D.118364];
  D.118366 = (sizetype) D.118365;
  D.118367 = this + D.118366;
  Glib::PropertyProxy<unsigned int>::PropertyProxy (<retval>, D.118367, "inactivity-timeout");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<unsigned int> Gio::Application::property_inactivity_timeout() const (const struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118371;
  int (*__vtbl_ptr_type) () * D.118372;
  long int D.118373;
  sizetype D.118374;
  const struct ObjectBase * D.118375;

  D.118371 = this->D.106831._vptr.Object;
  D.118372 = D.118371 + 18446744073709551592;
  D.118373 = MEM[(long int *)D.118372];
  D.118374 = (sizetype) D.118373;
  D.118375 = this + D.118374;
  Glib::PropertyProxy_ReadOnly<unsigned int>::PropertyProxy_ReadOnly (<retval>, D.118375, "inactivity-timeout");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<bool> Gio::Application::property_is_registered() const (const struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118379;
  int (*__vtbl_ptr_type) () * D.118380;
  long int D.118381;
  sizetype D.118382;
  const struct ObjectBase * D.118383;

  D.118379 = this->D.106831._vptr.Object;
  D.118380 = D.118379 + 18446744073709551592;
  D.118381 = MEM[(long int *)D.118380];
  D.118382 = (sizetype) D.118381;
  D.118383 = this + D.118382;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.118383, "is-registered");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<bool> Gio::Application::property_is_remote() const (const struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118387;
  int (*__vtbl_ptr_type) () * D.118388;
  long int D.118389;
  sizetype D.118390;
  const struct ObjectBase * D.118391;

  D.118387 = this->D.106831._vptr.Object;
  D.118388 = D.118387 + 18446744073709551592;
  D.118389 = MEM[(long int *)D.118388];
  D.118390 = (sizetype) D.118389;
  D.118391 = this + D.118390;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.118391, "is-remote");
  return <retval>;
}


virtual void Gio::Application::on_startup() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118393;
  int (*__vtbl_ptr_type) () * D.118394;
  long int D.118395;
  sizetype D.118396;
  struct ObjectBase * D.118397;
  struct GObject * D.118398;
  struct GTypeClass * D.118399;
  void (*<Tf930>) (struct GApplication *) D.118402;
  struct GApplication * D.118405;
  struct BaseClassType * const base;

  D.118393 = this->D.106831._vptr.Object;
  D.118394 = D.118393 + 18446744073709551592;
  D.118395 = MEM[(long int *)D.118394];
  D.118396 = (sizetype) D.118395;
  D.118397 = this + D.118396;
  D.118398 = D.118397->gobject_;
  D.118399 = MEM[(struct GTypeInstance *)D.118398].g_class;
  base = g_type_class_peek_parent (D.118399);
  if (base != 0B) goto <D.118400>; else goto <D.118401>;
  <D.118400>:
  D.118402 = base->startup;
  if (D.118402 != 0B) goto <D.118403>; else goto <D.118404>;
  <D.118403>:
  D.118402 = base->startup;
  D.118405 = Gio::Application::gobj (this);
  D.118402 (D.118405);
  goto <D.118406>;
  <D.118404>:
  <D.118406>:
  <D.118401>:
}


virtual void Gio::Application::on_activate() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118408;
  int (*__vtbl_ptr_type) () * D.118409;
  long int D.118410;
  sizetype D.118411;
  struct ObjectBase * D.118412;
  struct GObject * D.118413;
  struct GTypeClass * D.118414;
  void (*<Tf930>) (struct GApplication *) D.118417;
  struct GApplication * D.118420;
  struct BaseClassType * const base;

  D.118408 = this->D.106831._vptr.Object;
  D.118409 = D.118408 + 18446744073709551592;
  D.118410 = MEM[(long int *)D.118409];
  D.118411 = (sizetype) D.118410;
  D.118412 = this + D.118411;
  D.118413 = D.118412->gobject_;
  D.118414 = MEM[(struct GTypeInstance *)D.118413].g_class;
  base = g_type_class_peek_parent (D.118414);
  if (base != 0B) goto <D.118415>; else goto <D.118416>;
  <D.118415>:
  D.118417 = base->activate;
  if (D.118417 != 0B) goto <D.118418>; else goto <D.118419>;
  <D.118418>:
  D.118417 = base->activate;
  D.118420 = Gio::Application::gobj (this);
  D.118417 (D.118420);
  goto <D.118421>;
  <D.118419>:
  <D.118421>:
  <D.118416>:
}


virtual int Gio::Application::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>&) (struct Application * const this, const struct RefPtr & command_line)
{
  int (*__vtbl_ptr_type) () * D.118423;
  int (*__vtbl_ptr_type) () * D.118424;
  long int D.118425;
  sizetype D.118426;
  struct ObjectBase * D.118427;
  struct GObject * D.118428;
  struct GTypeClass * D.118429;
  int (*<Tf940>) (struct GApplication *, struct GApplicationCommandLine *) D.118432;
  int D.118435;
  struct BaseObjectType * D.118436;
  struct GApplication * D.118437;
  struct BaseClassType * const base;
  typedef RType RType;

  D.118423 = this->D.106831._vptr.Object;
  D.118424 = D.118423 + 18446744073709551592;
  D.118425 = MEM[(long int *)D.118424];
  D.118426 = (sizetype) D.118425;
  D.118427 = this + D.118426;
  D.118428 = D.118427->gobject_;
  D.118429 = MEM[(struct GTypeInstance *)D.118428].g_class;
  base = g_type_class_peek_parent (D.118429);
  if (base != 0B) goto <D.118430>; else goto <D.118431>;
  <D.118430>:
  D.118432 = base->command_line;
  if (D.118432 != 0B) goto <D.118433>; else goto <D.118434>;
  <D.118433>:
  D.118432 = base->command_line;
  D.118436 = Glib::unwrap<Gio::ApplicationCommandLine> (command_line);
  D.118437 = Gio::Application::gobj (this);
  D.118435 = D.118432 (D.118437, D.118436);
  return D.118435;
  <D.118434>:
  <D.118431>:
  D.118435 = 0;
  return D.118435;
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::ApplicationCommandLine; typename T::BaseObjectType = _GApplicationCommandLine] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.118442;
  struct BaseObjectType * iftmp.231;
  bool D.118444;
  struct ApplicationCommandLine * D.118447;

  D.118444 = Glib::RefPtr<Gio::ApplicationCommandLine>::operator bool (ptr);
  if (D.118444 != 0) goto <D.118445>; else goto <D.118446>;
  <D.118445>:
  D.118447 = Glib::RefPtr<Gio::ApplicationCommandLine>::operator-> (ptr);
  iftmp.231 = Gio::ApplicationCommandLine::gobj (D.118447);
  goto <D.118448>;
  <D.118446>:
  iftmp.231 = 0B;
  <D.118448>:
  D.118442 = iftmp.231;
  return D.118442;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::ApplicationCommandLine] (const struct RefPtr * const this)
{
  bool D.118450;
  struct ApplicationCommandLine * D.118451;

  D.118451 = this->pCppObject_;
  D.118450 = D.118451 != 0B;
  return D.118450;
}


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

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


GApplicationCommandLine* Gio::ApplicationCommandLine::gobj() (struct ApplicationCommandLine * const this)
{
  struct GApplicationCommandLine * D.118455;
  int (*__vtbl_ptr_type) () * D.118456;
  int (*__vtbl_ptr_type) () * D.118457;
  long int D.118458;
  sizetype D.118459;
  struct ObjectBase * D.118460;

  D.118456 = this->D.103022._vptr.Object;
  D.118457 = D.118456 + 18446744073709551592;
  D.118458 = MEM[(long int *)D.118457];
  D.118459 = (sizetype) D.118458;
  D.118460 = this + D.118459;
  D.118455 = D.118460->gobject_;
  return D.118455;
}


virtual bool Gio::Application::local_command_line_vfunc(char**&, int&) (struct Application * const this, char * * & arguments, int & exit_status)
{
  int (*__vtbl_ptr_type) () * D.118462;
  int (*__vtbl_ptr_type) () * D.118463;
  long int D.118464;
  sizetype D.118465;
  struct ObjectBase * D.118466;
  struct GObject * D.118467;
  struct GTypeClass * D.118468;
  gboolean (*<Tf944>) (struct GApplication *, gchar * * *, int *) D.118471;
  struct GApplication * D.118474;
  int D.118475;
  bool D.118476;
  struct BaseClassType * const base;
  typedef RType RType;

  D.118462 = this->D.106831._vptr.Object;
  D.118463 = D.118462 + 18446744073709551592;
  D.118464 = MEM[(long int *)D.118463];
  D.118465 = (sizetype) D.118464;
  D.118466 = this + D.118465;
  D.118467 = D.118466->gobject_;
  D.118468 = MEM[(struct GTypeInstance *)D.118467].g_class;
  base = g_type_class_peek_parent (D.118468);
  {
    if (base != 0B) goto <D.118469>; else goto <D.118470>;
    <D.118469>:
    D.118471 = base->local_command_line;
    if (D.118471 != 0B) goto <D.118472>; else goto <D.118473>;
    <D.118472>:
    {
      bool retval;

      D.118471 = base->local_command_line;
      D.118474 = Gio::Application::gobj (this);
      D.118475 = D.118471 (D.118474, arguments, exit_status);
      retval = D.118475 != 0;
      D.118476 = retval;
      return D.118476;
    }
    <D.118473>:
    <D.118470>:
  }
  D.118476 = 0;
  return D.118476;
}


virtual void Gio::Application::before_emit_vfunc(const Glib::VariantBase&) (struct Application * const this, const struct VariantBase & platform_data)
{
  int (*__vtbl_ptr_type) () * D.118480;
  int (*__vtbl_ptr_type) () * D.118481;
  long int D.118482;
  sizetype D.118483;
  struct ObjectBase * D.118484;
  struct GObject * D.118485;
  struct GTypeClass * D.118486;
  void (*<Tf948>) (struct GApplication *, struct GVariant *) D.118489;
  const struct GVariant * D.118492;
  struct GApplication * D.118493;
  struct BaseClassType * const base;

  D.118480 = this->D.106831._vptr.Object;
  D.118481 = D.118480 + 18446744073709551592;
  D.118482 = MEM[(long int *)D.118481];
  D.118483 = (sizetype) D.118482;
  D.118484 = this + D.118483;
  D.118485 = D.118484->gobject_;
  D.118486 = MEM[(struct GTypeInstance *)D.118485].g_class;
  base = g_type_class_peek_parent (D.118486);
  if (base != 0B) goto <D.118487>; else goto <D.118488>;
  <D.118487>:
  D.118489 = base->before_emit;
  if (D.118489 != 0B) goto <D.118490>; else goto <D.118491>;
  <D.118490>:
  D.118489 = base->before_emit;
  D.118492 = Glib::VariantBase::gobj (platform_data);
  D.118493 = Gio::Application::gobj (this);
  D.118489 (D.118493, D.118492);
  goto <D.118494>;
  <D.118491>:
  <D.118494>:
  <D.118488>:
}


const GVariant* Glib::VariantBase::gobj() const (const struct VariantBase * const this)
{
  const struct GVariant * D.118496;

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


virtual void Gio::Application::after_emit_vfunc(const Glib::VariantBase&) (struct Application * const this, const struct VariantBase & platform_data)
{
  int (*__vtbl_ptr_type) () * D.118498;
  int (*__vtbl_ptr_type) () * D.118499;
  long int D.118500;
  sizetype D.118501;
  struct ObjectBase * D.118502;
  struct GObject * D.118503;
  struct GTypeClass * D.118504;
  void (*<Tf948>) (struct GApplication *, struct GVariant *) D.118507;
  const struct GVariant * D.118510;
  struct GApplication * D.118511;
  struct BaseClassType * const base;

  D.118498 = this->D.106831._vptr.Object;
  D.118499 = D.118498 + 18446744073709551592;
  D.118500 = MEM[(long int *)D.118499];
  D.118501 = (sizetype) D.118500;
  D.118502 = this + D.118501;
  D.118503 = D.118502->gobject_;
  D.118504 = MEM[(struct GTypeInstance *)D.118503].g_class;
  base = g_type_class_peek_parent (D.118504);
  if (base != 0B) goto <D.118505>; else goto <D.118506>;
  <D.118505>:
  D.118507 = base->after_emit;
  if (D.118507 != 0B) goto <D.118508>; else goto <D.118509>;
  <D.118508>:
  D.118507 = base->after_emit;
  D.118510 = Glib::VariantBase::gobj (platform_data);
  D.118511 = Gio::Application::gobj (this);
  D.118507 (D.118511, D.118510);
  goto <D.118512>;
  <D.118509>:
  <D.118512>:
  <D.118506>:
}


virtual void Gio::Application::quit_mainloop_vfunc() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118514;
  int (*__vtbl_ptr_type) () * D.118515;
  long int D.118516;
  sizetype D.118517;
  struct ObjectBase * D.118518;
  struct GObject * D.118519;
  struct GTypeClass * D.118520;
  void (*<Tf930>) (struct GApplication *) D.118523;
  struct GApplication * D.118526;
  struct BaseClassType * const base;

  D.118514 = this->D.106831._vptr.Object;
  D.118515 = D.118514 + 18446744073709551592;
  D.118516 = MEM[(long int *)D.118515];
  D.118517 = (sizetype) D.118516;
  D.118518 = this + D.118517;
  D.118519 = D.118518->gobject_;
  D.118520 = MEM[(struct GTypeInstance *)D.118519].g_class;
  base = g_type_class_peek_parent (D.118520);
  if (base != 0B) goto <D.118521>; else goto <D.118522>;
  <D.118521>:
  D.118523 = base->quit_mainloop;
  if (D.118523 != 0B) goto <D.118524>; else goto <D.118525>;
  <D.118524>:
  D.118523 = base->quit_mainloop;
  D.118526 = Gio::Application::gobj (this);
  D.118523 (D.118526);
  goto <D.118527>;
  <D.118525>:
  <D.118527>:
  <D.118522>:
}


virtual void Gio::Application::run_mainloop_vfunc() (struct Application * const this)
{
  int (*__vtbl_ptr_type) () * D.118529;
  int (*__vtbl_ptr_type) () * D.118530;
  long int D.118531;
  sizetype D.118532;
  struct ObjectBase * D.118533;
  struct GObject * D.118534;
  struct GTypeClass * D.118535;
  void (*<Tf930>) (struct GApplication *) D.118538;
  struct GApplication * D.118541;
  struct BaseClassType * const base;

  D.118529 = this->D.106831._vptr.Object;
  D.118530 = D.118529 + 18446744073709551592;
  D.118531 = MEM[(long int *)D.118530];
  D.118532 = (sizetype) D.118531;
  D.118533 = this + D.118532;
  D.118534 = D.118533->gobject_;
  D.118535 = MEM[(struct GTypeInstance *)D.118534].g_class;
  base = g_type_class_peek_parent (D.118535);
  if (base != 0B) goto <D.118536>; else goto <D.118537>;
  <D.118536>:
  D.118538 = base->run_mainloop;
  if (D.118538 != 0B) goto <D.118539>; else goto <D.118540>;
  <D.118539>:
  D.118538 = base->run_mainloop;
  D.118541 = Gio::Application::gobj (this);
  D.118538 (D.118541);
  goto <D.118542>;
  <D.118540>:
  <D.118542>:
  <D.118537>:
}


(static initializers for application.cc) ()
{
  __static_initialization_and_destruction_0 (1, 65535);
}


void __static_initialization_and_destruction_0(int, int) (int __initialize_p, int __priority)
{
  unsigned int quark_extra_application_data.232;

  if (__initialize_p == 1) goto <D.118544>; else goto <D.118545>;
  <D.118544>:
  if (__priority == 65535) goto <D.118546>; else goto <D.118547>;
  <D.118546>:
  quark_extra_application_data.232 = g_quark_from_static_string ("glibmm__Gio::Application::quark_extra_application_data");
  quark_extra_application_data = quark_extra_application_data.232;
  std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::map (&option_arg_callback_data);
  __cxa_atexit (__comp_dtor , &option_arg_callback_data, &__dso_handle);
  Glib::Threads::Mutex::Mutex (&option_arg_callback_data_mutex);
  __cxa_atexit (__comp_dtor , &option_arg_callback_data_mutex, &__dso_handle);
  goto <D.118549>;
  <D.118547>:
  <D.118549>:
  goto <D.118550>;
  <D.118545>:
  <D.118550>:
}


std::map<Glib::ustring, {anonymous}::OptionArgCallbackData*>::~map() (struct map * const this)
{
  struct _Rep_type * D.118552;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.118552 = &this->_M_t;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~_Rb_tree (D.118552);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.115426>:
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::~_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.118554;
  struct _Rb_tree_impl * D.118555;

  {
    try
      {
        try
          {
            D.118554 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_begin (this);
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_erase (this, D.118554);
          }
        finally
          {
            D.118555 = &this->_M_impl;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl (D.118555);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114488>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __x)
{
  struct _Rb_tree_node * D.118558;

  goto <D.114771>;
  <D.114772>:
  {
    struct _Rb_tree_node * __y;

    D.118558 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_right (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_erase (this, D.118558);
    __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_S_left (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_M_destroy_node (this, __x);
    __x = __y;
  }
  <D.114771>:
  if (__x != 0B) goto <D.114772>; else goto <D.114770>;
  <D.114770>:
}


std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl() (struct _Rb_tree_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.114479>:
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct allocator * const this)
{
  void * D.118559;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.114765>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.118559 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.118559);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct new_allocator * const this)
{
  void * D.118560;

  try
    {
      {
        try
          {

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


std::map<_Key, _Tp, _Compare, _Alloc>::map() [with _Key = Glib::ustring; _Tp = {anonymous}::OptionArgCallbackData*; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct map * const this)
{
  struct _Rep_type * D.118561;

  D.118561 = &this->_M_t;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree (D.118561);
  try
    {

    }
  catch
    {
      D.118561 = &this->_M_t;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~_Rb_tree (D.118561);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_impl * D.118562;

  D.118562 = &this->_M_impl;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::_Rb_tree_impl (D.118562);
  try
    {

    }
  catch
    {
      D.118562 = &this->_M_impl;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl (D.118562);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_Rb_tree_impl() [with _Key_compare = std::less<Glib::ustring>; bool _Is_pod_comparator = false; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_impl * const this)
{
  std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::allocator (this);
  try
    {
      this->_M_header._M_color = 0;
      this->_M_header._M_parent = 0B;
      this->_M_header._M_left = 0B;
      this->_M_header._M_right = 0B;
      this->_M_node_count = 0;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>, std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::_M_initialize (this);
    }
  catch
    {
      std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct allocator * const this)
{
  void * D.118563;

  try
    {
      {
        __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> > >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.118563 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.118563);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct new_allocator * const this)
{
  void * D.118564;

  try
    {
      {

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


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_M_initialize() [with _Key_compare = std::less<Glib::ustring>; bool _Is_pod_comparator = false; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, {anonymous}::OptionArgCallbackData*> >] (struct _Rb_tree_impl * const this)
{
  struct _Rb_tree_node_base * D.118565;

  this->_M_header._M_color = 0;
  this->_M_header._M_parent = 0B;
  D.118565 = &this->_M_header;
  this->_M_header._M_left = D.118565;
  D.118565 = &this->_M_header;
  this->_M_header._M_right = D.118565;
}