void Gio::Action::activate() (struct Action * const this)
{
  struct GAction * D.97946;

  D.97946 = Gio::Action::gobj (this);
  g_action_activate (D.97946, 0B);
}


GAction* Gio::Action::gobj() (struct Action * const this)
{
  struct GAction * D.97947;
  int (*__vtbl_ptr_type) () * D.97948;
  int (*__vtbl_ptr_type) () * D.97949;
  long int D.97950;
  sizetype D.97951;
  struct ObjectBase * D.97952;

  D.97948 = this->D.96546._vptr.Interface;
  D.97949 = D.97948 + 18446744073709551592;
  D.97950 = MEM[(long int *)D.97949];
  D.97951 = (sizetype) D.97950;
  D.97952 = this + D.97951;
  D.97947 = D.97952->gobject_;
  return D.97947;
}


Glib::RefPtr<Gio::Action> Glib::wrap(GAction*, bool) (struct GAction * object, bool take_copy)
{
  int D.97955;
  struct Action * D.97956;

  D.97955 = (int) take_copy;
  D.97956 = Glib::wrap_auto_interface<Gio::Action> (object, D.97955);
  Glib::RefPtr<Gio::Action>::RefPtr (<retval>, D.97956);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::Action; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct Action * D.97961;
  long unsigned int D.97964;
  struct Action * iftmp.0;
  struct ObjectBase * pCppObject.1;
  const struct type_info * iftmp.2;
  int (*__vtbl_ptr_type) () * D.97978;
  const char * D.97980;
  void * result.3;
  bool D.97983;
  bool D.97984;
  int (*__vtbl_ptr_type) () * D.97987;
  int (*__vtbl_ptr_type) () * D.97988;
  long int D.97989;
  sizetype D.97990;
  struct ObjectBase * D.97991;
  int (*__vtbl_ptr_type) () * D.97992;
  int (*__vtbl_ptr_type) () * D.97993;
  int (*__vtbl_ptr_type) () D.97994;
  struct ObjectBase * pCppObject;
  struct Action * result;

  if (object == 0B) goto <D.97959>; else goto <D.97960>;
  <D.97959>:
  D.97961 = 0B;
  return D.97961;
  <D.97960>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.97962>; else goto <D.97963>;
  <D.97962>:
  D.97964 = Gio::Action::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.97964);
  goto <D.97965>;
  <D.97963>:
  <D.97965>:
  result = 0B;
  if (pCppObject != 0B) goto <D.97966>; else goto <D.97967>;
  <D.97966>:
  pCppObject.1 = pCppObject;
  if (pCppObject.1 == 0B) goto <D.97970>; else goto <D.97971>;
  <D.97970>:
  iftmp.0 = 0B;
  goto <D.97972>;
  <D.97971>:
  iftmp.0 = __dynamic_cast (pCppObject.1, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
  <D.97972>:
  result = iftmp.0;
  if (result == 0B) goto <D.97973>; else goto <D.97974>;
  <D.97973>:
  if (pCppObject != 0B) goto <D.97976>; else goto <D.97977>;
  <D.97976>:
  D.97978 = pCppObject->_vptr.ObjectBase;
  iftmp.2 = MEM[(int (*__vtbl_ptr_type) () *)D.97978 + -8B];
  goto <D.97979>;
  <D.97977>:
  __cxa_bad_typeid ();
  <D.97979>:
  D.97980 = std::type_info::name (iftmp.2);
  g_log ("giomm", 16, "Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", D.97980);
  goto <D.97981>;
  <D.97974>:
  <D.97981>:
  goto <D.97982>;
  <D.97967>:
  result.3 = operator new (48);
  try
    {
      Gio::Action::Action (result.3, object);
    }
  catch
    {
      operator delete (result.3);
    }
  result = result.3;
  <D.97982>:
  D.97983 = result != 0B;
  D.97984 = D.97983 & take_copy;
  if (D.97984 != 0) goto <D.97985>; else goto <D.97986>;
  <D.97985>:
  D.97987 = result->D.96546._vptr.Interface;
  D.97988 = D.97987 + 18446744073709551592;
  D.97989 = MEM[(long int *)D.97988];
  D.97990 = (sizetype) D.97989;
  D.97991 = result + D.97990;
  D.97987 = result->D.96546._vptr.Interface;
  D.97988 = D.97987 + 18446744073709551592;
  D.97989 = MEM[(long int *)D.97988];
  D.97990 = (sizetype) D.97989;
  D.97991 = result + D.97990;
  D.97992 = D.97991->_vptr.ObjectBase;
  D.97993 = D.97992 + 16;
  D.97994 = *D.97993;
  D.97987 = result->D.96546._vptr.Interface;
  D.97988 = D.97987 + 18446744073709551592;
  D.97989 = MEM[(long int *)D.97988];
  D.97990 = (sizetype) D.97989;
  D.97991 = result + D.97990;
  OBJ_TYPE_REF(D.97994;(const struct ObjectBase)D.97991->2) (D.97991);
  goto <D.97995>;
  <D.97986>:
  <D.97995>:
  D.97961 = result;
  return D.97961;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.98003;
  const char * iftmp.4;
  const char * D.98005;
  char D.98006;

  D.98005 = this->__name;
  D.98006 = *D.98005;
  if (D.98006 == 42) goto <D.98007>; else goto <D.98008>;
  <D.98007>:
  D.98005 = this->__name;
  iftmp.4 = D.98005 + 1;
  goto <D.98009>;
  <D.98008>:
  iftmp.4 = this->__name;
  <D.98009>:
  D.98003 = iftmp.4;
  return D.98003;
}


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


const Glib::Interface_Class& Gio::Action_Class::init() (struct Action_Class * const this)
{
  long unsigned int D.98011;
  long unsigned int D.98014;
  const struct Interface_Class & D.98016;

  D.98011 = this->D.96682.D.96650.gtype_;
  if (D.98011 == 0) goto <D.98012>; else goto <D.98013>;
  <D.98012>:
  this->D.96682.D.96650.class_init_func_ = iface_init_function;
  D.98014 = g_action_get_type ();
  this->D.96682.D.96650.gtype_ = D.98014;
  goto <D.98015>;
  <D.98013>:
  <D.98015>:
  D.98016 = &this->D.96682;
  return D.98016;
}


static void Gio::Action_Class::iface_init_function(void*, void*) (void * g_iface, void * D.96833)
{
  bool retval.5;
  int retval.6;
  long int D.98024;
  long int D.98025;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[65] = "static void Gio::Action_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.98021>; else goto <D.98022>;
        <D.98021>:
        _g_boolean_var_ = 1;
        goto <D.98023>;
        <D.98022>:
        _g_boolean_var_ = 0;
        <D.98023>:
        retval.6 = _g_boolean_var_;
      }
      D.98024 = (long int) retval.6;
      D.98025 = __builtin_expect (D.98024, 1);
      retval.5 = D.98025 != 0;
      if (retval.5 != 0) goto <D.98026>; else goto <D.98027>;
      <D.98026>:
      goto <D.98028>;
      <D.98027>:
      g_assertion_message_expr ("giomm", "action.cc", 87, &__PRETTY_FUNCTION__, "klass != 0");
      <D.98028>:
    }
  }
  klass->get_name = get_name_vfunc_callback;
  klass->get_parameter_type = get_parameter_type_vfunc_callback;
  klass->get_state_type = get_state_type_vfunc_callback;
  klass->get_state_hint = get_state_hint_vfunc_callback;
  klass->get_enabled = get_enabled_vfunc_callback;
  klass->get_state = get_state_vfunc_callback;
  klass->change_state = change_state_vfunc_callback;
  klass->activate = activate_vfunc_callback;
}


static const gchar* Gio::Action_Class::get_name_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.7;
  bool iftmp.8;
  bool D.98034;
  struct CppObjectType * const iftmp.9;
  const gchar * D.98044;
  struct ustring D.96849;
  int (*__vtbl_ptr_type) () * D.98045;
  int (*__vtbl_ptr_type) () * D.98046;
  int (*__vtbl_ptr_type) () D.98047;
  const char * D.98048;
  void * D.98049;
  long unsigned int D.98052;
  struct GTypeClass * D.98053;
  void * D.98054;
  const gchar * (*<Tf824>) (struct GAction *) D.98057;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef const gchar * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98033>; else goto <D.98031>;
    <D.98033>:
    D.98034 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98034 != 0) goto <D.98035>; else goto <D.98031>;
    <D.98035>:
    iftmp.8 = 1;
    goto <D.98032>;
    <D.98031>:
    iftmp.8 = 0;
    <D.98032>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.98036>; else goto <D.98037>;
    <D.98036>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98039>; else goto <D.98040>;
      <D.98039>:
      iftmp.9 = 0B;
      goto <D.98041>;
      <D.98040>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98041>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.98042>; else goto <D.98043>;
      <D.98042>:
      try
        {
          D.98045 = obj->D.96546._vptr.Interface;
          D.98046 = D.98045 + 16;
          D.98047 = *D.98046;
          D.96849 = OBJ_TYPE_REF(D.98047;(const struct Action)obj->2) (obj); [return slot optimization]
          try
            {
              D.98048 = Glib::ustring::c_str (&D.96849);
              D.98044 = g_strdup (D.98048);
              return D.98044;
            }
          finally
            {
              Glib::ustring::~ustring (&D.96849);
              D.96849 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98049 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98049);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98050>;
      <D.98043>:
      <D.98050>:
    }
    goto <D.98051>;
    <D.98037>:
    <D.98051>:
  }
  D.98052 = Gio::Action::get_type ();
  D.98053 = MEM[(struct GTypeInstance *)self].g_class;
  D.98054 = g_type_interface_peek (D.98053, D.98052);
  base = g_type_interface_peek_parent (D.98054);
  {
    if (base != 0B) goto <D.98055>; else goto <D.98056>;
    <D.98055>:
    D.98057 = base->get_name;
    if (D.98057 != 0B) goto <D.98058>; else goto <D.98059>;
    <D.98058>:
    {
      const gchar * retval;

      D.98057 = base->get_name;
      retval = D.98057 (self);
      D.98044 = retval;
      return D.98044;
    }
    <D.98059>:
    <D.98056>:
  }
  D.98044 = 0B;
  return D.98044;
}


