Glib::RefPtr<Glib::ObjectBase> Gio::AsyncResult::get_source_object_base() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.98071;
  struct GObject * cobj;
  struct ObjectBase * cppobj;

  D.98071 = Gio::AsyncResult::gobj (this);
  cobj = g_async_result_get_source_object (D.98071);
  cppobj = Glib::wrap_auto (cobj, 0);
  Glib::RefPtr<Glib::ObjectBase>::RefPtr (<retval>, cppobj);
  return <retval>;
}


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.98075;
  int (*__vtbl_ptr_type) () * D.98076;
  int (*__vtbl_ptr_type) () * D.98077;
  long int D.98078;
  sizetype D.98079;
  struct ObjectBase * D.98080;

  D.98076 = this->D.86030._vptr.Interface;
  D.98077 = D.98076 + 18446744073709551592;
  D.98078 = MEM[(long int *)D.98077];
  D.98079 = (sizetype) D.98078;
  D.98080 = this + D.98079;
  D.98075 = D.98080->gobject_;
  return D.98075;
}


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


Glib::RefPtr<const Glib::ObjectBase> Gio::AsyncResult::get_source_object_base() const (const struct AsyncResult * const this)
{
  struct RefPtr D.96765;

  D.96765 = Gio::AsyncResult::get_source_object_base (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Glib::ObjectBase>::RefPtr<Glib::ObjectBase> (<retval>, &D.96765);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Glib::ObjectBase>::~RefPtr (&D.96765);
      D.96765 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Glib::ObjectBase; T_CppObject = const Glib::ObjectBase] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct ObjectBase * D.98087;
  const struct ObjectBase * D.98088;
  int (*__vtbl_ptr_type) () * D.98091;
  int (*__vtbl_ptr_type) () * D.98092;
  int (*__vtbl_ptr_type) () D.98093;

  D.98087 = Glib::RefPtr<Glib::ObjectBase>::operator-> (src);
  this->pCppObject_ = D.98087;
  D.98088 = this->pCppObject_;
  if (D.98088 != 0B) goto <D.98089>; else goto <D.98090>;
  <D.98089>:
  D.98088 = this->pCppObject_;
  D.98088 = this->pCppObject_;
  D.98091 = D.98088->_vptr.ObjectBase;
  D.98092 = D.98091 + 16;
  D.98093 = *D.98092;
  D.98088 = this->pCppObject_;
  OBJ_TYPE_REF(D.98093;(const struct ObjectBase)D.98088->2) (D.98088);
  goto <D.98094>;
  <D.98090>:
  <D.98094>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Glib::ObjectBase] (struct RefPtr * const this)
{
  struct ObjectBase * D.98097;
  int (*__vtbl_ptr_type) () * D.98100;
  int (*__vtbl_ptr_type) () * D.98101;
  int (*__vtbl_ptr_type) () D.98102;

  {
    try
      {
        D.98097 = this->pCppObject_;
        if (D.98097 != 0B) goto <D.98098>; else goto <D.98099>;
        <D.98098>:
        D.98097 = this->pCppObject_;
        D.98097 = this->pCppObject_;
        D.98100 = D.98097->_vptr.ObjectBase;
        D.98101 = D.98100 + 24;
        D.98102 = *D.98101;
        D.98097 = this->pCppObject_;
        OBJ_TYPE_REF(D.98102;(const struct ObjectBase)D.98097->3) (D.98097);
        goto <D.98103>;
        <D.98099>:
        <D.98103>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97675>:
}


Glib::RefPtr<Gio::AsyncResult> Glib::wrap(GAsyncResult*, bool) (struct GAsyncResult * object, bool take_copy)
{
  int D.98106;
  struct AsyncResult * D.98107;

  D.98106 = (int) take_copy;
  D.98107 = Glib::wrap_auto_interface<Gio::AsyncResult> (object, D.98106);
  Glib::RefPtr<Gio::AsyncResult>::RefPtr (<retval>, D.98107);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::AsyncResult; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct AsyncResult * D.98112;
  long unsigned int D.98115;
  struct AsyncResult * iftmp.0;
  struct ObjectBase * pCppObject.1;
  const struct type_info * iftmp.2;
  int (*__vtbl_ptr_type) () * D.98129;
  const char * D.98131;
  void * result.3;
  bool D.98134;
  bool D.98135;
  int (*__vtbl_ptr_type) () * D.98138;
  int (*__vtbl_ptr_type) () * D.98139;
  long int D.98140;
  sizetype D.98141;
  struct ObjectBase * D.98142;
  int (*__vtbl_ptr_type) () * D.98143;
  int (*__vtbl_ptr_type) () * D.98144;
  int (*__vtbl_ptr_type) () D.98145;
  struct ObjectBase * pCppObject;
  struct AsyncResult * result;

  if (object == 0B) goto <D.98110>; else goto <D.98111>;
  <D.98110>:
  D.98112 = 0B;
  return D.98112;
  <D.98111>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.98113>; else goto <D.98114>;
  <D.98113>:
  D.98115 = Gio::AsyncResult::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.98115);
  goto <D.98116>;
  <D.98114>:
  <D.98116>:
  result = 0B;
  if (pCppObject != 0B) goto <D.98117>; else goto <D.98118>;
  <D.98117>:
  pCppObject.1 = pCppObject;
  if (pCppObject.1 == 0B) goto <D.98121>; else goto <D.98122>;
  <D.98121>:
  iftmp.0 = 0B;
  goto <D.98123>;
  <D.98122>:
  iftmp.0 = __dynamic_cast (pCppObject.1, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11AsyncResultE, -1);
  <D.98123>:
  result = iftmp.0;
  if (result == 0B) goto <D.98124>; else goto <D.98125>;
  <D.98124>:
  if (pCppObject != 0B) goto <D.98127>; else goto <D.98128>;
  <D.98127>:
  D.98129 = pCppObject->_vptr.ObjectBase;
  iftmp.2 = MEM[(int (*__vtbl_ptr_type) () *)D.98129 + -8B];
  goto <D.98130>;
  <D.98128>:
  __cxa_bad_typeid ();
  <D.98130>:
  D.98131 = 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.98131);
  goto <D.98132>;
  <D.98125>:
  <D.98132>:
  goto <D.98133>;
  <D.98118>:
  result.3 = operator new (48);
  try
    {
      Gio::AsyncResult::AsyncResult (result.3, object);
    }
  catch
    {
      operator delete (result.3);
    }
  result = result.3;
  <D.98133>:
  D.98134 = result != 0B;
  D.98135 = D.98134 & take_copy;
  if (D.98135 != 0) goto <D.98136>; else goto <D.98137>;
  <D.98136>:
  D.98138 = result->D.86030._vptr.Interface;
  D.98139 = D.98138 + 18446744073709551592;
  D.98140 = MEM[(long int *)D.98139];
  D.98141 = (sizetype) D.98140;
  D.98142 = result + D.98141;
  D.98138 = result->D.86030._vptr.Interface;
  D.98139 = D.98138 + 18446744073709551592;
  D.98140 = MEM[(long int *)D.98139];
  D.98141 = (sizetype) D.98140;
  D.98142 = result + D.98141;
  D.98143 = D.98142->_vptr.ObjectBase;
  D.98144 = D.98143 + 16;
  D.98145 = *D.98144;
  D.98138 = result->D.86030._vptr.Interface;
  D.98139 = D.98138 + 18446744073709551592;
  D.98140 = MEM[(long int *)D.98139];
  D.98141 = (sizetype) D.98140;
  D.98142 = result + D.98141;
  OBJ_TYPE_REF(D.98145;(const struct ObjectBase)D.98142->2) (D.98142);
  goto <D.98146>;
  <D.98137>:
  <D.98146>:
  D.98112 = result;
  return D.98112;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.98153;
  const char * iftmp.4;
  const char * D.98155;
  char D.98156;

  D.98155 = this->__name;
  D.98156 = *D.98155;
  if (D.98156 == 42) goto <D.98157>; else goto <D.98158>;
  <D.98157>:
  D.98155 = this->__name;
  iftmp.4 = D.98155 + 1;
  goto <D.98159>;
  <D.98158>:
  iftmp.4 = this->__name;
  <D.98159>:
  D.98153 = iftmp.4;
  return D.98153;
}


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


