Glib::OptionEntry::OptionEntry() (struct OptionEntry * const this)
{
  int D.86640;
  long unsigned int D.86643;
  long unsigned int D.86644;

  this->_vptr.OptionEntry = &MEM[(void *)&_ZTVN4Glib11OptionEntryE + 16B];
  {
    {
      gsize __n;
      gsize __s;
      void * __p;

      __n = 1;
      __s = 48;
      if (__s == 1) goto <D.86634>; else goto <D.86635>;
      <D.86634>:
      __p = g_malloc0 (__n);
      goto <D.86636>;
      <D.86635>:
      D.86640 = __builtin_constant_p (__n);
      if (D.86640 != 0) goto <D.86641>; else goto <D.86637>;
      <D.86641>:
      if (__s == 0) goto <D.86638>; else goto <D.86642>;
      <D.86642>:
      D.86643 = 18446744073709551615 / __s;
      if (D.86643 >= __n) goto <D.86638>; else goto <D.86637>;
      <D.86638>:
      D.86644 = __n * __s;
      __p = g_malloc0 (D.86644);
      goto <D.86639>;
      <D.86637>:
      __p = g_malloc0_n (__n, __s);
      <D.86639>:
      <D.86636>:
      this->gobject_ = __p;
    }
  }
}


Glib::OptionEntry::~OptionEntry() (struct OptionEntry * const this)
{
  struct GOptionEntry * D.86648;
  const gchar * D.86649;
  const gchar * D.86650;
  const gchar * D.86651;
  int D.86652;

  {
    this->_vptr.OptionEntry = &MEM[(void *)&_ZTVN4Glib11OptionEntryE + 16B];
    try
      {
        D.86648 = this->gobject_;
        D.86649 = D.86648->long_name;
        g_free (D.86649);
        D.86648 = this->gobject_;
        D.86650 = D.86648->description;
        g_free (D.86650);
        D.86648 = this->gobject_;
        D.86651 = D.86648->arg_description;
        g_free (D.86651);
        D.86648 = this->gobject_;
        g_free (D.86648);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.85931>:
  D.86652 = 0;
  if (D.86652 != 0) goto <D.86653>; else goto <D.86654>;
  <D.86653>:
  operator delete (this);
  goto <D.86655>;
  <D.86654>:
  <D.86655>:
}


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


Glib::OptionEntry::OptionEntry(const Glib::OptionEntry&) (struct OptionEntry * const this, const struct OptionEntry & src)
{
  int D.86664;
  long unsigned int D.86667;
  long unsigned int D.86668;

  this->_vptr.OptionEntry = &MEM[(void *)&_ZTVN4Glib11OptionEntryE + 16B];
  {
    {
      gsize __n;
      gsize __s;
      void * __p;

      __n = 1;
      __s = 48;
      if (__s == 1) goto <D.86658>; else goto <D.86659>;
      <D.86658>:
      __p = g_malloc0 (__n);
      goto <D.86660>;
      <D.86659>:
      D.86664 = __builtin_constant_p (__n);
      if (D.86664 != 0) goto <D.86665>; else goto <D.86661>;
      <D.86665>:
      if (__s == 0) goto <D.86662>; else goto <D.86666>;
      <D.86666>:
      D.86667 = 18446744073709551615 / __s;
      if (D.86667 >= __n) goto <D.86662>; else goto <D.86661>;
      <D.86662>:
      D.86668 = __n * __s;
      __p = g_malloc0 (D.86668);
      goto <D.86663>;
      <D.86661>:
      __p = g_malloc0_n (__n, __s);
      <D.86663>:
      <D.86660>:
      this->gobject_ = __p;
    }
    Glib::OptionEntry::operator= (this, src);
  }
}


Glib::OptionEntry& Glib::OptionEntry::operator=(const Glib::OptionEntry&) (struct OptionEntry * const this, const struct OptionEntry & src)
{
  struct GOptionEntry * D.86674;
  const gchar * D.86675;
  struct GOptionEntry * D.86679;
  const gchar * D.86680;
  gchar * D.86681;
  char D.86682;
  int D.86683;
  GOptionArg D.86684;
  void * D.86685;
  const gchar * D.86686;
  const gchar * D.86690;
  gchar * D.86691;
  const gchar * D.86692;
  const gchar * D.86696;
  gchar * D.86697;
  struct OptionEntry & D.86699;

  if (this != src) goto <D.86672>; else goto <D.86673>;
  <D.86672>:
  D.86674 = this->gobject_;
  D.86675 = D.86674->long_name;
  if (D.86675 != 0B) goto <D.86676>; else goto <D.86677>;
  <D.86676>:
  D.86674 = this->gobject_;
  D.86675 = D.86674->long_name;
  g_free (D.86675);
  goto <D.86678>;
  <D.86677>:
  <D.86678>:
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86680 = D.86679->long_name;
  D.86681 = g_strdup (D.86680);
  D.86674->long_name = D.86681;
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86682 = D.86679->short_name;
  D.86674->short_name = D.86682;
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86683 = D.86679->flags;
  D.86674->flags = D.86683;
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86684 = D.86679->arg;
  D.86674->arg = D.86684;
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86685 = D.86679->arg_data;
  D.86674->arg_data = D.86685;
  D.86674 = this->gobject_;
  D.86686 = D.86674->description;
  if (D.86686 != 0B) goto <D.86687>; else goto <D.86688>;
  <D.86687>:
  D.86674 = this->gobject_;
  D.86686 = D.86674->description;
  g_free (D.86686);
  goto <D.86689>;
  <D.86688>:
  <D.86689>:
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86690 = D.86679->description;
  D.86691 = g_strdup (D.86690);
  D.86674->description = D.86691;
  D.86674 = this->gobject_;
  D.86692 = D.86674->arg_description;
  if (D.86692 != 0B) goto <D.86693>; else goto <D.86694>;
  <D.86693>:
  D.86674 = this->gobject_;
  D.86692 = D.86674->arg_description;
  g_free (D.86692);
  goto <D.86695>;
  <D.86694>:
  <D.86695>:
  D.86674 = this->gobject_;
  D.86679 = src->gobject_;
  D.86696 = D.86679->arg_description;
  D.86697 = g_strdup (D.86696);
  D.86674->arg_description = D.86697;
  goto <D.86698>;
  <D.86673>:
  <D.86698>:
  D.86699 = this;
  return D.86699;
}


void Glib::OptionEntry::set_long_name(const Glib::ustring&) (struct OptionEntry * const this, const struct ustring & value)
{
  struct GOptionEntry * D.86704;
  const gchar * D.86705;
  struct GOptionEntry * D.86709;
  const gchar * iftmp.0;
  const char * D.86711;
  const char * D.86714;

  D.86704 = this->gobject_;
  D.86705 = D.86704->long_name;
  if (D.86705 != 0B) goto <D.86706>; else goto <D.86707>;
  <D.86706>:
  D.86704 = this->gobject_;
  D.86705 = D.86704->long_name;
  g_free (D.86705);
  D.86704 = this->gobject_;
  D.86704->long_name = 0B;
  goto <D.86708>;
  <D.86707>:
  <D.86708>:
  D.86709 = Glib::OptionEntry::gobj (this);
  D.86711 = Glib::ustring::c_str (value);
  if (D.86711 != 0B) goto <D.86712>; else goto <D.86713>;
  <D.86712>:
  D.86714 = Glib::ustring::c_str (value);
  iftmp.0 = g_strdup (D.86714);
  goto <D.86715>;
  <D.86713>:
  iftmp.0 = 0B;
  <D.86715>:
  D.86709->long_name = iftmp.0;
}


GOptionEntry* Glib::OptionEntry::gobj() (struct OptionEntry * const this)
{
  struct GOptionEntry * D.86719;

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


void Glib::OptionEntry::set_description(const Glib::ustring&) (struct OptionEntry * const this, const struct ustring & value)
{
  struct GOptionEntry * D.86721;
  const gchar * D.86722;
  struct GOptionEntry * D.86726;
  const gchar * iftmp.1;
  bool D.86728;
  const char * D.86732;

  D.86721 = this->gobject_;
  D.86722 = D.86721->description;
  if (D.86722 != 0B) goto <D.86723>; else goto <D.86724>;
  <D.86723>:
  D.86721 = this->gobject_;
  D.86722 = D.86721->description;
  g_free (D.86722);
  D.86721 = this->gobject_;
  D.86721->description = 0B;
  goto <D.86725>;
  <D.86724>:
  <D.86725>:
  D.86726 = Glib::OptionEntry::gobj (this);
  D.86728 = Glib::ustring::empty (value);
  if (D.86728 != 0) goto <D.86729>; else goto <D.86730>;
  <D.86729>:
  iftmp.1 = 0B;
  goto <D.86731>;
  <D.86730>:
  D.86732 = Glib::ustring::c_str (value);
  iftmp.1 = g_strdup (D.86732);
  <D.86731>:
  D.86726->description = iftmp.1;
}


void Glib::OptionEntry::set_arg_description(const Glib::ustring&) (struct OptionEntry * const this, const struct ustring & value)
{
  struct GOptionEntry * D.86736;
  const gchar * D.86737;
  struct GOptionEntry * D.86741;
  const gchar * iftmp.2;
  bool D.86743;
  const char * D.86747;

  D.86736 = this->gobject_;
  D.86737 = D.86736->arg_description;
  if (D.86737 != 0B) goto <D.86738>; else goto <D.86739>;
  <D.86738>:
  D.86736 = this->gobject_;
  D.86737 = D.86736->arg_description;
  g_free (D.86737);
  D.86736 = this->gobject_;
  D.86736->arg_description = 0B;
  goto <D.86740>;
  <D.86739>:
  <D.86740>:
  D.86741 = Glib::OptionEntry::gobj (this);
  D.86743 = Glib::ustring::empty (value);
  if (D.86743 != 0) goto <D.86744>; else goto <D.86745>;
  <D.86744>:
  iftmp.2 = 0B;
  goto <D.86746>;
  <D.86745>:
  D.86747 = Glib::ustring::c_str (value);
  iftmp.2 = g_strdup (D.86747);
  <D.86746>:
  D.86741->arg_description = iftmp.2;
}


Glib::ustring Glib::OptionEntry::get_long_name() const (const struct OptionEntry * const this)
{
  const struct GOptionEntry * D.86752;
  const gchar * D.86753;

  D.86752 = Glib::OptionEntry::gobj (this);
  D.86753 = D.86752->long_name;
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.86753); [return slot optimization]
  return <retval>;
}


const GOptionEntry* Glib::OptionEntry::gobj() const (const struct OptionEntry * const this)
{
  const struct GOptionEntry * D.86755;

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


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

  if (str != 0B) goto <D.86758>; else goto <D.86759>;
  <D.86758>:
  D.86760 = <retval>;
  Glib::ustring::ustring (D.86760, str);
  goto <D.86761>;
  <D.86759>:
  D.86760 = <retval>;
  Glib::ustring::ustring (D.86760);
  <D.86761>:
  return <retval>;
}


gchar Glib::OptionEntry::get_short_name() const (const struct OptionEntry * const this)
{
  gchar D.86763;
  const struct GOptionEntry * D.86764;

  D.86764 = Glib::OptionEntry::gobj (this);
  D.86763 = D.86764->short_name;
  return D.86763;
}


void Glib::OptionEntry::set_short_name(const gchar&) (struct OptionEntry * const this, const gchar & value)
{
  struct GOptionEntry * D.86766;
  char D.86767;

  D.86766 = Glib::OptionEntry::gobj (this);
  D.86767 = *value;
  D.86766->short_name = D.86767;
}


int Glib::OptionEntry::get_flags() const (const struct OptionEntry * const this)
{
  int D.86768;
  const struct GOptionEntry * D.86769;

  D.86769 = Glib::OptionEntry::gobj (this);
  D.86768 = D.86769->flags;
  return D.86768;
}


void Glib::OptionEntry::set_flags(const int&) (struct OptionEntry * const this, const int & value)
{
  struct GOptionEntry * D.86771;
  int D.86772;

  D.86771 = Glib::OptionEntry::gobj (this);
  D.86772 = *value;
  D.86771->flags = D.86772;
}


Glib::ustring Glib::OptionEntry::get_description() const (const struct OptionEntry * const this)
{
  const struct GOptionEntry * D.86774;
  const gchar * D.86775;

  D.86774 = Glib::OptionEntry::gobj (this);
  D.86775 = D.86774->description;
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.86775); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::OptionEntry::get_arg_description() const (const struct OptionEntry * const this)
{
  const struct GOptionEntry * D.86778;
  const gchar * D.86779;

  D.86778 = Glib::OptionEntry::gobj (this);
  D.86779 = D.86778->arg_description;
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.86779); [return slot optimization]
  return <retval>;
}