static const GVariantType* Gio::Action_Class::get_parameter_type_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.10;
  bool iftmp.11;
  bool D.98079;
  struct CppObjectType * const iftmp.12;
  const struct GVariantType * D.98089;
  struct VariantType D.96859;
  int (*__vtbl_ptr_type) () * D.98090;
  int (*__vtbl_ptr_type) () * D.98091;
  int (*__vtbl_ptr_type) () D.98092;
  void * D.98093;
  long unsigned int D.98096;
  struct GTypeClass * D.98097;
  void * D.98098;
  const struct GVariantType * (*<Tf828>) (struct GAction *) D.98101;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef const struct GVariantType * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98078>; else goto <D.98076>;
    <D.98078>:
    D.98079 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98079 != 0) goto <D.98080>; else goto <D.98076>;
    <D.98080>:
    iftmp.11 = 1;
    goto <D.98077>;
    <D.98076>:
    iftmp.11 = 0;
    <D.98077>:
    retval.10 = iftmp.11;
    if (retval.10 != 0) goto <D.98081>; else goto <D.98082>;
    <D.98081>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98084>; else goto <D.98085>;
      <D.98084>:
      iftmp.12 = 0B;
      goto <D.98086>;
      <D.98085>:
      iftmp.12 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98086>:
      obj = iftmp.12;
      if (obj != 0B) goto <D.98087>; else goto <D.98088>;
      <D.98087>:
      try
        {
          D.98090 = obj->D.96546._vptr.Interface;
          D.98091 = D.98090 + 24;
          D.98092 = *D.98091;
          D.96859 = OBJ_TYPE_REF(D.98092;(const struct Action)obj->3) (obj); [return slot optimization]
          try
            {
              D.98089 = Glib::VariantType::gobj_copy (&D.96859);
              return D.98089;
            }
          finally
            {
              Glib::VariantType::~VariantType (&D.96859);
              D.96859 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98093 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98093);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98094>;
      <D.98088>:
      <D.98094>:
    }
    goto <D.98095>;
    <D.98082>:
    <D.98095>:
  }
  D.98096 = Gio::Action::get_type ();
  D.98097 = MEM[(struct GTypeInstance *)self].g_class;
  D.98098 = g_type_interface_peek (D.98097, D.98096);
  base = g_type_interface_peek_parent (D.98098);
  {
    if (base != 0B) goto <D.98099>; else goto <D.98100>;
    <D.98099>:
    D.98101 = base->get_parameter_type;
    if (D.98101 != 0B) goto <D.98102>; else goto <D.98103>;
    <D.98102>:
    {
      const struct GVariantType * retval;

      D.98101 = base->get_parameter_type;
      retval = D.98101 (self);
      D.98089 = retval;
      return D.98089;
    }
    <D.98103>:
    <D.98100>:
  }
  D.98089 = 0B;
  return D.98089;
}


static const GVariantType* Gio::Action_Class::get_state_type_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.13;
  bool iftmp.14;
  bool D.98122;
  struct CppObjectType * const iftmp.15;
  const struct GVariantType * D.98132;
  struct VariantType D.96869;
  int (*__vtbl_ptr_type) () * D.98133;
  int (*__vtbl_ptr_type) () * D.98134;
  int (*__vtbl_ptr_type) () D.98135;
  void * D.98136;
  long unsigned int D.98139;
  struct GTypeClass * D.98140;
  void * D.98141;
  const struct GVariantType * (*<Tf828>) (struct GAction *) D.98144;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef const struct GVariantType * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98121>; else goto <D.98119>;
    <D.98121>:
    D.98122 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98122 != 0) goto <D.98123>; else goto <D.98119>;
    <D.98123>:
    iftmp.14 = 1;
    goto <D.98120>;
    <D.98119>:
    iftmp.14 = 0;
    <D.98120>:
    retval.13 = iftmp.14;
    if (retval.13 != 0) goto <D.98124>; else goto <D.98125>;
    <D.98124>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98127>; else goto <D.98128>;
      <D.98127>:
      iftmp.15 = 0B;
      goto <D.98129>;
      <D.98128>:
      iftmp.15 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98129>:
      obj = iftmp.15;
      if (obj != 0B) goto <D.98130>; else goto <D.98131>;
      <D.98130>:
      try
        {
          D.98133 = obj->D.96546._vptr.Interface;
          D.98134 = D.98133 + 32;
          D.98135 = *D.98134;
          D.96869 = OBJ_TYPE_REF(D.98135;(const struct Action)obj->4) (obj); [return slot optimization]
          try
            {
              D.98132 = Glib::VariantType::gobj_copy (&D.96869);
              return D.98132;
            }
          finally
            {
              Glib::VariantType::~VariantType (&D.96869);
              D.96869 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98136 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98136);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98137>;
      <D.98131>:
      <D.98137>:
    }
    goto <D.98138>;
    <D.98125>:
    <D.98138>:
  }
  D.98139 = Gio::Action::get_type ();
  D.98140 = MEM[(struct GTypeInstance *)self].g_class;
  D.98141 = g_type_interface_peek (D.98140, D.98139);
  base = g_type_interface_peek_parent (D.98141);
  {
    if (base != 0B) goto <D.98142>; else goto <D.98143>;
    <D.98142>:
    D.98144 = base->get_state_type;
    if (D.98144 != 0B) goto <D.98145>; else goto <D.98146>;
    <D.98145>:
    {
      const struct GVariantType * retval;

      D.98144 = base->get_state_type;
      retval = D.98144 (self);
      D.98132 = retval;
      return D.98132;
    }
    <D.98146>:
    <D.98143>:
  }
  D.98132 = 0B;
  return D.98132;
}


static GVariant* Gio::Action_Class::get_state_hint_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.16;
  bool iftmp.17;
  bool D.98165;
  struct CppObjectType * const iftmp.18;
  struct GVariant * D.98175;
  struct VariantBase D.96879;
  int (*__vtbl_ptr_type) () * D.98176;
  int (*__vtbl_ptr_type) () * D.98177;
  int (*__vtbl_ptr_type) () D.98178;
  void * D.98179;
  long unsigned int D.98182;
  struct GTypeClass * D.98183;
  void * D.98184;
  struct GVariant * (*<Tf82e>) (struct GAction *) D.98187;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GVariant * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98164>; else goto <D.98162>;
    <D.98164>:
    D.98165 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98165 != 0) goto <D.98166>; else goto <D.98162>;
    <D.98166>:
    iftmp.17 = 1;
    goto <D.98163>;
    <D.98162>:
    iftmp.17 = 0;
    <D.98163>:
    retval.16 = iftmp.17;
    if (retval.16 != 0) goto <D.98167>; else goto <D.98168>;
    <D.98167>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98170>; else goto <D.98171>;
      <D.98170>:
      iftmp.18 = 0B;
      goto <D.98172>;
      <D.98171>:
      iftmp.18 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98172>:
      obj = iftmp.18;
      if (obj != 0B) goto <D.98173>; else goto <D.98174>;
      <D.98173>:
      try
        {
          D.98176 = obj->D.96546._vptr.Interface;
          D.98177 = D.98176 + 40;
          D.98178 = *D.98177;
          D.96879 = OBJ_TYPE_REF(D.98178;(const struct Action)obj->5) (obj); [return slot optimization]
          try
            {
              D.98175 = Glib::VariantBase::gobj_copy (&D.96879);
              return D.98175;
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.96879);
              D.96879 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98179 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98179);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98180>;
      <D.98174>:
      <D.98180>:
    }
    goto <D.98181>;
    <D.98168>:
    <D.98181>:
  }
  D.98182 = Gio::Action::get_type ();
  D.98183 = MEM[(struct GTypeInstance *)self].g_class;
  D.98184 = g_type_interface_peek (D.98183, D.98182);
  base = g_type_interface_peek_parent (D.98184);
  {
    if (base != 0B) goto <D.98185>; else goto <D.98186>;
    <D.98185>:
    D.98187 = base->get_state_hint;
    if (D.98187 != 0B) goto <D.98188>; else goto <D.98189>;
    <D.98188>:
    {
      struct GVariant * retval;

      D.98187 = base->get_state_hint;
      retval = D.98187 (self);
      D.98175 = retval;
      return D.98175;
    }
    <D.98189>:
    <D.98186>:
  }
  D.98175 = 0B;
  return D.98175;
}


static gboolean Gio::Action_Class::get_enabled_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.19;
  bool iftmp.20;
  bool D.98208;
  struct CppObjectType * const iftmp.21;
  gboolean D.98218;
  int (*__vtbl_ptr_type) () * D.98219;
  int (*__vtbl_ptr_type) () * D.98220;
  int (*__vtbl_ptr_type) () D.98221;
  bool D.98222;
  void * D.98223;
  long unsigned int D.98226;
  struct GTypeClass * D.98227;
  void * D.98228;
  gboolean (*<Tf832>) (struct GAction *) D.98231;
  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.98207>; else goto <D.98205>;
    <D.98207>:
    D.98208 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98208 != 0) goto <D.98209>; else goto <D.98205>;
    <D.98209>:
    iftmp.20 = 1;
    goto <D.98206>;
    <D.98205>:
    iftmp.20 = 0;
    <D.98206>:
    retval.19 = iftmp.20;
    if (retval.19 != 0) goto <D.98210>; else goto <D.98211>;
    <D.98210>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98213>; else goto <D.98214>;
      <D.98213>:
      iftmp.21 = 0B;
      goto <D.98215>;
      <D.98214>:
      iftmp.21 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98215>:
      obj = iftmp.21;
      if (obj != 0B) goto <D.98216>; else goto <D.98217>;
      <D.98216>:
      try
        {
          D.98219 = obj->D.96546._vptr.Interface;
          D.98220 = D.98219 + 48;
          D.98221 = *D.98220;
          D.98222 = OBJ_TYPE_REF(D.98221;(const struct Action)obj->6) (obj);
          D.98218 = (gboolean) D.98222;
          return D.98218;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98223 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98223);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98224>;
      <D.98217>:
      <D.98224>:
    }
    goto <D.98225>;
    <D.98211>:
    <D.98225>:
  }
  D.98226 = Gio::Action::get_type ();
  D.98227 = MEM[(struct GTypeInstance *)self].g_class;
  D.98228 = g_type_interface_peek (D.98227, D.98226);
  base = g_type_interface_peek_parent (D.98228);
  {
    if (base != 0B) goto <D.98229>; else goto <D.98230>;
    <D.98229>:
    D.98231 = base->get_enabled;
    if (D.98231 != 0B) goto <D.98232>; else goto <D.98233>;
    <D.98232>:
    {
      gboolean retval;

      D.98231 = base->get_enabled;
      retval = D.98231 (self);
      D.98218 = retval;
      return D.98218;
    }
    <D.98233>:
    <D.98230>:
  }
  D.98218 = 0;
  return D.98218;
}