const Glib::Interface_Class& Gio::AsyncResult_Class::init() (struct AsyncResult_Class * const this)
{
  long unsigned int D.98161;
  long unsigned int D.98164;
  const struct Interface_Class & D.98166;

  D.98161 = this->D.86068.D.86052.gtype_;
  if (D.98161 == 0) goto <D.98162>; else goto <D.98163>;
  <D.98162>:
  this->D.86068.D.86052.class_init_func_ = iface_init_function;
  D.98164 = g_async_result_get_type ();
  this->D.86068.D.86052.gtype_ = D.98164;
  goto <D.98165>;
  <D.98163>:
  <D.98165>:
  D.98166 = &this->D.86068;
  return D.98166;
}


static void Gio::AsyncResult_Class::iface_init_function(void*, void*) (void * g_iface, void * D.96931)
{
  bool retval.5;
  int retval.6;
  long int D.98174;
  long int D.98175;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[70] = "static void Gio::AsyncResult_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.98171>; else goto <D.98172>;
        <D.98171>:
        _g_boolean_var_ = 1;
        goto <D.98173>;
        <D.98172>:
        _g_boolean_var_ = 0;
        <D.98173>:
        retval.6 = _g_boolean_var_;
      }
      D.98174 = (long int) retval.6;
      D.98175 = __builtin_expect (D.98174, 1);
      retval.5 = D.98175 != 0;
      if (retval.5 != 0) goto <D.98176>; else goto <D.98177>;
      <D.98176>:
      goto <D.98178>;
      <D.98177>:
      g_assertion_message_expr ("giomm", "asyncresult.cc", 100, &__PRETTY_FUNCTION__, "klass != 0");
      <D.98178>:
    }
  }
  klass->get_source_object = get_source_object_vfunc_callback;
}


static GObject* Gio::AsyncResult_Class::get_source_object_vfunc_callback(GAsyncResult*) (struct GAsyncResult * self)
{
  bool retval.7;
  bool iftmp.8;
  bool D.98184;
  struct CppObjectType * const iftmp.9;
  struct GObject * D.98194;
  struct RefPtr D.96947;
  int (*__vtbl_ptr_type) () * D.98195;
  int (*__vtbl_ptr_type) () * D.98196;
  int (*__vtbl_ptr_type) () D.98197;
  void * D.98198;
  long unsigned int D.98201;
  struct GTypeClass * D.98202;
  void * D.98203;
  struct GObject * (*<Tfb16>) (struct GAsyncResult *) D.98206;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef struct GObject * RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.98183>; else goto <D.98181>;
    <D.98183>:
    D.98184 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.98184 != 0) goto <D.98185>; else goto <D.98181>;
    <D.98185>:
    iftmp.8 = 1;
    goto <D.98182>;
    <D.98181>:
    iftmp.8 = 0;
    <D.98182>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.98186>; else goto <D.98187>;
    <D.98186>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.98189>; else goto <D.98190>;
      <D.98189>:
      iftmp.9 = 0B;
      goto <D.98191>;
      <D.98190>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11AsyncResultE, -1);
      <D.98191>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.98192>; else goto <D.98193>;
      <D.98192>:
      try
        {
          D.98195 = obj->D.86030._vptr.Interface;
          D.98196 = D.98195 + 16;
          D.98197 = *D.98196;
          D.96947 = OBJ_TYPE_REF(D.98197;(struct AsyncResult)obj->2) (obj); [return slot optimization]
          try
            {
              D.98194 = Gio::unwrap_objectbase_custom (&D.96947);
              return D.98194;
            }
          finally
            {
              Glib::RefPtr<Glib::ObjectBase>::~RefPtr (&D.96947);
              D.96947 = {CLOBBER};
            }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.98198 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.98198);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.98199>;
      <D.98193>:
      <D.98199>:
    }
    goto <D.98200>;
    <D.98187>:
    <D.98200>:
  }
  D.98201 = Gio::AsyncResult::get_type ();
  D.98202 = MEM[(struct GTypeInstance *)self].g_class;
  D.98203 = g_type_interface_peek (D.98202, D.98201);
  base = g_type_interface_peek_parent (D.98203);
  {
    if (base != 0B) goto <D.98204>; else goto <D.98205>;
    <D.98204>:
    D.98206 = base->get_source_object;
    if (D.98206 != 0B) goto <D.98207>; else goto <D.98208>;
    <D.98207>:
    {
      struct GObject * retval;

      D.98206 = base->get_source_object;
      retval = D.98206 (self);
      D.98194 = retval;
      return D.98194;
    }
    <D.98208>:
    <D.98205>:
  }
  D.98194 = 0B;
  return D.98194;
}


GObject* Gio::unwrap_objectbase_custom(const Glib::RefPtr<Glib::ObjectBase>&) (const struct RefPtr & cpp_instance)
{
  struct GObject * D.98222;
  struct GObject * iftmp.10;
  bool D.98224;
  struct ObjectBase * D.98227;

  D.98224 = Glib::RefPtr<Glib::ObjectBase>::operator bool (cpp_instance);
  if (D.98224 != 0) goto <D.98225>; else goto <D.98226>;
  <D.98225>:
  D.98227 = Glib::RefPtr<Glib::ObjectBase>::operator-> (cpp_instance);
  iftmp.10 = Glib::ObjectBase::gobj (D.98227);
  goto <D.98228>;
  <D.98226>:
  iftmp.10 = 0B;
  <D.98228>:
  D.98222 = iftmp.10;
  return D.98222;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Glib::ObjectBase] (const struct RefPtr * const this)
{
  bool D.98230;
  struct ObjectBase * D.98231;

  D.98231 = this->pCppObject_;
  D.98230 = D.98231 != 0B;
  return D.98230;
}


GObject* Glib::ObjectBase::gobj() (struct ObjectBase * const this)
{
  struct GObject * D.98233;

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


static Glib::ObjectBase* Gio::AsyncResult_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.98235;
  struct ObjectBase * iftmp.11;
  void * D.96955;
  void * D.98237;
  int (*__vtbl_ptr_type) () * D.98240;
  int (*__vtbl_ptr_type) () * D.98241;
  long int D.98242;
  sizetype D.98243;

  D.96955 = operator new (48);
  try
    {
      Gio::AsyncResult::AsyncResult (D.96955, object);
    }
  catch
    {
      operator delete (D.96955);
    }
  D.98237 = D.96955;
  if (D.98237 != 0B) goto <D.98238>; else goto <D.98239>;
  <D.98238>:
  D.98240 = MEM[(struct AsyncResult *)D.98237].D.86030._vptr.Interface;
  D.98241 = D.98240 + 18446744073709551592;
  D.98242 = MEM[(long int *)D.98241];
  D.98243 = (sizetype) D.98242;
  iftmp.11 = D.98237 + D.98243;
  goto <D.98244>;
  <D.98239>:
  iftmp.11 = 0B;
  <D.98244>:
  D.98235 = iftmp.11;
  return D.98235;
}


Gio::AsyncResult::AsyncResult() (struct AsyncResult * const this, const void * * __vtt_parm)
{
  struct trackable * D.98250;
  const void * * iftmp.12;
  struct ObjectBase * D.98258;
  const struct Interface_Class & D.98260;
  const void * * iftmp.13;
  struct Interface * D.98265;
  int (*__vtbl_ptr_type) () * iftmp.14;
  sizetype iftmp.15;
  int (*__vtbl_ptr_type) () * D.98273;
  int (*__vtbl_ptr_type) () * D.98274;
  long int D.98275;
  struct ObjectBase * D.98277;
  int (*__vtbl_ptr_type) () * iftmp.16;
  const void * * iftmp.17;
  const void * * iftmp.18;

  if (0 != 0) goto <D.98248>; else goto <D.98249>;
  <D.98248>:
  D.98250 = &this->D.86033;
  sigc::trackable::trackable (D.98250);
  goto <D.98251>;
  <D.98249>:
  <D.98251>:
  try
    {
      if (0 != 0) goto <D.98252>; else goto <D.98253>;
      <D.98252>:
      if (0 == 0) goto <D.98255>; else goto <D.98256>;
      <D.98255>:
      iftmp.12 = __vtt_parm + 32;
      goto <D.98257>;
      <D.98256>:
      iftmp.12 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98257>:
      D.98258 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98258, iftmp.12);
      goto <D.98259>;
      <D.98253>:
      <D.98259>:
      try
        {
          D.98260 = Gio::AsyncResult_Class::init (&asyncresult_class_);
          if (0 == 0) goto <D.98262>; else goto <D.98263>;
          <D.98262>:
          iftmp.13 = __vtt_parm + 8;
          goto <D.98264>;
          <D.98263>:
          iftmp.13 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98264>:
          D.98265 = &this->D.86030;
          Glib::Interface::Interface (D.98265, iftmp.13, D.98260);
          try
            {
              if (0 == 0) goto <D.98267>; else goto <D.98268>;
              <D.98267>:
              iftmp.14 = *__vtt_parm;
              goto <D.98269>;
              <D.98268>:
              iftmp.14 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98269>:
              this->D.86030._vptr.Interface = iftmp.14;
              if (0 == 0) goto <D.98271>; else goto <D.98272>;
              <D.98271>:
              D.98273 = this->D.86030._vptr.Interface;
              D.98274 = D.98273 + 18446744073709551592;
              D.98275 = MEM[(long int *)D.98274];
              iftmp.15 = (sizetype) D.98275;
              goto <D.98276>;
              <D.98272>:
              iftmp.15 = 8;
              <D.98276>:
              D.98277 = this + iftmp.15;
              if (0 == 0) goto <D.98279>; else goto <D.98280>;
              <D.98279>:
              iftmp.16 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98281>;
              <D.98280>:
              iftmp.16 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98281>:
              D.98277->_vptr.ObjectBase = iftmp.16;
            }
          catch
            {
              if (0 == 0) goto <D.98283>; else goto <D.98284>;
              <D.98283>:
              iftmp.17 = __vtt_parm + 8;
              goto <D.98285>;
              <D.98284>:
              iftmp.17 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98285>:
              D.98265 = &this->D.86030;
              Glib::Interface::~Interface (D.98265, iftmp.17);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98286>; else goto <D.98287>;
          <D.98286>:
          if (0 == 0) goto <D.98289>; else goto <D.98290>;
          <D.98289>:
          iftmp.18 = __vtt_parm + 32;
          goto <D.98291>;
          <D.98290>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98291>:
          D.98258 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98258, iftmp.18);
          goto <D.98292>;
          <D.98287>:
          <D.98292>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98293>; else goto <D.98294>;
      <D.98293>:
      D.98250 = &this->D.86033;
      sigc::trackable::~trackable (D.98250);
      goto <D.98295>;
      <D.98294>:
      <D.98295>:
    }
}