static GVariant* Gio::Action_Class::get_state_vfunc_callback(GAction*) (struct GAction * self)
{
  bool retval.22;
  bool iftmp.23;
  bool D.98250;
  struct CppObjectType * const iftmp.24;
  struct GVariant * D.98260;
  struct VariantBase D.96898;
  int (*__vtbl_ptr_type) () * D.98261;
  int (*__vtbl_ptr_type) () * D.98262;
  int (*__vtbl_ptr_type) () D.98263;
  void * D.98264;
  long unsigned int D.98267;
  struct GTypeClass * D.98268;
  void * D.98269;
  struct GVariant * (*<Tf82e>) (struct GAction *) D.98272;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GVariant * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98249>; else goto <D.98247>;
    <D.98249>:
    D.98250 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98250 != 0) goto <D.98251>; else goto <D.98247>;
    <D.98251>:
    iftmp.23 = 1;
    goto <D.98248>;
    <D.98247>:
    iftmp.23 = 0;
    <D.98248>:
    retval.22 = iftmp.23;
    if (retval.22 != 0) goto <D.98252>; else goto <D.98253>;
    <D.98252>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98255>; else goto <D.98256>;
      <D.98255>:
      iftmp.24 = 0B;
      goto <D.98257>;
      <D.98256>:
      iftmp.24 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98257>:
      obj = iftmp.24;
      if (obj != 0B) goto <D.98258>; else goto <D.98259>;
      <D.98258>:
      try
        {
          D.98261 = obj->D.96546._vptr.Interface;
          D.98262 = D.98261 + 56;
          D.98263 = *D.98262;
          D.96898 = OBJ_TYPE_REF(D.98263;(const struct Action)obj->7) (obj); [return slot optimization]
          try
            {
              D.98260 = Glib::VariantBase::gobj_copy (&D.96898);
              return D.98260;
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.96898);
              D.96898 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98264 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98264);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98265>;
      <D.98259>:
      <D.98265>:
    }
    goto <D.98266>;
    <D.98253>:
    <D.98266>:
  }
  D.98267 = Gio::Action::get_type ();
  D.98268 = MEM[(struct GTypeInstance *)self].g_class;
  D.98269 = g_type_interface_peek (D.98268, D.98267);
  base = g_type_interface_peek_parent (D.98269);
  {
    if (base != 0B) goto <D.98270>; else goto <D.98271>;
    <D.98270>:
    D.98272 = base->get_state;
    if (D.98272 != 0B) goto <D.98273>; else goto <D.98274>;
    <D.98273>:
    {
      struct GVariant * retval;

      D.98272 = base->get_state;
      retval = D.98272 (self);
      D.98260 = retval;
      return D.98260;
    }
    <D.98274>:
    <D.98271>:
  }
  D.98260 = 0B;
  return D.98260;
}


static void Gio::Action_Class::change_state_vfunc_callback(GAction*, GVariant*) (struct GAction * self, struct GVariant * value)
{
  bool retval.25;
  bool iftmp.26;
  bool D.98293;
  struct CppObjectType * const iftmp.27;
  int (*__vtbl_ptr_type) () * D.98303;
  int (*__vtbl_ptr_type) () * D.98304;
  int (*__vtbl_ptr_type) () D.98305;
  struct VariantBase D.96909;
  void * D.98306;
  long unsigned int D.98309;
  struct GTypeClass * D.98310;
  void * D.98311;
  void (*<Tf838>) (struct GAction *, struct GVariant *) D.98314;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98292>; else goto <D.98290>;
    <D.98292>:
    D.98293 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98293 != 0) goto <D.98294>; else goto <D.98290>;
    <D.98294>:
    iftmp.26 = 1;
    goto <D.98291>;
    <D.98290>:
    iftmp.26 = 0;
    <D.98291>:
    retval.25 = iftmp.26;
    if (retval.25 != 0) goto <D.98295>; else goto <D.98296>;
    <D.98295>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98298>; else goto <D.98299>;
      <D.98298>:
      iftmp.27 = 0B;
      goto <D.98300>;
      <D.98299>:
      iftmp.27 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98300>:
      obj = iftmp.27;
      if (obj != 0B) goto <D.98301>; else goto <D.98302>;
      <D.98301>:
      try
        {
          D.98303 = obj->D.96546._vptr.Interface;
          D.98304 = D.98303 + 64;
          D.98305 = *D.98304;
          D.96909 = Glib::wrap (value, 1); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.98305;(struct Action)obj->8) (obj, &D.96909);
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.96909);
              D.96909 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98306 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98306);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98307>;
      <D.98302>:
      <D.98307>:
    }
    goto <D.98308>;
    <D.98296>:
    <D.98308>:
  }
  D.98309 = Gio::Action::get_type ();
  D.98310 = MEM[(struct GTypeInstance *)self].g_class;
  D.98311 = g_type_interface_peek (D.98310, D.98309);
  base = g_type_interface_peek_parent (D.98311);
  if (base != 0B) goto <D.98312>; else goto <D.98313>;
  <D.98312>:
  D.98314 = base->change_state;
  if (D.98314 != 0B) goto <D.98315>; else goto <D.98316>;
  <D.98315>:
  D.98314 = base->change_state;
  D.98314 (self, value);
  goto <D.98317>;
  <D.98316>:
  <D.98317>:
  <D.98313>:
}


static void Gio::Action_Class::activate_vfunc_callback(GAction*, GVariant*) (struct GAction * self, struct GVariant * parameter)
{
  bool retval.28;
  bool iftmp.29;
  bool D.98333;
  struct CppObjectType * const iftmp.30;
  int (*__vtbl_ptr_type) () * D.98343;
  int (*__vtbl_ptr_type) () * D.98344;
  int (*__vtbl_ptr_type) () D.98345;
  struct VariantBase D.96918;
  void * D.98346;
  long unsigned int D.98349;
  struct GTypeClass * D.98350;
  void * D.98351;
  void (*<Tf838>) (struct GAction *, struct GVariant *) D.98354;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98332>; else goto <D.98330>;
    <D.98332>:
    D.98333 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98333 != 0) goto <D.98334>; else goto <D.98330>;
    <D.98334>:
    iftmp.29 = 1;
    goto <D.98331>;
    <D.98330>:
    iftmp.29 = 0;
    <D.98331>:
    retval.28 = iftmp.29;
    if (retval.28 != 0) goto <D.98335>; else goto <D.98336>;
    <D.98335>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98338>; else goto <D.98339>;
      <D.98338>:
      iftmp.30 = 0B;
      goto <D.98340>;
      <D.98339>:
      iftmp.30 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio6ActionE, -1);
      <D.98340>:
      obj = iftmp.30;
      if (obj != 0B) goto <D.98341>; else goto <D.98342>;
      <D.98341>:
      try
        {
          D.98343 = obj->D.96546._vptr.Interface;
          D.98344 = D.98343 + 72;
          D.98345 = *D.98344;
          D.96918 = Glib::wrap (parameter, 1); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.98345;(struct Action)obj->9) (obj, &D.96918);
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&D.96918);
              D.96918 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98346 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98346);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98347>;
      <D.98342>:
      <D.98347>:
    }
    goto <D.98348>;
    <D.98336>:
    <D.98348>:
  }
  D.98349 = Gio::Action::get_type ();
  D.98350 = MEM[(struct GTypeInstance *)self].g_class;
  D.98351 = g_type_interface_peek (D.98350, D.98349);
  base = g_type_interface_peek_parent (D.98351);
  if (base != 0B) goto <D.98352>; else goto <D.98353>;
  <D.98352>:
  D.98354 = base->activate;
  if (D.98354 != 0B) goto <D.98355>; else goto <D.98356>;
  <D.98355>:
  D.98354 = base->activate;
  D.98354 (self, parameter);
  goto <D.98357>;
  <D.98356>:
  <D.98357>:
  <D.98353>:
}


static Glib::ObjectBase* Gio::Action_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.98368;
  struct ObjectBase * iftmp.31;
  void * D.96924;
  void * D.98370;
  int (*__vtbl_ptr_type) () * D.98373;
  int (*__vtbl_ptr_type) () * D.98374;
  long int D.98375;
  sizetype D.98376;

  D.96924 = operator new (48);
  try
    {
      Gio::Action::Action (D.96924, object);
    }
  catch
    {
      operator delete (D.96924);
    }
  D.98370 = D.96924;
  if (D.98370 != 0B) goto <D.98371>; else goto <D.98372>;
  <D.98371>:
  D.98373 = MEM[(struct Action *)D.98370].D.96546._vptr.Interface;
  D.98374 = D.98373 + 18446744073709551592;
  D.98375 = MEM[(long int *)D.98374];
  D.98376 = (sizetype) D.98375;
  iftmp.31 = D.98370 + D.98376;
  goto <D.98377>;
  <D.98372>:
  iftmp.31 = 0B;
  <D.98377>:
  D.98368 = iftmp.31;
  return D.98368;
}


Gio::Action::Action() (struct Action * const this, const void * * __vtt_parm)
{
  struct trackable * D.98383;
  const void * * iftmp.32;
  struct ObjectBase * D.98391;
  const struct Interface_Class & D.98393;
  const void * * iftmp.33;
  struct Interface * D.98398;
  int (*__vtbl_ptr_type) () * iftmp.34;
  sizetype iftmp.35;
  int (*__vtbl_ptr_type) () * D.98406;
  int (*__vtbl_ptr_type) () * D.98407;
  long int D.98408;
  struct ObjectBase * D.98410;
  int (*__vtbl_ptr_type) () * iftmp.36;
  const void * * iftmp.37;
  const void * * iftmp.38;

  if (0 != 0) goto <D.98381>; else goto <D.98382>;
  <D.98381>:
  D.98383 = &this->D.96549;
  sigc::trackable::trackable (D.98383);
  goto <D.98384>;
  <D.98382>:
  <D.98384>:
  try
    {
      if (0 != 0) goto <D.98385>; else goto <D.98386>;
      <D.98385>:
      if (0 == 0) goto <D.98388>; else goto <D.98389>;
      <D.98388>:
      iftmp.32 = __vtt_parm + 32;
      goto <D.98390>;
      <D.98389>:
      iftmp.32 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98390>:
      D.98391 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98391, iftmp.32);
      goto <D.98392>;
      <D.98386>:
      <D.98392>:
      try
        {
          D.98393 = Gio::Action_Class::init (&action_class_);
          if (0 == 0) goto <D.98395>; else goto <D.98396>;
          <D.98395>:
          iftmp.33 = __vtt_parm + 8;
          goto <D.98397>;
          <D.98396>:
          iftmp.33 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98397>:
          D.98398 = &this->D.96546;
          Glib::Interface::Interface (D.98398, iftmp.33, D.98393);
          try
            {
              if (0 == 0) goto <D.98400>; else goto <D.98401>;
              <D.98400>:
              iftmp.34 = *__vtt_parm;
              goto <D.98402>;
              <D.98401>:
              iftmp.34 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98402>:
              this->D.96546._vptr.Interface = iftmp.34;
              if (0 == 0) goto <D.98404>; else goto <D.98405>;
              <D.98404>:
              D.98406 = this->D.96546._vptr.Interface;
              D.98407 = D.98406 + 18446744073709551592;
              D.98408 = MEM[(long int *)D.98407];
              iftmp.35 = (sizetype) D.98408;
              goto <D.98409>;
              <D.98405>:
              iftmp.35 = 8;
              <D.98409>:
              D.98410 = this + iftmp.35;
              if (0 == 0) goto <D.98412>; else goto <D.98413>;
              <D.98412>:
              iftmp.36 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98414>;
              <D.98413>:
              iftmp.36 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98414>:
              D.98410->_vptr.ObjectBase = iftmp.36;
            }
          catch
            {
              if (0 == 0) goto <D.98416>; else goto <D.98417>;
              <D.98416>:
              iftmp.37 = __vtt_parm + 8;
              goto <D.98418>;
              <D.98417>:
              iftmp.37 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98418>:
              D.98398 = &this->D.96546;
              Glib::Interface::~Interface (D.98398, iftmp.37);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98419>; else goto <D.98420>;
          <D.98419>:
          if (0 == 0) goto <D.98422>; else goto <D.98423>;
          <D.98422>:
          iftmp.38 = __vtt_parm + 32;
          goto <D.98424>;
          <D.98423>:
          iftmp.38 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98424>:
          D.98391 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98391, iftmp.38);
          goto <D.98425>;
          <D.98420>:
          <D.98425>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98426>; else goto <D.98427>;
      <D.98426>:
      D.98383 = &this->D.96549;
      sigc::trackable::~trackable (D.98383);
      goto <D.98428>;
      <D.98427>:
      <D.98428>:
    }
}