Gio::AsyncResult::AsyncResult() (struct AsyncResult * const this)
{
  struct trackable * D.98301;
  const void * * iftmp.19;
  struct ObjectBase * D.98309;
  const struct Interface_Class & D.98311;
  const void * * iftmp.20;
  struct Interface * D.98316;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * D.98320;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.98325;
  int (*__vtbl_ptr_type) () * D.98326;
  long int D.98327;
  struct ObjectBase * D.98329;
  int (*__vtbl_ptr_type) () * iftmp.23;
  const void * * iftmp.24;
  const void * * iftmp.25;

  if (1 != 0) goto <D.98299>; else goto <D.98300>;
  <D.98299>:
  D.98301 = &this->D.86033;
  sigc::trackable::trackable (D.98301);
  goto <D.98302>;
  <D.98300>:
  <D.98302>:
  try
    {
      if (1 != 0) goto <D.98303>; else goto <D.98304>;
      <D.98303>:
      if (1 == 0) goto <D.98306>; else goto <D.98307>;
      <D.98306>:
      iftmp.19 = 32B;
      goto <D.98308>;
      <D.98307>:
      iftmp.19 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98308>:
      D.98309 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98309, iftmp.19);
      goto <D.98310>;
      <D.98304>:
      <D.98310>:
      try
        {
          D.98311 = Gio::AsyncResult_Class::init (&asyncresult_class_);
          if (1 == 0) goto <D.98313>; else goto <D.98314>;
          <D.98313>:
          iftmp.20 = 8B;
          goto <D.98315>;
          <D.98314>:
          iftmp.20 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98315>:
          D.98316 = &this->D.86030;
          Glib::Interface::Interface (D.98316, iftmp.20, D.98311);
          try
            {
              if (1 == 0) goto <D.98318>; else goto <D.98319>;
              <D.98318>:
              D.98320 = 0B;
              iftmp.21 = *D.98320;
              goto <D.98321>;
              <D.98319>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98321>:
              this->D.86030._vptr.Interface = iftmp.21;
              if (1 == 0) goto <D.98323>; else goto <D.98324>;
              <D.98323>:
              D.98325 = this->D.86030._vptr.Interface;
              D.98326 = D.98325 + 18446744073709551592;
              D.98327 = MEM[(long int *)D.98326];
              iftmp.22 = (sizetype) D.98327;
              goto <D.98328>;
              <D.98324>:
              iftmp.22 = 8;
              <D.98328>:
              D.98329 = this + iftmp.22;
              if (1 == 0) goto <D.98331>; else goto <D.98332>;
              <D.98331>:
              iftmp.23 = MEM[(const void * *)0B + 24B];
              goto <D.98333>;
              <D.98332>:
              iftmp.23 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98333>:
              D.98329->_vptr.ObjectBase = iftmp.23;
            }
          catch
            {
              if (1 == 0) goto <D.98335>; else goto <D.98336>;
              <D.98335>:
              iftmp.24 = 8B;
              goto <D.98337>;
              <D.98336>:
              iftmp.24 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98337>:
              D.98316 = &this->D.86030;
              Glib::Interface::~Interface (D.98316, iftmp.24);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98338>; else goto <D.98339>;
          <D.98338>:
          if (1 == 0) goto <D.98341>; else goto <D.98342>;
          <D.98341>:
          iftmp.25 = 32B;
          goto <D.98343>;
          <D.98342>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98343>:
          D.98309 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98309, iftmp.25);
          goto <D.98344>;
          <D.98339>:
          <D.98344>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98345>; else goto <D.98346>;
      <D.98345>:
      D.98301 = &this->D.86033;
      sigc::trackable::~trackable (D.98301);
      goto <D.98347>;
      <D.98346>:
      <D.98347>:
    }
}


Gio::AsyncResult::AsyncResult(GAsyncResult*) (struct AsyncResult * const this, const void * * __vtt_parm, struct GAsyncResult * castitem)
{
  struct trackable * D.98353;
  const void * * iftmp.26;
  struct ObjectBase * D.98361;
  const void * * iftmp.27;
  struct Interface * D.98367;
  int (*__vtbl_ptr_type) () * iftmp.28;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.98375;
  int (*__vtbl_ptr_type) () * D.98376;
  long int D.98377;
  struct ObjectBase * D.98379;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * iftmp.31;
  const void * * iftmp.32;

  if (0 != 0) goto <D.98351>; else goto <D.98352>;
  <D.98351>:
  D.98353 = &this->D.86033;
  sigc::trackable::trackable (D.98353);
  goto <D.98354>;
  <D.98352>:
  <D.98354>:
  try
    {
      if (0 != 0) goto <D.98355>; else goto <D.98356>;
      <D.98355>:
      if (0 == 0) goto <D.98358>; else goto <D.98359>;
      <D.98358>:
      iftmp.26 = __vtt_parm + 32;
      goto <D.98360>;
      <D.98359>:
      iftmp.26 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98360>:
      D.98361 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98361, iftmp.26);
      goto <D.98362>;
      <D.98356>:
      <D.98362>:
      try
        {
          if (0 == 0) goto <D.98364>; else goto <D.98365>;
          <D.98364>:
          iftmp.27 = __vtt_parm + 8;
          goto <D.98366>;
          <D.98365>:
          iftmp.27 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98366>:
          D.98367 = &this->D.86030;
          Glib::Interface::Interface (D.98367, iftmp.27, castitem);
          try
            {
              if (0 == 0) goto <D.98369>; else goto <D.98370>;
              <D.98369>:
              iftmp.28 = *__vtt_parm;
              goto <D.98371>;
              <D.98370>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98371>:
              this->D.86030._vptr.Interface = iftmp.28;
              if (0 == 0) goto <D.98373>; else goto <D.98374>;
              <D.98373>:
              D.98375 = this->D.86030._vptr.Interface;
              D.98376 = D.98375 + 18446744073709551592;
              D.98377 = MEM[(long int *)D.98376];
              iftmp.29 = (sizetype) D.98377;
              goto <D.98378>;
              <D.98374>:
              iftmp.29 = 8;
              <D.98378>:
              D.98379 = this + iftmp.29;
              if (0 == 0) goto <D.98381>; else goto <D.98382>;
              <D.98381>:
              iftmp.30 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98383>;
              <D.98382>:
              iftmp.30 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98383>:
              D.98379->_vptr.ObjectBase = iftmp.30;
            }
          catch
            {
              if (0 == 0) goto <D.98385>; else goto <D.98386>;
              <D.98385>:
              iftmp.31 = __vtt_parm + 8;
              goto <D.98387>;
              <D.98386>:
              iftmp.31 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98387>:
              D.98367 = &this->D.86030;
              Glib::Interface::~Interface (D.98367, iftmp.31);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98388>; else goto <D.98389>;
          <D.98388>:
          if (0 == 0) goto <D.98391>; else goto <D.98392>;
          <D.98391>:
          iftmp.32 = __vtt_parm + 32;
          goto <D.98393>;
          <D.98392>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98393>:
          D.98361 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98361, iftmp.32);
          goto <D.98394>;
          <D.98389>:
          <D.98394>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98395>; else goto <D.98396>;
      <D.98395>:
      D.98353 = &this->D.86033;
      sigc::trackable::~trackable (D.98353);
      goto <D.98397>;
      <D.98396>:
      <D.98397>:
    }
}