Gio::Action::Action() (struct Action * const this)
{
  struct trackable * D.98434;
  const void * * iftmp.39;
  struct ObjectBase * D.98442;
  const struct Interface_Class & D.98444;
  const void * * iftmp.40;
  struct Interface * D.98449;
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * D.98453;
  sizetype iftmp.42;
  int (*__vtbl_ptr_type) () * D.98458;
  int (*__vtbl_ptr_type) () * D.98459;
  long int D.98460;
  struct ObjectBase * D.98462;
  int (*__vtbl_ptr_type) () * iftmp.43;
  const void * * iftmp.44;
  const void * * iftmp.45;

  if (1 != 0) goto <D.98432>; else goto <D.98433>;
  <D.98432>:
  D.98434 = &this->D.96549;
  sigc::trackable::trackable (D.98434);
  goto <D.98435>;
  <D.98433>:
  <D.98435>:
  try
    {
      if (1 != 0) goto <D.98436>; else goto <D.98437>;
      <D.98436>:
      if (1 == 0) goto <D.98439>; else goto <D.98440>;
      <D.98439>:
      iftmp.39 = 32B;
      goto <D.98441>;
      <D.98440>:
      iftmp.39 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98441>:
      D.98442 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98442, iftmp.39);
      goto <D.98443>;
      <D.98437>:
      <D.98443>:
      try
        {
          D.98444 = Gio::Action_Class::init (&action_class_);
          if (1 == 0) goto <D.98446>; else goto <D.98447>;
          <D.98446>:
          iftmp.40 = 8B;
          goto <D.98448>;
          <D.98447>:
          iftmp.40 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98448>:
          D.98449 = &this->D.96546;
          Glib::Interface::Interface (D.98449, iftmp.40, D.98444);
          try
            {
              if (1 == 0) goto <D.98451>; else goto <D.98452>;
              <D.98451>:
              D.98453 = 0B;
              iftmp.41 = *D.98453;
              goto <D.98454>;
              <D.98452>:
              iftmp.41 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98454>:
              this->D.96546._vptr.Interface = iftmp.41;
              if (1 == 0) goto <D.98456>; else goto <D.98457>;
              <D.98456>:
              D.98458 = this->D.96546._vptr.Interface;
              D.98459 = D.98458 + 18446744073709551592;
              D.98460 = MEM[(long int *)D.98459];
              iftmp.42 = (sizetype) D.98460;
              goto <D.98461>;
              <D.98457>:
              iftmp.42 = 8;
              <D.98461>:
              D.98462 = this + iftmp.42;
              if (1 == 0) goto <D.98464>; else goto <D.98465>;
              <D.98464>:
              iftmp.43 = MEM[(const void * *)0B + 24B];
              goto <D.98466>;
              <D.98465>:
              iftmp.43 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98466>:
              D.98462->_vptr.ObjectBase = iftmp.43;
            }
          catch
            {
              if (1 == 0) goto <D.98468>; else goto <D.98469>;
              <D.98468>:
              iftmp.44 = 8B;
              goto <D.98470>;
              <D.98469>:
              iftmp.44 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98470>:
              D.98449 = &this->D.96546;
              Glib::Interface::~Interface (D.98449, iftmp.44);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98471>; else goto <D.98472>;
          <D.98471>:
          if (1 == 0) goto <D.98474>; else goto <D.98475>;
          <D.98474>:
          iftmp.45 = 32B;
          goto <D.98476>;
          <D.98475>:
          iftmp.45 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98476>:
          D.98442 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98442, iftmp.45);
          goto <D.98477>;
          <D.98472>:
          <D.98477>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98478>; else goto <D.98479>;
      <D.98478>:
      D.98434 = &this->D.96549;
      sigc::trackable::~trackable (D.98434);
      goto <D.98480>;
      <D.98479>:
      <D.98480>:
    }
}


Gio::Action::Action(GAction*) (struct Action * const this, const void * * __vtt_parm, struct GAction * castitem)
{
  struct trackable * D.98486;
  const void * * iftmp.46;
  struct ObjectBase * D.98494;
  const void * * iftmp.47;
  struct Interface * D.98500;
  int (*__vtbl_ptr_type) () * iftmp.48;
  sizetype iftmp.49;
  int (*__vtbl_ptr_type) () * D.98508;
  int (*__vtbl_ptr_type) () * D.98509;
  long int D.98510;
  struct ObjectBase * D.98512;
  int (*__vtbl_ptr_type) () * iftmp.50;
  const void * * iftmp.51;
  const void * * iftmp.52;

  if (0 != 0) goto <D.98484>; else goto <D.98485>;
  <D.98484>:
  D.98486 = &this->D.96549;
  sigc::trackable::trackable (D.98486);
  goto <D.98487>;
  <D.98485>:
  <D.98487>:
  try
    {
      if (0 != 0) goto <D.98488>; else goto <D.98489>;
      <D.98488>:
      if (0 == 0) goto <D.98491>; else goto <D.98492>;
      <D.98491>:
      iftmp.46 = __vtt_parm + 32;
      goto <D.98493>;
      <D.98492>:
      iftmp.46 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98493>:
      D.98494 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98494, iftmp.46);
      goto <D.98495>;
      <D.98489>:
      <D.98495>:
      try
        {
          if (0 == 0) goto <D.98497>; else goto <D.98498>;
          <D.98497>:
          iftmp.47 = __vtt_parm + 8;
          goto <D.98499>;
          <D.98498>:
          iftmp.47 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98499>:
          D.98500 = &this->D.96546;
          Glib::Interface::Interface (D.98500, iftmp.47, castitem);
          try
            {
              if (0 == 0) goto <D.98502>; else goto <D.98503>;
              <D.98502>:
              iftmp.48 = *__vtt_parm;
              goto <D.98504>;
              <D.98503>:
              iftmp.48 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98504>:
              this->D.96546._vptr.Interface = iftmp.48;
              if (0 == 0) goto <D.98506>; else goto <D.98507>;
              <D.98506>:
              D.98508 = this->D.96546._vptr.Interface;
              D.98509 = D.98508 + 18446744073709551592;
              D.98510 = MEM[(long int *)D.98509];
              iftmp.49 = (sizetype) D.98510;
              goto <D.98511>;
              <D.98507>:
              iftmp.49 = 8;
              <D.98511>:
              D.98512 = this + iftmp.49;
              if (0 == 0) goto <D.98514>; else goto <D.98515>;
              <D.98514>:
              iftmp.50 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98516>;
              <D.98515>:
              iftmp.50 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98516>:
              D.98512->_vptr.ObjectBase = iftmp.50;
            }
          catch
            {
              if (0 == 0) goto <D.98518>; else goto <D.98519>;
              <D.98518>:
              iftmp.51 = __vtt_parm + 8;
              goto <D.98520>;
              <D.98519>:
              iftmp.51 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98520>:
              D.98500 = &this->D.96546;
              Glib::Interface::~Interface (D.98500, iftmp.51);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98521>; else goto <D.98522>;
          <D.98521>:
          if (0 == 0) goto <D.98524>; else goto <D.98525>;
          <D.98524>:
          iftmp.52 = __vtt_parm + 32;
          goto <D.98526>;
          <D.98525>:
          iftmp.52 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98526>:
          D.98494 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98494, iftmp.52);
          goto <D.98527>;
          <D.98522>:
          <D.98527>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98528>; else goto <D.98529>;
      <D.98528>:
      D.98486 = &this->D.96549;
      sigc::trackable::~trackable (D.98486);
      goto <D.98530>;
      <D.98529>:
      <D.98530>:
    }
}


Gio::Action::Action(GAction*) (struct Action * const this, struct GAction * castitem)
{
  struct trackable * D.98535;
  const void * * iftmp.53;
  struct ObjectBase * D.98543;
  const void * * iftmp.54;
  struct Interface * D.98549;
  int (*__vtbl_ptr_type) () * iftmp.55;
  const void * * D.98553;
  sizetype iftmp.56;
  int (*__vtbl_ptr_type) () * D.98558;
  int (*__vtbl_ptr_type) () * D.98559;
  long int D.98560;
  struct ObjectBase * D.98562;
  int (*__vtbl_ptr_type) () * iftmp.57;
  const void * * iftmp.58;
  const void * * iftmp.59;

  if (1 != 0) goto <D.98533>; else goto <D.98534>;
  <D.98533>:
  D.98535 = &this->D.96549;
  sigc::trackable::trackable (D.98535);
  goto <D.98536>;
  <D.98534>:
  <D.98536>:
  try
    {
      if (1 != 0) goto <D.98537>; else goto <D.98538>;
      <D.98537>:
      if (1 == 0) goto <D.98540>; else goto <D.98541>;
      <D.98540>:
      iftmp.53 = 32B;
      goto <D.98542>;
      <D.98541>:
      iftmp.53 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98542>:
      D.98543 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98543, iftmp.53);
      goto <D.98544>;
      <D.98538>:
      <D.98544>:
      try
        {
          if (1 == 0) goto <D.98546>; else goto <D.98547>;
          <D.98546>:
          iftmp.54 = 8B;
          goto <D.98548>;
          <D.98547>:
          iftmp.54 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98548>:
          D.98549 = &this->D.96546;
          Glib::Interface::Interface (D.98549, iftmp.54, castitem);
          try
            {
              if (1 == 0) goto <D.98551>; else goto <D.98552>;
              <D.98551>:
              D.98553 = 0B;
              iftmp.55 = *D.98553;
              goto <D.98554>;
              <D.98552>:
              iftmp.55 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98554>:
              this->D.96546._vptr.Interface = iftmp.55;
              if (1 == 0) goto <D.98556>; else goto <D.98557>;
              <D.98556>:
              D.98558 = this->D.96546._vptr.Interface;
              D.98559 = D.98558 + 18446744073709551592;
              D.98560 = MEM[(long int *)D.98559];
              iftmp.56 = (sizetype) D.98560;
              goto <D.98561>;
              <D.98557>:
              iftmp.56 = 8;
              <D.98561>:
              D.98562 = this + iftmp.56;
              if (1 == 0) goto <D.98564>; else goto <D.98565>;
              <D.98564>:
              iftmp.57 = MEM[(const void * *)0B + 24B];
              goto <D.98566>;
              <D.98565>:
              iftmp.57 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98566>:
              D.98562->_vptr.ObjectBase = iftmp.57;
            }
          catch
            {
              if (1 == 0) goto <D.98568>; else goto <D.98569>;
              <D.98568>:
              iftmp.58 = 8B;
              goto <D.98570>;
              <D.98569>:
              iftmp.58 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98570>:
              D.98549 = &this->D.96546;
              Glib::Interface::~Interface (D.98549, iftmp.58);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98571>; else goto <D.98572>;
          <D.98571>:
          if (1 == 0) goto <D.98574>; else goto <D.98575>;
          <D.98574>:
          iftmp.59 = 32B;
          goto <D.98576>;
          <D.98575>:
          iftmp.59 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98576>:
          D.98543 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98543, iftmp.59);
          goto <D.98577>;
          <D.98572>:
          <D.98577>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98578>; else goto <D.98579>;
      <D.98578>:
      D.98535 = &this->D.96549;
      sigc::trackable::~trackable (D.98535);
      goto <D.98580>;
      <D.98579>:
      <D.98580>:
    }
}


Gio::Action::Action(const Glib::Interface_Class&) (struct Action * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.98585;
  const void * * iftmp.60;
  struct ObjectBase * D.98593;
  const void * * iftmp.61;
  struct Interface * D.98599;
  int (*__vtbl_ptr_type) () * iftmp.62;
  sizetype iftmp.63;
  int (*__vtbl_ptr_type) () * D.98607;
  int (*__vtbl_ptr_type) () * D.98608;
  long int D.98609;
  struct ObjectBase * D.98611;
  int (*__vtbl_ptr_type) () * iftmp.64;
  const void * * iftmp.65;
  const void * * iftmp.66;

  if (0 != 0) goto <D.98583>; else goto <D.98584>;
  <D.98583>:
  D.98585 = &this->D.96549;
  sigc::trackable::trackable (D.98585);
  goto <D.98586>;
  <D.98584>:
  <D.98586>:
  try
    {
      if (0 != 0) goto <D.98587>; else goto <D.98588>;
      <D.98587>:
      if (0 == 0) goto <D.98590>; else goto <D.98591>;
      <D.98590>:
      iftmp.60 = __vtt_parm + 32;
      goto <D.98592>;
      <D.98591>:
      iftmp.60 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98592>:
      D.98593 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98593, iftmp.60);
      goto <D.98594>;
      <D.98588>:
      <D.98594>:
      try
        {
          if (0 == 0) goto <D.98596>; else goto <D.98597>;
          <D.98596>:
          iftmp.61 = __vtt_parm + 8;
          goto <D.98598>;
          <D.98597>:
          iftmp.61 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98598>:
          D.98599 = &this->D.96546;
          Glib::Interface::Interface (D.98599, iftmp.61, interface_class);
          try
            {
              if (0 == 0) goto <D.98601>; else goto <D.98602>;
              <D.98601>:
              iftmp.62 = *__vtt_parm;
              goto <D.98603>;
              <D.98602>:
              iftmp.62 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98603>:
              this->D.96546._vptr.Interface = iftmp.62;
              if (0 == 0) goto <D.98605>; else goto <D.98606>;
              <D.98605>:
              D.98607 = this->D.96546._vptr.Interface;
              D.98608 = D.98607 + 18446744073709551592;
              D.98609 = MEM[(long int *)D.98608];
              iftmp.63 = (sizetype) D.98609;
              goto <D.98610>;
              <D.98606>:
              iftmp.63 = 8;
              <D.98610>:
              D.98611 = this + iftmp.63;
              if (0 == 0) goto <D.98613>; else goto <D.98614>;
              <D.98613>:
              iftmp.64 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98615>;
              <D.98614>:
              iftmp.64 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98615>:
              D.98611->_vptr.ObjectBase = iftmp.64;
            }
          catch
            {
              if (0 == 0) goto <D.98617>; else goto <D.98618>;
              <D.98617>:
              iftmp.65 = __vtt_parm + 8;
              goto <D.98619>;
              <D.98618>:
              iftmp.65 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98619>:
              D.98599 = &this->D.96546;
              Glib::Interface::~Interface (D.98599, iftmp.65);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98620>; else goto <D.98621>;
          <D.98620>:
          if (0 == 0) goto <D.98623>; else goto <D.98624>;
          <D.98623>:
          iftmp.66 = __vtt_parm + 32;
          goto <D.98625>;
          <D.98624>:
          iftmp.66 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98625>:
          D.98593 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98593, iftmp.66);
          goto <D.98626>;
          <D.98621>:
          <D.98626>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98627>; else goto <D.98628>;
      <D.98627>:
      D.98585 = &this->D.96549;
      sigc::trackable::~trackable (D.98585);
      goto <D.98629>;
      <D.98628>:
      <D.98629>:
    }
}