Gio::AsyncResult::AsyncResult(GAsyncResult*) (struct AsyncResult * const this, struct GAsyncResult * castitem)
{
  struct trackable * D.98402;
  const void * * iftmp.33;
  struct ObjectBase * D.98410;
  const void * * iftmp.34;
  struct Interface * D.98416;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * D.98420;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.98425;
  int (*__vtbl_ptr_type) () * D.98426;
  long int D.98427;
  struct ObjectBase * D.98429;
  int (*__vtbl_ptr_type) () * iftmp.37;
  const void * * iftmp.38;
  const void * * iftmp.39;

  if (1 != 0) goto <D.98400>; else goto <D.98401>;
  <D.98400>:
  D.98402 = &this->D.86033;
  sigc::trackable::trackable (D.98402);
  goto <D.98403>;
  <D.98401>:
  <D.98403>:
  try
    {
      if (1 != 0) goto <D.98404>; else goto <D.98405>;
      <D.98404>:
      if (1 == 0) goto <D.98407>; else goto <D.98408>;
      <D.98407>:
      iftmp.33 = 32B;
      goto <D.98409>;
      <D.98408>:
      iftmp.33 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98409>:
      D.98410 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98410, iftmp.33);
      goto <D.98411>;
      <D.98405>:
      <D.98411>:
      try
        {
          if (1 == 0) goto <D.98413>; else goto <D.98414>;
          <D.98413>:
          iftmp.34 = 8B;
          goto <D.98415>;
          <D.98414>:
          iftmp.34 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98415>:
          D.98416 = &this->D.86030;
          Glib::Interface::Interface (D.98416, iftmp.34, castitem);
          try
            {
              if (1 == 0) goto <D.98418>; else goto <D.98419>;
              <D.98418>:
              D.98420 = 0B;
              iftmp.35 = *D.98420;
              goto <D.98421>;
              <D.98419>:
              iftmp.35 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98421>:
              this->D.86030._vptr.Interface = iftmp.35;
              if (1 == 0) goto <D.98423>; else goto <D.98424>;
              <D.98423>:
              D.98425 = this->D.86030._vptr.Interface;
              D.98426 = D.98425 + 18446744073709551592;
              D.98427 = MEM[(long int *)D.98426];
              iftmp.36 = (sizetype) D.98427;
              goto <D.98428>;
              <D.98424>:
              iftmp.36 = 8;
              <D.98428>:
              D.98429 = this + iftmp.36;
              if (1 == 0) goto <D.98431>; else goto <D.98432>;
              <D.98431>:
              iftmp.37 = MEM[(const void * *)0B + 24B];
              goto <D.98433>;
              <D.98432>:
              iftmp.37 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98433>:
              D.98429->_vptr.ObjectBase = iftmp.37;
            }
          catch
            {
              if (1 == 0) goto <D.98435>; else goto <D.98436>;
              <D.98435>:
              iftmp.38 = 8B;
              goto <D.98437>;
              <D.98436>:
              iftmp.38 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98437>:
              D.98416 = &this->D.86030;
              Glib::Interface::~Interface (D.98416, iftmp.38);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98438>; else goto <D.98439>;
          <D.98438>:
          if (1 == 0) goto <D.98441>; else goto <D.98442>;
          <D.98441>:
          iftmp.39 = 32B;
          goto <D.98443>;
          <D.98442>:
          iftmp.39 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98443>:
          D.98410 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98410, iftmp.39);
          goto <D.98444>;
          <D.98439>:
          <D.98444>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98445>; else goto <D.98446>;
      <D.98445>:
      D.98402 = &this->D.86033;
      sigc::trackable::~trackable (D.98402);
      goto <D.98447>;
      <D.98446>:
      <D.98447>:
    }
}


Gio::AsyncResult::AsyncResult(const Glib::Interface_Class&) (struct AsyncResult * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.98452;
  const void * * iftmp.40;
  struct ObjectBase * D.98460;
  const void * * iftmp.41;
  struct Interface * D.98466;
  int (*__vtbl_ptr_type) () * iftmp.42;
  sizetype iftmp.43;
  int (*__vtbl_ptr_type) () * D.98474;
  int (*__vtbl_ptr_type) () * D.98475;
  long int D.98476;
  struct ObjectBase * D.98478;
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * iftmp.45;
  const void * * iftmp.46;

  if (0 != 0) goto <D.98450>; else goto <D.98451>;
  <D.98450>:
  D.98452 = &this->D.86033;
  sigc::trackable::trackable (D.98452);
  goto <D.98453>;
  <D.98451>:
  <D.98453>:
  try
    {
      if (0 != 0) goto <D.98454>; else goto <D.98455>;
      <D.98454>:
      if (0 == 0) goto <D.98457>; else goto <D.98458>;
      <D.98457>:
      iftmp.40 = __vtt_parm + 32;
      goto <D.98459>;
      <D.98458>:
      iftmp.40 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98459>:
      D.98460 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98460, iftmp.40);
      goto <D.98461>;
      <D.98455>:
      <D.98461>:
      try
        {
          if (0 == 0) goto <D.98463>; else goto <D.98464>;
          <D.98463>:
          iftmp.41 = __vtt_parm + 8;
          goto <D.98465>;
          <D.98464>:
          iftmp.41 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98465>:
          D.98466 = &this->D.86030;
          Glib::Interface::Interface (D.98466, iftmp.41, interface_class);
          try
            {
              if (0 == 0) goto <D.98468>; else goto <D.98469>;
              <D.98468>:
              iftmp.42 = *__vtt_parm;
              goto <D.98470>;
              <D.98469>:
              iftmp.42 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98470>:
              this->D.86030._vptr.Interface = iftmp.42;
              if (0 == 0) goto <D.98472>; else goto <D.98473>;
              <D.98472>:
              D.98474 = this->D.86030._vptr.Interface;
              D.98475 = D.98474 + 18446744073709551592;
              D.98476 = MEM[(long int *)D.98475];
              iftmp.43 = (sizetype) D.98476;
              goto <D.98477>;
              <D.98473>:
              iftmp.43 = 8;
              <D.98477>:
              D.98478 = this + iftmp.43;
              if (0 == 0) goto <D.98480>; else goto <D.98481>;
              <D.98480>:
              iftmp.44 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98482>;
              <D.98481>:
              iftmp.44 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98482>:
              D.98478->_vptr.ObjectBase = iftmp.44;
            }
          catch
            {
              if (0 == 0) goto <D.98484>; else goto <D.98485>;
              <D.98484>:
              iftmp.45 = __vtt_parm + 8;
              goto <D.98486>;
              <D.98485>:
              iftmp.45 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98486>:
              D.98466 = &this->D.86030;
              Glib::Interface::~Interface (D.98466, iftmp.45);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98487>; else goto <D.98488>;
          <D.98487>:
          if (0 == 0) goto <D.98490>; else goto <D.98491>;
          <D.98490>:
          iftmp.46 = __vtt_parm + 32;
          goto <D.98492>;
          <D.98491>:
          iftmp.46 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98492>:
          D.98460 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98460, iftmp.46);
          goto <D.98493>;
          <D.98488>:
          <D.98493>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98494>; else goto <D.98495>;
      <D.98494>:
      D.98452 = &this->D.86033;
      sigc::trackable::~trackable (D.98452);
      goto <D.98496>;
      <D.98495>:
      <D.98496>:
    }
}