Gio::Action::Action(const Glib::Interface_Class&) (struct Action * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.98634;
  const void * * iftmp.67;
  struct ObjectBase * D.98642;
  const void * * iftmp.68;
  struct Interface * D.98648;
  int (*__vtbl_ptr_type) () * iftmp.69;
  const void * * D.98652;
  sizetype iftmp.70;
  int (*__vtbl_ptr_type) () * D.98657;
  int (*__vtbl_ptr_type) () * D.98658;
  long int D.98659;
  struct ObjectBase * D.98661;
  int (*__vtbl_ptr_type) () * iftmp.71;
  const void * * iftmp.72;
  const void * * iftmp.73;

  if (1 != 0) goto <D.98632>; else goto <D.98633>;
  <D.98632>:
  D.98634 = &this->D.96549;
  sigc::trackable::trackable (D.98634);
  goto <D.98635>;
  <D.98633>:
  <D.98635>:
  try
    {
      if (1 != 0) goto <D.98636>; else goto <D.98637>;
      <D.98636>:
      if (1 == 0) goto <D.98639>; else goto <D.98640>;
      <D.98639>:
      iftmp.67 = 32B;
      goto <D.98641>;
      <D.98640>:
      iftmp.67 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
      <D.98641>:
      D.98642 = &this->D.96548;
      Glib::ObjectBase::ObjectBase (D.98642, iftmp.67);
      goto <D.98643>;
      <D.98637>:
      <D.98643>:
      try
        {
          if (1 == 0) goto <D.98645>; else goto <D.98646>;
          <D.98645>:
          iftmp.68 = 8B;
          goto <D.98647>;
          <D.98646>:
          iftmp.68 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
          <D.98647>:
          D.98648 = &this->D.96546;
          Glib::Interface::Interface (D.98648, iftmp.68, interface_class);
          try
            {
              if (1 == 0) goto <D.98650>; else goto <D.98651>;
              <D.98650>:
              D.98652 = 0B;
              iftmp.69 = *D.98652;
              goto <D.98653>;
              <D.98651>:
              iftmp.69 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
              <D.98653>:
              this->D.96546._vptr.Interface = iftmp.69;
              if (1 == 0) goto <D.98655>; else goto <D.98656>;
              <D.98655>:
              D.98657 = this->D.96546._vptr.Interface;
              D.98658 = D.98657 + 18446744073709551592;
              D.98659 = MEM[(long int *)D.98658];
              iftmp.70 = (sizetype) D.98659;
              goto <D.98660>;
              <D.98656>:
              iftmp.70 = 8;
              <D.98660>:
              D.98661 = this + iftmp.70;
              if (1 == 0) goto <D.98663>; else goto <D.98664>;
              <D.98663>:
              iftmp.71 = MEM[(const void * *)0B + 24B];
              goto <D.98665>;
              <D.98664>:
              iftmp.71 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
              <D.98665>:
              D.98661->_vptr.ObjectBase = iftmp.71;
            }
          catch
            {
              if (1 == 0) goto <D.98667>; else goto <D.98668>;
              <D.98667>:
              iftmp.72 = 8B;
              goto <D.98669>;
              <D.98668>:
              iftmp.72 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
              <D.98669>:
              D.98648 = &this->D.96546;
              Glib::Interface::~Interface (D.98648, iftmp.72);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98670>; else goto <D.98671>;
          <D.98670>:
          if (1 == 0) goto <D.98673>; else goto <D.98674>;
          <D.98673>:
          iftmp.73 = 32B;
          goto <D.98675>;
          <D.98674>:
          iftmp.73 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
          <D.98675>:
          D.98642 = &this->D.96548;
          Glib::ObjectBase::~ObjectBase (D.98642, iftmp.73);
          goto <D.98676>;
          <D.98671>:
          <D.98676>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98677>; else goto <D.98678>;
      <D.98677>:
      D.98634 = &this->D.96549;
      sigc::trackable::~trackable (D.98634);
      goto <D.98679>;
      <D.98678>:
      <D.98679>:
    }
}


Gio::Action::~Action() (struct Action * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.74;
  sizetype iftmp.75;
  int (*__vtbl_ptr_type) () * D.98689;
  int (*__vtbl_ptr_type) () * D.98690;
  long int D.98691;
  struct ObjectBase * D.98693;
  int (*__vtbl_ptr_type) () * iftmp.76;
  const void * * iftmp.77;
  struct Interface * D.98702;
  int D.98703;
  const void * * iftmp.78;
  struct ObjectBase * D.98710;
  struct trackable * D.98714;
  int D.98716;

  {
    if (0 == 0) goto <D.98683>; else goto <D.98684>;
    <D.98683>:
    iftmp.74 = *__vtt_parm;
    goto <D.98685>;
    <D.98684>:
    iftmp.74 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
    <D.98685>:
    this->D.96546._vptr.Interface = iftmp.74;
    if (0 == 0) goto <D.98687>; else goto <D.98688>;
    <D.98687>:
    D.98689 = this->D.96546._vptr.Interface;
    D.98690 = D.98689 + 18446744073709551592;
    D.98691 = MEM[(long int *)D.98690];
    iftmp.75 = (sizetype) D.98691;
    goto <D.98692>;
    <D.98688>:
    iftmp.75 = 8;
    <D.98692>:
    D.98693 = this + iftmp.75;
    if (0 == 0) goto <D.98695>; else goto <D.98696>;
    <D.98695>:
    iftmp.76 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.98697>;
    <D.98696>:
    iftmp.76 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
    <D.98697>:
    D.98693->_vptr.ObjectBase = iftmp.76;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.98699>; else goto <D.98700>;
                    <D.98699>:
                    iftmp.77 = __vtt_parm + 8;
                    goto <D.98701>;
                    <D.98700>:
                    iftmp.77 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
                    <D.98701>:
                    D.98702 = &this->D.96546;
                    Glib::Interface::~Interface (D.98702, iftmp.77);
                  }
              }
            finally
              {
                D.98703 = 0;
                if (D.98703 != 0) goto <D.98704>; else goto <D.98705>;
                <D.98704>:
                if (0 == 0) goto <D.98707>; else goto <D.98708>;
                <D.98707>:
                iftmp.78 = __vtt_parm + 32;
                goto <D.98709>;
                <D.98708>:
                iftmp.78 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
                <D.98709>:
                D.98710 = &this->D.96548;
                Glib::ObjectBase::~ObjectBase (D.98710, iftmp.78);
                goto <D.98711>;
                <D.98705>:
                <D.98711>:
              }
          }
        finally
          {
            D.98703 = 0;
            if (D.98703 != 0) goto <D.98712>; else goto <D.98713>;
            <D.98712>:
            D.98714 = &this->D.96549;
            sigc::trackable::~trackable (D.98714);
            goto <D.98715>;
            <D.98713>:
            <D.98715>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96971>:
  D.98716 = 0;
  if (D.98716 != 0) goto <D.98717>; else goto <D.98718>;
  <D.98717>:
  operator delete (this);
  goto <D.98719>;
  <D.98718>:
  <D.98719>:
}


virtual Gio::Action::~Action() (struct Action * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.79;
  const void * * D.98735;
  sizetype iftmp.80;
  int (*__vtbl_ptr_type) () * D.98740;
  int (*__vtbl_ptr_type) () * D.98741;
  long int D.98742;
  struct ObjectBase * D.98744;
  int (*__vtbl_ptr_type) () * iftmp.81;
  const void * * iftmp.82;
  struct Interface * D.98753;
  int D.98754;
  const void * * iftmp.83;
  struct ObjectBase * D.98761;
  struct trackable * D.98765;
  int D.98767;

  {
    if (2 == 0) goto <D.98733>; else goto <D.98734>;
    <D.98733>:
    D.98735 = 0B;
    iftmp.79 = *D.98735;
    goto <D.98736>;
    <D.98734>:
    iftmp.79 = &MEM[(void *)&_ZTVN3Gio6ActionE + 32B];
    <D.98736>:
    this->D.96546._vptr.Interface = iftmp.79;
    if (2 == 0) goto <D.98738>; else goto <D.98739>;
    <D.98738>:
    D.98740 = this->D.96546._vptr.Interface;
    D.98741 = D.98740 + 18446744073709551592;
    D.98742 = MEM[(long int *)D.98741];
    iftmp.80 = (sizetype) D.98742;
    goto <D.98743>;
    <D.98739>:
    iftmp.80 = 8;
    <D.98743>:
    D.98744 = this + iftmp.80;
    if (2 == 0) goto <D.98746>; else goto <D.98747>;
    <D.98746>:
    iftmp.81 = MEM[(const void * *)0B + 24B];
    goto <D.98748>;
    <D.98747>:
    iftmp.81 = &MEM[(void *)&_ZTVN3Gio6ActionE + 176B];
    <D.98748>:
    D.98744->_vptr.ObjectBase = iftmp.81;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.98750>; else goto <D.98751>;
                    <D.98750>:
                    iftmp.82 = 8B;
                    goto <D.98752>;
                    <D.98751>:
                    iftmp.82 = &MEM[(void *)&_ZTTN3Gio6ActionE + 8B];
                    <D.98752>:
                    D.98753 = &this->D.96546;
                    Glib::Interface::~Interface (D.98753, iftmp.82);
                  }
              }
            finally
              {
                D.98754 = 2;
                if (D.98754 != 0) goto <D.98755>; else goto <D.98756>;
                <D.98755>:
                if (2 == 0) goto <D.98758>; else goto <D.98759>;
                <D.98758>:
                iftmp.83 = 32B;
                goto <D.98760>;
                <D.98759>:
                iftmp.83 = &MEM[(void *)&_ZTTN3Gio6ActionE + 32B];
                <D.98760>:
                D.98761 = &this->D.96548;
                Glib::ObjectBase::~ObjectBase (D.98761, iftmp.83);
                goto <D.98762>;
                <D.98756>:
                <D.98762>:
              }
          }
        finally
          {
            D.98754 = 2;
            if (D.98754 != 0) goto <D.98763>; else goto <D.98764>;
            <D.98763>:
            D.98765 = &this->D.96549;
            sigc::trackable::~trackable (D.98765);
            goto <D.98766>;
            <D.98764>:
            <D.98766>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96974>:
  D.98767 = 0;
  if (D.98767 != 0) goto <D.98768>; else goto <D.98769>;
  <D.98768>:
  operator delete (this);
  goto <D.98770>;
  <D.98769>:
  <D.98770>:
}


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


static void Gio::Action::add_interface(GType) (GType gtype_implementer)
{
  const struct Interface_Class & D.98783;

  D.98783 = Gio::Action_Class::init (&action_class_);
  Glib::Interface_Class::add_interface (D.98783, gtype_implementer);
}


static GType Gio::Action::get_type() ()
{
  GType D.98785;
  const struct Interface_Class & D.98786;
  const struct Class * D.98787;

  D.98786 = Gio::Action_Class::init (&action_class_);
  D.98787 = &D.98786->D.96650;
  D.98785 = Glib::Class::get_type (D.98787);
  return D.98785;
}


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

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


static GType Gio::Action::get_base_type() ()
{
  GType D.98792;

  D.98792 = g_action_get_type ();
  return D.98792;
}


Glib::ustring Gio::Action::get_name() const (const struct Action * const this)
{
  const struct GAction * D.98796;
  const gchar * D.98797;

  D.98796 = Gio::Action::gobj (this);
  D.98797 = g_action_get_name (D.98796);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.98797); [return slot optimization]
  return <retval>;
}


const GAction* Gio::Action::gobj() const (const struct Action * const this)
{
  const struct GAction * D.98800;
  int (*__vtbl_ptr_type) () * D.98801;
  int (*__vtbl_ptr_type) () * D.98802;
  long int D.98803;
  sizetype D.98804;
  const struct ObjectBase * D.98805;

  D.98801 = this->D.96546._vptr.Interface;
  D.98802 = D.98801 + 18446744073709551592;
  D.98803 = MEM[(long int *)D.98802];
  D.98804 = (sizetype) D.98803;
  D.98805 = this + D.98804;
  D.98800 = D.98805->gobject_;
  return D.98800;
}


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

  if (str != 0B) goto <D.98808>; else goto <D.98809>;
  <D.98808>:
  D.98810 = <retval>;
  Glib::ustring::ustring (D.98810, str);
  goto <D.98811>;
  <D.98809>:
  D.98810 = <retval>;
  Glib::ustring::ustring (D.98810);
  <D.98811>:
  return <retval>;
}


Glib::VariantType Gio::Action::get_parameter_type() const (const struct Action * const this)
{
  const struct GAction * D.98814;
  const struct GVariantType * D.98815;

  D.98814 = Gio::Action::gobj (this);
  D.98815 = g_action_get_parameter_type (D.98814);
  *<retval> = Glib::wrap (D.98815, 1); [return slot optimization]
  return <retval>;
}


Glib::VariantType Gio::Action::get_state_type() const (const struct Action * const this)
{
  const struct GAction * D.98819;
  const struct GVariantType * D.98820;

  D.98819 = Gio::Action::gobj (this);
  D.98820 = g_action_get_state_type (D.98819);
  *<retval> = Glib::wrap (D.98820, 1); [return slot optimization]
  return <retval>;
}


Glib::VariantBase Gio::Action::get_state_hint_variant() const (const struct Action * const this)
{
  const struct GAction * D.98824;
  struct GVariant * D.98825;

  D.98824 = Gio::Action::gobj (this);
  D.98825 = g_action_get_state_hint (D.98824);
  *<retval> = Glib::wrap (D.98825, 0); [return slot optimization]
  return <retval>;
}


bool Gio::Action::get_enabled() const (const struct Action * const this)
{
  bool D.98828;
  const struct GAction * D.98829;
  int D.98830;

  D.98829 = Gio::Action::gobj (this);
  D.98830 = g_action_get_enabled (D.98829);
  D.98828 = D.98830 != 0;
  return D.98828;
}


void Gio::Action::change_state_variant(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & value)
{
  const struct GVariant * D.98833;
  struct GAction * D.98834;

  D.98833 = Glib::VariantBase::gobj (value);
  D.98834 = Gio::Action::gobj (this);
  g_action_change_state (D.98834, D.98833);
}


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

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


void Gio::Action::change_state(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & value)
{
  const struct GVariant * D.98837;
  struct GAction * D.98838;

  D.98837 = Glib::VariantBase::gobj (value);
  D.98838 = Gio::Action::gobj (this);
  g_action_change_state (D.98838, D.98837);
}


Glib::VariantBase Gio::Action::get_state_variant() const (const struct Action * const this)
{
  const struct GAction * D.98840;
  struct GVariant * D.98841;

  D.98840 = Gio::Action::gobj (this);
  D.98841 = g_action_get_state (D.98840);
  *<retval> = Glib::wrap (D.98841, 0); [return slot optimization]
  return <retval>;
}


void Gio::Action::activate_variant(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & parameter)
{
  const struct GVariant * D.98844;
  struct GAction * D.98845;

  D.98844 = Glib::VariantBase::gobj (parameter);
  D.98845 = Gio::Action::gobj (this);
  g_action_activate (D.98845, D.98844);
}


void Gio::Action::activate(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & parameter)
{
  const struct GVariant * D.98846;
  struct GAction * D.98847;

  D.98846 = Glib::VariantBase::gobj (parameter);
  D.98847 = Gio::Action::gobj (this);
  g_action_activate (D.98847, D.98846);
}


static bool Gio::Action::name_is_valid(const Glib::ustring&) (const struct ustring & action_name)
{
  bool D.98848;
  const char * D.98849;
  int D.98850;

  D.98849 = Glib::ustring::c_str (action_name);
  D.98850 = g_action_name_is_valid (D.98849);
  D.98848 = D.98850 != 0;
  return D.98848;
}


static void Gio::Action::parse_detailed_name_variant(const Glib::ustring&, Glib::ustring&, Glib::VariantBase&) (const struct ustring & detailed_name, struct ustring & action_name, struct VariantBase & target_value)
{
  const char * D.98854;
  struct GError * gerror.84;
  struct ustring D.97046;
  gchar * g_action_name.85;
  struct VariantBase D.97047;
  struct GVariant * g_target_value.86;
  struct GError * gerror;
  gchar * g_action_name;
  struct GVariant * g_target_value;

  try
    {
      gerror = 0B;
      g_action_name = 0B;
      g_target_value = 0B;
      D.98854 = Glib::ustring::c_str (detailed_name);
      g_action_parse_detailed_name (D.98854, &g_action_name, &g_target_value, &gerror);
      gerror.84 = gerror;
      if (gerror.84 != 0B) goto <D.98856>; else goto <D.98857>;
      <D.98856>:
      gerror.84 = gerror;
      Glib::Error::throw_exception (gerror.84);
      <D.98857>:
      g_action_name.85 = g_action_name;
      D.97046 = Glib::convert_return_gchar_ptr_to_ustring (g_action_name.85); [return slot optimization]
      try
        {
          Glib::ustring::operator= (action_name, &D.97046);
        }
      finally
        {
          Glib::ustring::~ustring (&D.97046);
          D.97046 = {CLOBBER};
        }
      g_target_value.86 = g_target_value;
      D.97047 = Glib::wrap (g_target_value.86, 0); [return slot optimization]
      try
        {
          Glib::VariantBase::operator= (target_value, &D.97047);
        }
      finally
        {
          Glib::VariantBase::~VariantBase (&D.97047);
          D.97047 = {CLOBBER};
        }
    }
  finally
    {
      gerror = {CLOBBER};
      g_action_name = {CLOBBER};
      g_target_value = {CLOBBER};
    }
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.87;
  char * D.98870;
  struct ustring * D.98871;

  cleanup.87 = 0;
  try
    {
      if (str != 0B) goto <D.98865>; else goto <D.98866>;
      <D.98865>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.87 = 1;
      D.98870 = Glib::ScopedPtr<char>::get (&D.78974);
      D.98871 = <retval>;
      Glib::ustring::ustring (D.98871, D.98870);
      goto <D.98872>;
      <D.98866>:
      D.98871 = <retval>;
      Glib::ustring::ustring (D.98871);
      <D.98872>:
      return <retval>;
    }
  finally
    {
      if (cleanup.87 != 0) goto <D.98868>; else goto <D.98869>;
      <D.98868>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.98869>:
    }
}


Glib::ScopedPtr<T>::ScopedPtr(T*) [with T = char] (struct ScopedPtr * const this, char * ptr)
{
  this->ptr_ = ptr;
}


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

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


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

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


static Glib::ustring Gio::Action::print_detailed_name_variant(const Glib::ustring&, const Glib::VariantBase&) (const struct ustring & action_name, const struct VariantBase & target_value)
{
  const struct GVariant * D.98883;
  const char * D.98884;
  gchar * D.98885;

  D.98883 = Glib::VariantBase::gobj (target_value);
  D.98884 = Glib::ustring::c_str (action_name);
  D.98885 = g_action_print_detailed_name (D.98884, D.98883);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.98885); [return slot optimization]
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Action::property_enabled() const (const struct Action * const this)
{
  int (*__vtbl_ptr_type) () * D.98890;
  int (*__vtbl_ptr_type) () * D.98891;
  long int D.98892;
  sizetype D.98893;
  const struct ObjectBase * D.98894;

  D.98890 = this->D.96546._vptr.Interface;
  D.98891 = D.98890 + 18446744073709551592;
  D.98892 = MEM[(long int *)D.98891];
  D.98893 = (sizetype) D.98892;
  D.98894 = this + D.98893;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.98894, "enabled");
  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.98896;

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


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::Action::property_name() const (const struct Action * const this)
{
  int (*__vtbl_ptr_type) () * D.98898;
  int (*__vtbl_ptr_type) () * D.98899;
  long int D.98900;
  sizetype D.98901;
  const struct ObjectBase * D.98902;

  D.98898 = this->D.96546._vptr.Interface;
  D.98899 = D.98898 + 18446744073709551592;
  D.98900 = MEM[(long int *)D.98899];
  D.98901 = (sizetype) D.98900;
  D.98902 = this + D.98901;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.98902, "name");
  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.98904;

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