Gio::AsyncResult::AsyncResult(const Glib::Interface_Class&) (struct AsyncResult * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.98501;
  const void * * iftmp.47;
  struct ObjectBase * D.98509;
  const void * * iftmp.48;
  struct Interface * D.98515;
  int (*__vtbl_ptr_type) () * iftmp.49;
  const void * * D.98519;
  sizetype iftmp.50;
  int (*__vtbl_ptr_type) () * D.98524;
  int (*__vtbl_ptr_type) () * D.98525;
  long int D.98526;
  struct ObjectBase * D.98528;
  int (*__vtbl_ptr_type) () * iftmp.51;
  const void * * iftmp.52;
  const void * * iftmp.53;

  if (1 != 0) goto <D.98499>; else goto <D.98500>;
  <D.98499>:
  D.98501 = &this->D.86033;
  sigc::trackable::trackable (D.98501);
  goto <D.98502>;
  <D.98500>:
  <D.98502>:
  try
    {
      if (1 != 0) goto <D.98503>; else goto <D.98504>;
      <D.98503>:
      if (1 == 0) goto <D.98506>; else goto <D.98507>;
      <D.98506>:
      iftmp.47 = 32B;
      goto <D.98508>;
      <D.98507>:
      iftmp.47 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
      <D.98508>:
      D.98509 = &this->D.86032;
      Glib::ObjectBase::ObjectBase (D.98509, iftmp.47);
      goto <D.98510>;
      <D.98504>:
      <D.98510>:
      try
        {
          if (1 == 0) goto <D.98512>; else goto <D.98513>;
          <D.98512>:
          iftmp.48 = 8B;
          goto <D.98514>;
          <D.98513>:
          iftmp.48 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
          <D.98514>:
          D.98515 = &this->D.86030;
          Glib::Interface::Interface (D.98515, iftmp.48, interface_class);
          try
            {
              if (1 == 0) goto <D.98517>; else goto <D.98518>;
              <D.98517>:
              D.98519 = 0B;
              iftmp.49 = *D.98519;
              goto <D.98520>;
              <D.98518>:
              iftmp.49 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
              <D.98520>:
              this->D.86030._vptr.Interface = iftmp.49;
              if (1 == 0) goto <D.98522>; else goto <D.98523>;
              <D.98522>:
              D.98524 = this->D.86030._vptr.Interface;
              D.98525 = D.98524 + 18446744073709551592;
              D.98526 = MEM[(long int *)D.98525];
              iftmp.50 = (sizetype) D.98526;
              goto <D.98527>;
              <D.98523>:
              iftmp.50 = 8;
              <D.98527>:
              D.98528 = this + iftmp.50;
              if (1 == 0) goto <D.98530>; else goto <D.98531>;
              <D.98530>:
              iftmp.51 = MEM[(const void * *)0B + 24B];
              goto <D.98532>;
              <D.98531>:
              iftmp.51 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
              <D.98532>:
              D.98528->_vptr.ObjectBase = iftmp.51;
            }
          catch
            {
              if (1 == 0) goto <D.98534>; else goto <D.98535>;
              <D.98534>:
              iftmp.52 = 8B;
              goto <D.98536>;
              <D.98535>:
              iftmp.52 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
              <D.98536>:
              D.98515 = &this->D.86030;
              Glib::Interface::~Interface (D.98515, iftmp.52);
            }
        }
      catch
        {
          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 *)&_ZTTN3Gio11AsyncResultE + 32B];
          <D.98542>:
          D.98509 = &this->D.86032;
          Glib::ObjectBase::~ObjectBase (D.98509, iftmp.53);
          goto <D.98543>;
          <D.98538>:
          <D.98543>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98544>; else goto <D.98545>;
      <D.98544>:
      D.98501 = &this->D.86033;
      sigc::trackable::~trackable (D.98501);
      goto <D.98546>;
      <D.98545>:
      <D.98546>:
    }
}


Gio::AsyncResult::~AsyncResult() (struct AsyncResult * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.54;
  sizetype iftmp.55;
  int (*__vtbl_ptr_type) () * D.98556;
  int (*__vtbl_ptr_type) () * D.98557;
  long int D.98558;
  struct ObjectBase * D.98560;
  int (*__vtbl_ptr_type) () * iftmp.56;
  const void * * iftmp.57;
  struct Interface * D.98569;
  int D.98570;
  const void * * iftmp.58;
  struct ObjectBase * D.98577;
  struct trackable * D.98581;
  int D.98583;

  {
    if (0 == 0) goto <D.98550>; else goto <D.98551>;
    <D.98550>:
    iftmp.54 = *__vtt_parm;
    goto <D.98552>;
    <D.98551>:
    iftmp.54 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
    <D.98552>:
    this->D.86030._vptr.Interface = iftmp.54;
    if (0 == 0) goto <D.98554>; else goto <D.98555>;
    <D.98554>:
    D.98556 = this->D.86030._vptr.Interface;
    D.98557 = D.98556 + 18446744073709551592;
    D.98558 = MEM[(long int *)D.98557];
    iftmp.55 = (sizetype) D.98558;
    goto <D.98559>;
    <D.98555>:
    iftmp.55 = 8;
    <D.98559>:
    D.98560 = this + iftmp.55;
    if (0 == 0) goto <D.98562>; else goto <D.98563>;
    <D.98562>:
    iftmp.56 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.98564>;
    <D.98563>:
    iftmp.56 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
    <D.98564>:
    D.98560->_vptr.ObjectBase = iftmp.56;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.98566>; else goto <D.98567>;
                    <D.98566>:
                    iftmp.57 = __vtt_parm + 8;
                    goto <D.98568>;
                    <D.98567>:
                    iftmp.57 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
                    <D.98568>:
                    D.98569 = &this->D.86030;
                    Glib::Interface::~Interface (D.98569, iftmp.57);
                  }
              }
            finally
              {
                D.98570 = 0;
                if (D.98570 != 0) goto <D.98571>; else goto <D.98572>;
                <D.98571>:
                if (0 == 0) goto <D.98574>; else goto <D.98575>;
                <D.98574>:
                iftmp.58 = __vtt_parm + 32;
                goto <D.98576>;
                <D.98575>:
                iftmp.58 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
                <D.98576>:
                D.98577 = &this->D.86032;
                Glib::ObjectBase::~ObjectBase (D.98577, iftmp.58);
                goto <D.98578>;
                <D.98572>:
                <D.98578>:
              }
          }
        finally
          {
            D.98570 = 0;
            if (D.98570 != 0) goto <D.98579>; else goto <D.98580>;
            <D.98579>:
            D.98581 = &this->D.86033;
            sigc::trackable::~trackable (D.98581);
            goto <D.98582>;
            <D.98580>:
            <D.98582>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97002>:
  D.98583 = 0;
  if (D.98583 != 0) goto <D.98584>; else goto <D.98585>;
  <D.98584>:
  operator delete (this);
  goto <D.98586>;
  <D.98585>:
  <D.98586>:
}


virtual Gio::AsyncResult::~AsyncResult() (struct AsyncResult * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * D.98602;
  sizetype iftmp.60;
  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.61;
  const void * * iftmp.62;
  struct Interface * D.98620;
  int D.98621;
  const void * * iftmp.63;
  struct ObjectBase * D.98628;
  struct trackable * D.98632;
  int D.98634;

  {
    if (2 == 0) goto <D.98600>; else goto <D.98601>;
    <D.98600>:
    D.98602 = 0B;
    iftmp.59 = *D.98602;
    goto <D.98603>;
    <D.98601>:
    iftmp.59 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 32B];
    <D.98603>:
    this->D.86030._vptr.Interface = iftmp.59;
    if (2 == 0) goto <D.98605>; else goto <D.98606>;
    <D.98605>:
    D.98607 = this->D.86030._vptr.Interface;
    D.98608 = D.98607 + 18446744073709551592;
    D.98609 = MEM[(long int *)D.98608];
    iftmp.60 = (sizetype) D.98609;
    goto <D.98610>;
    <D.98606>:
    iftmp.60 = 8;
    <D.98610>:
    D.98611 = this + iftmp.60;
    if (2 == 0) goto <D.98613>; else goto <D.98614>;
    <D.98613>:
    iftmp.61 = MEM[(const void * *)0B + 24B];
    goto <D.98615>;
    <D.98614>:
    iftmp.61 = &MEM[(void *)&_ZTVN3Gio11AsyncResultE + 120B];
    <D.98615>:
    D.98611->_vptr.ObjectBase = iftmp.61;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.98617>; else goto <D.98618>;
                    <D.98617>:
                    iftmp.62 = 8B;
                    goto <D.98619>;
                    <D.98618>:
                    iftmp.62 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 8B];
                    <D.98619>:
                    D.98620 = &this->D.86030;
                    Glib::Interface::~Interface (D.98620, iftmp.62);
                  }
              }
            finally
              {
                D.98621 = 2;
                if (D.98621 != 0) goto <D.98622>; else goto <D.98623>;
                <D.98622>:
                if (2 == 0) goto <D.98625>; else goto <D.98626>;
                <D.98625>:
                iftmp.63 = 32B;
                goto <D.98627>;
                <D.98626>:
                iftmp.63 = &MEM[(void *)&_ZTTN3Gio11AsyncResultE + 32B];
                <D.98627>:
                D.98628 = &this->D.86032;
                Glib::ObjectBase::~ObjectBase (D.98628, iftmp.63);
                goto <D.98629>;
                <D.98623>:
                <D.98629>:
              }
          }
        finally
          {
            D.98621 = 2;
            if (D.98621 != 0) goto <D.98630>; else goto <D.98631>;
            <D.98630>:
            D.98632 = &this->D.86033;
            sigc::trackable::~trackable (D.98632);
            goto <D.98633>;
            <D.98631>:
            <D.98633>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97005>:
  D.98634 = 0;
  if (D.98634 != 0) goto <D.98635>; else goto <D.98636>;
  <D.98635>:
  operator delete (this);
  goto <D.98637>;
  <D.98636>:
  <D.98637>:
}


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


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

  D.98650 = Gio::AsyncResult_Class::init (&asyncresult_class_);
  Glib::Interface_Class::add_interface (D.98650, gtype_implementer);
}


static GType Gio::AsyncResult::get_type() ()
{
  GType D.98652;
  const struct Interface_Class & D.98653;
  const struct Class * D.98654;

  D.98653 = Gio::AsyncResult_Class::init (&asyncresult_class_);
  D.98654 = &D.98653->D.86052;
  D.98652 = Glib::Class::get_type (D.98654);
  return D.98652;
}


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

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


static GType Gio::AsyncResult::get_base_type() ()
{
  GType D.98659;

  D.98659 = g_async_result_get_type ();
  return D.98659;
}