Glib::PropertyProxy_ReadOnly<Glib::VariantType> Gio::Action::property_parameter_type() const (const struct Action * const this)
{
  int (*__vtbl_ptr_type) () * D.98906;
  int (*__vtbl_ptr_type) () * D.98907;
  long int D.98908;
  sizetype D.98909;
  const struct ObjectBase * D.98910;

  D.98906 = this->D.96546._vptr.Interface;
  D.98907 = D.98906 + 18446744073709551592;
  D.98908 = MEM[(long int *)D.98907];
  D.98909 = (sizetype) D.98908;
  D.98910 = this + D.98909;
  Glib::PropertyProxy_ReadOnly<Glib::VariantType>::PropertyProxy_ReadOnly (<retval>, D.98910, "parameter-type");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::VariantBase> Gio::Action::property_state() const (const struct Action * const this)
{
  int (*__vtbl_ptr_type) () * D.98914;
  int (*__vtbl_ptr_type) () * D.98915;
  long int D.98916;
  sizetype D.98917;
  const struct ObjectBase * D.98918;

  D.98914 = this->D.96546._vptr.Interface;
  D.98915 = D.98914 + 18446744073709551592;
  D.98916 = MEM[(long int *)D.98915];
  D.98917 = (sizetype) D.98916;
  D.98918 = this + D.98917;
  Glib::PropertyProxy_ReadOnly<Glib::VariantBase>::PropertyProxy_ReadOnly (<retval>, D.98918, "state");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::VariantType> Gio::Action::property_state_type() const (const struct Action * const this)
{
  int (*__vtbl_ptr_type) () * D.98922;
  int (*__vtbl_ptr_type) () * D.98923;
  long int D.98924;
  sizetype D.98925;
  const struct ObjectBase * D.98926;

  D.98922 = this->D.96546._vptr.Interface;
  D.98923 = D.98922 + 18446744073709551592;
  D.98924 = MEM[(long int *)D.98923];
  D.98925 = (sizetype) D.98924;
  D.98926 = this + D.98925;
  Glib::PropertyProxy_ReadOnly<Glib::VariantType>::PropertyProxy_ReadOnly (<retval>, D.98926, "state-type");
  return <retval>;
}


virtual Glib::ustring Gio::Action::get_name_vfunc() const (const struct Action * const this)
{
  long unsigned int D.98929;
  int (*__vtbl_ptr_type) () * D.98930;
  int (*__vtbl_ptr_type) () * D.98931;
  long int D.98932;
  sizetype D.98933;
  const struct ObjectBase * D.98934;
  struct GObject * D.98935;
  struct GTypeClass * D.98936;
  void * D.98937;
  const gchar * (*<Tf824>) (struct GAction *) D.98940;
  const struct GAction * D.98943;
  const gchar * D.98944;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.98929 = Gio::Action::get_type ();
  D.98930 = this->D.96546._vptr.Interface;
  D.98931 = D.98930 + 18446744073709551592;
  D.98932 = MEM[(long int *)D.98931];
  D.98933 = (sizetype) D.98932;
  D.98934 = this + D.98933;
  D.98935 = D.98934->gobject_;
  D.98936 = MEM[(struct GTypeInstance *)D.98935].g_class;
  D.98937 = g_type_interface_peek (D.98936, D.98929);
  base = g_type_interface_peek_parent (D.98937);
  {
    if (base != 0B) goto <D.98938>; else goto <D.98939>;
    <D.98938>:
    D.98940 = base->get_name;
    if (D.98940 != 0B) goto <D.98941>; else goto <D.98942>;
    <D.98941>:
    {
      struct ustring retval;

      try
        {
          D.98940 = base->get_name;
          D.98943 = Gio::Action::gobj (this);
          D.98944 = D.98940 (D.98943);
          retval = Glib::convert_const_gchar_ptr_to_ustring (D.98944); [return slot optimization]
          try
            {
              Glib::ustring::ustring (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::ustring::~ustring (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.98942>:
    <D.98939>:
  }
  Glib::ustring::ustring (<retval>);
  return <retval>;
}


virtual Glib::VariantType Gio::Action::get_parameter_type_vfunc() const (const struct Action * const this)
{
  long unsigned int D.98955;
  int (*__vtbl_ptr_type) () * D.98956;
  int (*__vtbl_ptr_type) () * D.98957;
  long int D.98958;
  sizetype D.98959;
  const struct ObjectBase * D.98960;
  struct GObject * D.98961;
  struct GTypeClass * D.98962;
  void * D.98963;
  const struct GVariantType * (*<Tf828>) (struct GAction *) D.98966;
  const struct GAction * D.98969;
  const struct GVariantType * D.98970;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.98955 = Gio::Action::get_type ();
  D.98956 = this->D.96546._vptr.Interface;
  D.98957 = D.98956 + 18446744073709551592;
  D.98958 = MEM[(long int *)D.98957];
  D.98959 = (sizetype) D.98958;
  D.98960 = this + D.98959;
  D.98961 = D.98960->gobject_;
  D.98962 = MEM[(struct GTypeInstance *)D.98961].g_class;
  D.98963 = g_type_interface_peek (D.98962, D.98955);
  base = g_type_interface_peek_parent (D.98963);
  {
    if (base != 0B) goto <D.98964>; else goto <D.98965>;
    <D.98964>:
    D.98966 = base->get_parameter_type;
    if (D.98966 != 0B) goto <D.98967>; else goto <D.98968>;
    <D.98967>:
    {
      struct VariantType retval;

      try
        {
          D.98966 = base->get_parameter_type;
          D.98969 = Gio::Action::gobj (this);
          D.98970 = D.98966 (D.98969);
          retval = Glib::wrap (D.98970, 1); [return slot optimization]
          try
            {
              Glib::VariantType::VariantType (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::VariantType::~VariantType (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.98968>:
    <D.98965>:
  }
  Glib::VariantType::VariantType (<retval>);
  return <retval>;
}


virtual Glib::VariantType Gio::Action::get_state_type_vfunc() const (const struct Action * const this)
{
  long unsigned int D.98981;
  int (*__vtbl_ptr_type) () * D.98982;
  int (*__vtbl_ptr_type) () * D.98983;
  long int D.98984;
  sizetype D.98985;
  const struct ObjectBase * D.98986;
  struct GObject * D.98987;
  struct GTypeClass * D.98988;
  void * D.98989;
  const struct GVariantType * (*<Tf828>) (struct GAction *) D.98992;
  const struct GAction * D.98995;
  const struct GVariantType * D.98996;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.98981 = Gio::Action::get_type ();
  D.98982 = this->D.96546._vptr.Interface;
  D.98983 = D.98982 + 18446744073709551592;
  D.98984 = MEM[(long int *)D.98983];
  D.98985 = (sizetype) D.98984;
  D.98986 = this + D.98985;
  D.98987 = D.98986->gobject_;
  D.98988 = MEM[(struct GTypeInstance *)D.98987].g_class;
  D.98989 = g_type_interface_peek (D.98988, D.98981);
  base = g_type_interface_peek_parent (D.98989);
  {
    if (base != 0B) goto <D.98990>; else goto <D.98991>;
    <D.98990>:
    D.98992 = base->get_state_type;
    if (D.98992 != 0B) goto <D.98993>; else goto <D.98994>;
    <D.98993>:
    {
      struct VariantType retval;

      try
        {
          D.98992 = base->get_state_type;
          D.98995 = Gio::Action::gobj (this);
          D.98996 = D.98992 (D.98995);
          retval = Glib::wrap (D.98996, 1); [return slot optimization]
          try
            {
              Glib::VariantType::VariantType (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::VariantType::~VariantType (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.98994>:
    <D.98991>:
  }
  Glib::VariantType::VariantType (<retval>);
  return <retval>;
}


virtual Glib::VariantBase Gio::Action::get_state_hint_vfunc() const (const struct Action * const this)
{
  long unsigned int D.99007;
  int (*__vtbl_ptr_type) () * D.99008;
  int (*__vtbl_ptr_type) () * D.99009;
  long int D.99010;
  sizetype D.99011;
  const struct ObjectBase * D.99012;
  struct GObject * D.99013;
  struct GTypeClass * D.99014;
  void * D.99015;
  struct GVariant * (*<Tf82e>) (struct GAction *) D.99018;
  const struct GAction * D.99021;
  struct GVariant * D.99022;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.99007 = Gio::Action::get_type ();
  D.99008 = this->D.96546._vptr.Interface;
  D.99009 = D.99008 + 18446744073709551592;
  D.99010 = MEM[(long int *)D.99009];
  D.99011 = (sizetype) D.99010;
  D.99012 = this + D.99011;
  D.99013 = D.99012->gobject_;
  D.99014 = MEM[(struct GTypeInstance *)D.99013].g_class;
  D.99015 = g_type_interface_peek (D.99014, D.99007);
  base = g_type_interface_peek_parent (D.99015);
  {
    if (base != 0B) goto <D.99016>; else goto <D.99017>;
    <D.99016>:
    D.99018 = base->get_state_hint;
    if (D.99018 != 0B) goto <D.99019>; else goto <D.99020>;
    <D.99019>:
    {
      struct VariantBase retval;

      try
        {
          D.99018 = base->get_state_hint;
          D.99021 = Gio::Action::gobj (this);
          D.99022 = D.99018 (D.99021);
          retval = Glib::wrap (D.99022, 0); [return slot optimization]
          try
            {
              Glib::VariantBase::VariantBase (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.99020>:
    <D.99017>:
  }
  Glib::VariantBase::VariantBase (<retval>);
  return <retval>;
}


virtual bool Gio::Action::get_enabled_vfunc() const (const struct Action * const this)
{
  long unsigned int D.99032;
  int (*__vtbl_ptr_type) () * D.99033;
  int (*__vtbl_ptr_type) () * D.99034;
  long int D.99035;
  sizetype D.99036;
  const struct ObjectBase * D.99037;
  struct GObject * D.99038;
  struct GTypeClass * D.99039;
  void * D.99040;
  gboolean (*<Tf832>) (struct GAction *) D.99043;
  const struct GAction * D.99046;
  int D.99047;
  bool D.99048;
  struct BaseClassType * const base;
  typedef RType RType;

  D.99032 = Gio::Action::get_type ();
  D.99033 = this->D.96546._vptr.Interface;
  D.99034 = D.99033 + 18446744073709551592;
  D.99035 = MEM[(long int *)D.99034];
  D.99036 = (sizetype) D.99035;
  D.99037 = this + D.99036;
  D.99038 = D.99037->gobject_;
  D.99039 = MEM[(struct GTypeInstance *)D.99038].g_class;
  D.99040 = g_type_interface_peek (D.99039, D.99032);
  base = g_type_interface_peek_parent (D.99040);
  {
    if (base != 0B) goto <D.99041>; else goto <D.99042>;
    <D.99041>:
    D.99043 = base->get_enabled;
    if (D.99043 != 0B) goto <D.99044>; else goto <D.99045>;
    <D.99044>:
    {
      bool retval;

      D.99043 = base->get_enabled;
      D.99046 = Gio::Action::gobj (this);
      D.99047 = D.99043 (D.99046);
      retval = D.99047 != 0;
      D.99048 = retval;
      return D.99048;
    }
    <D.99045>:
    <D.99042>:
  }
  D.99048 = 0;
  return D.99048;
}


virtual Glib::VariantBase Gio::Action::get_state_vfunc() const (const struct Action * const this)
{
  long unsigned int D.99055;
  int (*__vtbl_ptr_type) () * D.99056;
  int (*__vtbl_ptr_type) () * D.99057;
  long int D.99058;
  sizetype D.99059;
  const struct ObjectBase * D.99060;
  struct GObject * D.99061;
  struct GTypeClass * D.99062;
  void * D.99063;
  struct GVariant * (*<Tf82e>) (struct GAction *) D.99066;
  const struct GAction * D.99069;
  struct GVariant * D.99070;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.99055 = Gio::Action::get_type ();
  D.99056 = this->D.96546._vptr.Interface;
  D.99057 = D.99056 + 18446744073709551592;
  D.99058 = MEM[(long int *)D.99057];
  D.99059 = (sizetype) D.99058;
  D.99060 = this + D.99059;
  D.99061 = D.99060->gobject_;
  D.99062 = MEM[(struct GTypeInstance *)D.99061].g_class;
  D.99063 = g_type_interface_peek (D.99062, D.99055);
  base = g_type_interface_peek_parent (D.99063);
  {
    if (base != 0B) goto <D.99064>; else goto <D.99065>;
    <D.99064>:
    D.99066 = base->get_state;
    if (D.99066 != 0B) goto <D.99067>; else goto <D.99068>;
    <D.99067>:
    {
      struct VariantBase retval;

      try
        {
          D.99066 = base->get_state;
          D.99069 = Gio::Action::gobj (this);
          D.99070 = D.99066 (D.99069);
          retval = Glib::wrap (D.99070, 0); [return slot optimization]
          try
            {
              Glib::VariantBase::VariantBase (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.99068>:
    <D.99065>:
  }
  Glib::VariantBase::VariantBase (<retval>);
  return <retval>;
}


virtual void Gio::Action::change_state_vfunc(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & value)
{
  long unsigned int D.99080;
  int (*__vtbl_ptr_type) () * D.99081;
  int (*__vtbl_ptr_type) () * D.99082;
  long int D.99083;
  sizetype D.99084;
  struct ObjectBase * D.99085;
  struct GObject * D.99086;
  struct GTypeClass * D.99087;
  void * D.99088;
  void (*<Tf838>) (struct GAction *, struct GVariant *) D.99091;
  const struct GVariant * D.99094;
  struct GAction * D.99095;
  struct BaseClassType * const base;

  D.99080 = Gio::Action::get_type ();
  D.99081 = this->D.96546._vptr.Interface;
  D.99082 = D.99081 + 18446744073709551592;
  D.99083 = MEM[(long int *)D.99082];
  D.99084 = (sizetype) D.99083;
  D.99085 = this + D.99084;
  D.99086 = D.99085->gobject_;
  D.99087 = MEM[(struct GTypeInstance *)D.99086].g_class;
  D.99088 = g_type_interface_peek (D.99087, D.99080);
  base = g_type_interface_peek_parent (D.99088);
  if (base != 0B) goto <D.99089>; else goto <D.99090>;
  <D.99089>:
  D.99091 = base->change_state;
  if (D.99091 != 0B) goto <D.99092>; else goto <D.99093>;
  <D.99092>:
  D.99091 = base->change_state;
  D.99094 = Glib::VariantBase::gobj (value);
  D.99095 = Gio::Action::gobj (this);
  D.99091 (D.99095, D.99094);
  goto <D.99096>;
  <D.99093>:
  <D.99096>:
  <D.99090>:
}


virtual void Gio::Action::activate_vfunc(const Glib::VariantBase&) (struct Action * const this, const struct VariantBase & parameter)
{
  long unsigned int D.99100;
  int (*__vtbl_ptr_type) () * D.99101;
  int (*__vtbl_ptr_type) () * D.99102;
  long int D.99103;
  sizetype D.99104;
  struct ObjectBase * D.99105;
  struct GObject * D.99106;
  struct GTypeClass * D.99107;
  void * D.99108;
  void (*<Tf838>) (struct GAction *, struct GVariant *) D.99111;
  const struct GVariant * D.99114;
  struct GAction * D.99115;
  struct BaseClassType * const base;

  D.99100 = Gio::Action::get_type ();
  D.99101 = this->D.96546._vptr.Interface;
  D.99102 = D.99101 + 18446744073709551592;
  D.99103 = MEM[(long int *)D.99102];
  D.99104 = (sizetype) D.99103;
  D.99105 = this + D.99104;
  D.99106 = D.99105->gobject_;
  D.99107 = MEM[(struct GTypeInstance *)D.99106].g_class;
  D.99108 = g_type_interface_peek (D.99107, D.99100);
  base = g_type_interface_peek_parent (D.99108);
  if (base != 0B) goto <D.99109>; else goto <D.99110>;
  <D.99109>:
  D.99111 = base->activate;
  if (D.99111 != 0B) goto <D.99112>; else goto <D.99113>;
  <D.99112>:
  D.99111 = base->activate;
  D.99114 = Glib::VariantBase::gobj (parameter);
  D.99115 = Gio::Action::gobj (this);
  D.99111 (D.99115, D.99114);
  goto <D.99116>;
  <D.99113>:
  <D.99116>:
  <D.99110>:
}