Glib::RefPtr<Glib::Object> Gio::AsyncResult::get_source_object() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.98663;
  struct GObject * D.98664;

  D.98663 = Gio::AsyncResult::gobj (this);
  D.98664 = g_async_result_get_source_object (D.98663);
  *<retval> = Glib::wrap (D.98664, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Glib::Object> Gio::AsyncResult::get_source_object() const (const struct AsyncResult * const this)
{
  struct RefPtr D.97289;

  D.97289 = Gio::AsyncResult::get_source_object (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Glib::Object>::RefPtr<Glib::Object> (<retval>, &D.97289);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Glib::Object>::~RefPtr (&D.97289);
      D.97289 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Glib::Object; T_CppObject = const Glib::Object] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Object * D.98671;
  const struct Object * D.98672;
  int (*__vtbl_ptr_type) () * D.98675;
  int (*__vtbl_ptr_type) () * D.98676;
  long int D.98677;
  sizetype D.98678;
  const struct ObjectBase * D.98679;
  int (*__vtbl_ptr_type) () * D.98680;
  int (*__vtbl_ptr_type) () * D.98681;
  int (*__vtbl_ptr_type) () D.98682;

  D.98671 = Glib::RefPtr<Glib::Object>::operator-> (src);
  this->pCppObject_ = D.98671;
  D.98672 = this->pCppObject_;
  if (D.98672 != 0B) goto <D.98673>; else goto <D.98674>;
  <D.98673>:
  D.98672 = this->pCppObject_;
  D.98672 = this->pCppObject_;
  D.98675 = D.98672->_vptr.Object;
  D.98676 = D.98675 + 18446744073709551592;
  D.98677 = MEM[(long int *)D.98676];
  D.98678 = (sizetype) D.98677;
  D.98679 = D.98672 + D.98678;
  D.98672 = this->pCppObject_;
  D.98672 = this->pCppObject_;
  D.98675 = D.98672->_vptr.Object;
  D.98676 = D.98675 + 18446744073709551592;
  D.98677 = MEM[(long int *)D.98676];
  D.98678 = (sizetype) D.98677;
  D.98679 = D.98672 + D.98678;
  D.98680 = D.98679->_vptr.ObjectBase;
  D.98681 = D.98680 + 16;
  D.98682 = *D.98681;
  D.98672 = this->pCppObject_;
  D.98672 = this->pCppObject_;
  D.98675 = D.98672->_vptr.Object;
  D.98676 = D.98675 + 18446744073709551592;
  D.98677 = MEM[(long int *)D.98676];
  D.98678 = (sizetype) D.98677;
  D.98679 = D.98672 + D.98678;
  OBJ_TYPE_REF(D.98682;(const struct ObjectBase)D.98679->2) (D.98679);
  goto <D.98683>;
  <D.98674>:
  <D.98683>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Glib::Object] (struct RefPtr * const this)
{
  struct Object * D.98686;
  int (*__vtbl_ptr_type) () * D.98689;
  int (*__vtbl_ptr_type) () * D.98690;
  long int D.98691;
  sizetype D.98692;
  struct ObjectBase * D.98693;
  int (*__vtbl_ptr_type) () * D.98694;
  int (*__vtbl_ptr_type) () * D.98695;
  int (*__vtbl_ptr_type) () D.98696;

  {
    try
      {
        D.98686 = this->pCppObject_;
        if (D.98686 != 0B) goto <D.98687>; else goto <D.98688>;
        <D.98687>:
        D.98686 = this->pCppObject_;
        D.98686 = this->pCppObject_;
        D.98689 = D.98686->_vptr.Object;
        D.98690 = D.98689 + 18446744073709551592;
        D.98691 = MEM[(long int *)D.98690];
        D.98692 = (sizetype) D.98691;
        D.98693 = D.98686 + D.98692;
        D.98686 = this->pCppObject_;
        D.98686 = this->pCppObject_;
        D.98689 = D.98686->_vptr.Object;
        D.98690 = D.98689 + 18446744073709551592;
        D.98691 = MEM[(long int *)D.98690];
        D.98692 = (sizetype) D.98691;
        D.98693 = D.98686 + D.98692;
        D.98694 = D.98693->_vptr.ObjectBase;
        D.98695 = D.98694 + 24;
        D.98696 = *D.98695;
        D.98686 = this->pCppObject_;
        D.98686 = this->pCppObject_;
        D.98689 = D.98686->_vptr.Object;
        D.98690 = D.98689 + 18446744073709551592;
        D.98691 = MEM[(long int *)D.98690];
        D.98692 = (sizetype) D.98691;
        D.98693 = D.98686 + D.98692;
        OBJ_TYPE_REF(D.98696;(const struct ObjectBase)D.98693->3) (D.98693);
        goto <D.98697>;
        <D.98688>:
        <D.98697>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97723>:
}


bool Gio::AsyncResult::is_tagged(gpointer) const (const struct AsyncResult * const this, void * source_tag)
{
  bool D.98699;
  const struct GAsyncResult * D.98700;
  int D.98701;

  D.98700 = Gio::AsyncResult::gobj (this);
  D.98701 = g_async_result_is_tagged (D.98700, source_tag);
  D.98699 = D.98701 != 0;
  return D.98699;
}


const GAsyncResult* Gio::AsyncResult::gobj() const (const struct AsyncResult * const this)
{
  const struct GAsyncResult * D.98704;
  int (*__vtbl_ptr_type) () * D.98705;
  int (*__vtbl_ptr_type) () * D.98706;
  long int D.98707;
  sizetype D.98708;
  const struct ObjectBase * D.98709;

  D.98705 = this->D.86030._vptr.Interface;
  D.98706 = D.98705 + 18446744073709551592;
  D.98707 = MEM[(long int *)D.98706];
  D.98708 = (sizetype) D.98707;
  D.98709 = this + D.98708;
  D.98704 = D.98709->gobject_;
  return D.98704;
}


virtual Glib::RefPtr<Glib::ObjectBase> Gio::AsyncResult::get_source_object_vfunc() (struct AsyncResult * const this)
{
  long unsigned int D.98712;
  int (*__vtbl_ptr_type) () * D.98713;
  int (*__vtbl_ptr_type) () * D.98714;
  long int D.98715;
  sizetype D.98716;
  struct ObjectBase * D.98717;
  struct GObject * D.98718;
  struct GTypeClass * D.98719;
  void * D.98720;
  struct GObject * (*<Tfb16>) (struct GAsyncResult *) D.98723;
  struct RefPtr D.97318;
  struct GAsyncResult * D.98726;
  struct GObject * D.98727;
  struct BaseClassType * const base;
  typedef struct RType RType;

  D.98712 = Gio::AsyncResult::get_type ();
  D.98713 = this->D.86030._vptr.Interface;
  D.98714 = D.98713 + 18446744073709551592;
  D.98715 = MEM[(long int *)D.98714];
  D.98716 = (sizetype) D.98715;
  D.98717 = this + D.98716;
  D.98718 = D.98717->gobject_;
  D.98719 = MEM[(struct GTypeInstance *)D.98718].g_class;
  D.98720 = g_type_interface_peek (D.98719, D.98712);
  base = g_type_interface_peek_parent (D.98720);
  {
    if (base != 0B) goto <D.98721>; else goto <D.98722>;
    <D.98721>:
    D.98723 = base->get_source_object;
    if (D.98723 != 0B) goto <D.98724>; else goto <D.98725>;
    <D.98724>:
    {
      struct RefPtr retval;

      try
        {
          D.98723 = base->get_source_object;
          D.98726 = Gio::AsyncResult::gobj (this);
          D.98727 = D.98723 (D.98726);
          D.97318 = Glib::wrap (D.98727, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Glib::ObjectBase>::RefPtr<Glib::Object> (&retval, &D.97318);
            }
          finally
            {
              try
                {
                  Glib::RefPtr<Glib::Object>::~RefPtr (&D.97318);
                }
              catch
                {
                  Glib::RefPtr<Glib::ObjectBase>::~RefPtr (&retval);
                }
              D.97318 = {CLOBBER};
            }
          try
            {
              Glib::RefPtr<Glib::ObjectBase>::RefPtr (<retval>, &retval);
              return <retval>;
            }
          finally
            {
              Glib::RefPtr<Glib::ObjectBase>::~RefPtr (&retval);
            }
        }
      finally
        {
          retval = {CLOBBER};
        }
    }
    <D.98725>:
    <D.98722>:
  }
  Glib::RefPtr<Glib::ObjectBase>::RefPtr (<retval>);
  return <retval>;
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Glib::Object; T_CppObject = Glib::ObjectBase] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct ObjectBase * iftmp.64;
  struct Object * D.98740;
  int (*__vtbl_ptr_type) () * D.98743;
  int (*__vtbl_ptr_type) () * D.98744;
  long int D.98745;
  sizetype D.98746;
  struct ObjectBase * D.98748;
  int (*__vtbl_ptr_type) () * D.98751;
  int (*__vtbl_ptr_type) () * D.98752;
  int (*__vtbl_ptr_type) () D.98753;

  D.98740 = Glib::RefPtr<Glib::Object>::operator-> (src);
  if (D.98740 != 0B) goto <D.98741>; else goto <D.98742>;
  <D.98741>:
  D.98743 = D.98740->_vptr.Object;
  D.98744 = D.98743 + 18446744073709551592;
  D.98745 = MEM[(long int *)D.98744];
  D.98746 = (sizetype) D.98745;
  iftmp.64 = D.98740 + D.98746;
  goto <D.98747>;
  <D.98742>:
  iftmp.64 = 0B;
  <D.98747>:
  this->pCppObject_ = iftmp.64;
  D.98748 = this->pCppObject_;
  if (D.98748 != 0B) goto <D.98749>; else goto <D.98750>;
  <D.98749>:
  D.98748 = this->pCppObject_;
  D.98748 = this->pCppObject_;
  D.98751 = D.98748->_vptr.ObjectBase;
  D.98752 = D.98751 + 16;
  D.98753 = *D.98752;
  D.98748 = this->pCppObject_;
  OBJ_TYPE_REF(D.98753;(const struct ObjectBase)D.98748->2) (D.98748);
  goto <D.98754>;
  <D.98750>:
  <D.98754>:
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Glib::ObjectBase] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct ObjectBase * D.98755;
  struct ObjectBase * D.98756;
  int (*__vtbl_ptr_type) () * D.98759;
  int (*__vtbl_ptr_type) () * D.98760;
  int (*__vtbl_ptr_type) () D.98761;

  D.98755 = src->pCppObject_;
  this->pCppObject_ = D.98755;
  D.98756 = this->pCppObject_;
  if (D.98756 != 0B) goto <D.98757>; else goto <D.98758>;
  <D.98757>:
  D.98756 = this->pCppObject_;
  D.98756 = this->pCppObject_;
  D.98759 = D.98756->_vptr.ObjectBase;
  D.98760 = D.98759 + 16;
  D.98761 = *D.98760;
  D.98756 = this->pCppObject_;
  OBJ_TYPE_REF(D.98761;(const struct ObjectBase)D.98756->2) (D.98756);
  goto <D.98762>;
  <D.98758>:
  <D.98762>:
}


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