void Gio::delete_slot(gpointer) (void * data)
{
  struct SlotCancelledCallback * callback.0;
  struct SlotCancelledCallback * callback;

  callback = data;
  callback.0 = callback;
  if (callback.0 != 0B) goto <D.97543>; else goto <D.97544>;
  <D.97543>:
  sigc::slot<void>::~slot (callback.0);
  operator delete (callback.0);
  goto <D.97545>;
  <D.97544>:
  <D.97545>:
}


sigc::slot<void>::~slot() (struct slot * const this)
{
  struct slot0 * D.97546;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.97546 = &this->D.83876;
            sigc::slot0<void>::~slot0 (D.97546);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.83908>:
}


sigc::slot0<void>::~slot0() (struct slot0 * const this)
{
  struct slot_base * D.97549;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.97549 = &this->D.83834;
            sigc::slot_base::~slot_base (D.97549);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.83903>:
}


void Gio::slot_cancelled_proxy(GCancellable*, gpointer) (struct GCancellable * D.96518, void * data)
{
  struct slot0 * D.97551;
  struct SlotCancelledCallback * callback;

  callback = data;
  D.97551 = &callback->D.83876;
  sigc::slot0<void>::operator() (D.97551);
}


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.1;
  bool iftmp.2;
  const struct slot_base * D.97556;
  bool D.97557;
  bool D.97558;
  bool D.97560;
  bool D.97561;
  struct rep_type * D.97565;
  void * (*<T609>) (void *) D.97566;

  D.97556 = &this->D.83834;
  D.97557 = sigc::slot_base::empty (D.97556);
  D.97558 = ~D.97557;
  if (D.97558 != 0) goto <D.97559>; else goto <D.97554>;
  <D.97559>:
  D.97556 = &this->D.83834;
  D.97560 = sigc::slot_base::blocked (D.97556);
  D.97561 = ~D.97560;
  if (D.97561 != 0) goto <D.97562>; else goto <D.97554>;
  <D.97562>:
  iftmp.2 = 1;
  goto <D.97555>;
  <D.97554>:
  iftmp.2 = 0;
  <D.97555>:
  retval.1 = iftmp.2;
  if (retval.1 != 0) goto <D.97563>; else goto <D.97564>;
  <D.97563>:
  D.97565 = this->D.83834.rep_;
  D.97566 = D.97565->call_;
  D.97565 = this->D.83834.rep_;
  D.97566 (D.97565);
  return;
  <D.97564>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.97568;
  bool iftmp.3;
  struct rep_type * D.97573;
  void * (*<T609>) (void *) D.97575;

  D.97573 = this->rep_;
  if (D.97573 == 0B) goto <D.97570>; else goto <D.97574>;
  <D.97574>:
  D.97573 = this->rep_;
  D.97575 = D.97573->call_;
  if (D.97575 == 0B) goto <D.97570>; else goto <D.97571>;
  <D.97570>:
  iftmp.3 = 1;
  goto <D.97572>;
  <D.97571>:
  iftmp.3 = 0;
  <D.97572>:
  D.97568 = iftmp.3;
  return D.97568;
}


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

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


gulong Gio::Cancellable::connect(const SlotCancelledCallback&) (struct Cancellable * const this, const struct SlotCancelledCallback & slot)
{
  void * slot_copy.4;
  gulong D.97579;
  struct GCancellable * D.97580;
  struct SlotCancelledCallback * slot_copy;

  slot_copy.4 = operator new (16);
  try
    {
      sigc::slot<void>::slot (slot_copy.4, slot);
    }
  catch
    {
      operator delete (slot_copy.4);
    }
  slot_copy = slot_copy.4;
  D.97580 = Gio::Cancellable::gobj (this);
  D.97579 = g_cancellable_connect (D.97580, slot_cancelled_proxy, slot_copy, delete_slot);
  return D.97579;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void] (struct slot * const this, const struct slot & src)
{
  struct slot0 * D.97585;

  D.97585 = &this->D.83876;
  sigc::slot0<void>::slot0 (D.97585, src);
  try
    {

    }
  catch
    {
      D.97585 = &this->D.83876;
      sigc::slot0<void>::~slot0 (D.97585);
    }
}


sigc::slot0<T_return>::slot0(const sigc::slot0<T_return>&) [with T_return = void] (struct slot0 * const this, const struct slot0 & src)
{
  const struct slot_base * D.97586;
  struct slot_base * D.97587;

  D.97586 = &src->D.83834;
  D.97587 = &this->D.83834;
  sigc::slot_base::slot_base (D.97587, D.97586);
  try
    {

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.97588;
  int (*__vtbl_ptr_type) () * D.97589;
  int (*__vtbl_ptr_type) () * D.97590;
  long int D.97591;
  sizetype D.97592;
  struct ObjectBase * D.97593;

  D.97589 = this->D.86042._vptr.Object;
  D.97590 = D.97589 + 18446744073709551592;
  D.97591 = MEM[(long int *)D.97590];
  D.97592 = (sizetype) D.97591;
  D.97593 = this + D.97592;
  D.97588 = D.97593->gobject_;
  return D.97588;
}


Glib::RefPtr<Gio::Cancellable> Glib::wrap(GCancellable*, bool) (struct GCancellable * object, bool take_copy)
{
  struct Cancellable * iftmp.5;
  int D.97597;
  struct ObjectBase * D.97598;

  D.97597 = (int) take_copy;
  D.97598 = Glib::wrap_auto (object, D.97597);
  if (D.97598 == 0B) goto <D.97599>; else goto <D.97600>;
  <D.97599>:
  iftmp.5 = 0B;
  goto <D.97601>;
  <D.97600>:
  iftmp.5 = __dynamic_cast (D.97598, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11CancellableE, -1);
  <D.97601>:
  Glib::RefPtr<Gio::Cancellable>::RefPtr (<retval>, iftmp.5);
  return <retval>;
}


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


const Glib::Class& Gio::Cancellable_Class::init() (struct Cancellable_Class * const this)
{
  long unsigned int D.97604;
  long unsigned int D.97607;
  struct Class * D.97608;
  const struct Class & D.97610;

  D.97604 = this->D.86086.gtype_;
  if (D.97604 == 0) goto <D.97605>; else goto <D.97606>;
  <D.97605>:
  this->D.86086.class_init_func_ = class_init_function;
  D.97607 = g_cancellable_get_type ();
  D.97608 = &this->D.86086;
  Glib::Class::register_derived_type (D.97608, D.97607);
  goto <D.97609>;
  <D.97606>:
  <D.97609>:
  D.97610 = &this->D.86086;
  return D.97610;
}


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

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
  klass->cancelled = cancelled_callback;
}


static void Gio::Cancellable_Class::cancelled_callback(GCancellable*) (struct GCancellable * self)
{
  bool retval.6;
  bool iftmp.7;
  bool D.97618;
  struct CppObjectType * const iftmp.8;
  int (*__vtbl_ptr_type) () * D.97628;
  int (*__vtbl_ptr_type) () * D.97629;
  int (*__vtbl_ptr_type) () D.97630;
  void * D.97631;
  struct GTypeClass * D.97634;
  void (*<Tfc8b>) (struct GCancellable *) D.97637;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97617>; else goto <D.97615>;
    <D.97617>:
    D.97618 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97618 != 0) goto <D.97619>; else goto <D.97615>;
    <D.97619>:
    iftmp.7 = 1;
    goto <D.97616>;
    <D.97615>:
    iftmp.7 = 0;
    <D.97616>:
    retval.6 = iftmp.7;
    if (retval.6 != 0) goto <D.97620>; else goto <D.97621>;
    <D.97620>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97623>; else goto <D.97624>;
      <D.97623>:
      iftmp.8 = 0B;
      goto <D.97625>;
      <D.97624>:
      iftmp.8 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio11CancellableE, -1);
      <D.97625>:
      obj = iftmp.8;
      if (obj != 0B) goto <D.97626>; else goto <D.97627>;
      <D.97626>:
      try
        {
          D.97628 = obj->D.86042._vptr.Object;
          D.97629 = D.97628 + 16;
          D.97630 = *D.97629;
          OBJ_TYPE_REF(D.97630;(struct Cancellable)obj->2) (obj);
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97631 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97631);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97632>;
      <D.97627>:
      <D.97632>:
    }
    goto <D.97633>;
    <D.97621>:
    <D.97633>:
  }
  D.97634 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.97634);
  if (base != 0B) goto <D.97635>; else goto <D.97636>;
  <D.97635>:
  D.97637 = base->cancelled;
  if (D.97637 != 0B) goto <D.97638>; else goto <D.97639>;
  <D.97638>:
  D.97637 = base->cancelled;
  D.97637 (self);
  goto <D.97640>;
  <D.97639>:
  <D.97640>:
  <D.97636>:
}


static Glib::ObjectBase* Gio::Cancellable_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.97648;
  struct ObjectBase * iftmp.9;
  void * D.96699;
  void * D.97650;
  int (*__vtbl_ptr_type) () * D.97653;
  int (*__vtbl_ptr_type) () * D.97654;
  long int D.97655;
  sizetype D.97656;

  D.96699 = operator new (48);
  try
    {
      Gio::Cancellable::Cancellable (D.96699, object);
    }
  catch
    {
      operator delete (D.96699);
    }
  D.97650 = D.96699;
  if (D.97650 != 0B) goto <D.97651>; else goto <D.97652>;
  <D.97651>:
  D.97653 = MEM[(struct Cancellable *)D.97650].D.86042._vptr.Object;
  D.97654 = D.97653 + 18446744073709551592;
  D.97655 = MEM[(long int *)D.97654];
  D.97656 = (sizetype) D.97655;
  iftmp.9 = D.97650 + D.97656;
  goto <D.97657>;
  <D.97652>:
  iftmp.9 = 0B;
  <D.97657>:
  D.97648 = iftmp.9;
  return D.97648;
}


GCancellable* Gio::Cancellable::gobj_copy() (struct Cancellable * const this)
{
  int (*__vtbl_ptr_type) () * D.97661;
  int (*__vtbl_ptr_type) () * D.97662;
  long int D.97663;
  sizetype D.97664;
  struct ObjectBase * D.97665;
  int (*__vtbl_ptr_type) () * D.97666;
  int (*__vtbl_ptr_type) () * D.97667;
  int (*__vtbl_ptr_type) () D.97668;
  struct GCancellable * D.97669;

  D.97661 = this->D.86042._vptr.Object;
  D.97662 = D.97661 + 18446744073709551592;
  D.97663 = MEM[(long int *)D.97662];
  D.97664 = (sizetype) D.97663;
  D.97665 = this + D.97664;
  D.97661 = this->D.86042._vptr.Object;
  D.97662 = D.97661 + 18446744073709551592;
  D.97663 = MEM[(long int *)D.97662];
  D.97664 = (sizetype) D.97663;
  D.97665 = this + D.97664;
  D.97666 = D.97665->_vptr.ObjectBase;
  D.97667 = D.97666 + 16;
  D.97668 = *D.97667;
  D.97661 = this->D.86042._vptr.Object;
  D.97662 = D.97661 + 18446744073709551592;
  D.97663 = MEM[(long int *)D.97662];
  D.97664 = (sizetype) D.97663;
  D.97665 = this + D.97664;
  OBJ_TYPE_REF(D.97668;(const struct ObjectBase)D.97665->2) (D.97665);
  D.97669 = Gio::Cancellable::gobj (this);
  return D.97669;
}


Gio::Cancellable::Cancellable(const Glib::ConstructParams&) (struct Cancellable * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.97673;
  const void * * iftmp.10;
  struct ObjectBase * D.97681;
  const void * * iftmp.11;
  struct Object * D.97687;
  int (*__vtbl_ptr_type) () * iftmp.12;
  sizetype iftmp.13;
  int (*__vtbl_ptr_type) () * D.97695;
  int (*__vtbl_ptr_type) () * D.97696;
  long int D.97697;
  struct ObjectBase * D.97699;
  int (*__vtbl_ptr_type) () * iftmp.14;
  const void * * iftmp.15;
  const void * * iftmp.16;

  if (0 != 0) goto <D.97671>; else goto <D.97672>;
  <D.97671>:
  D.97673 = &this->D.86045;
  sigc::trackable::trackable (D.97673);
  goto <D.97674>;
  <D.97672>:
  <D.97674>:
  try
    {
      if (0 != 0) goto <D.97675>; else goto <D.97676>;
      <D.97675>:
      if (0 == 0) goto <D.97678>; else goto <D.97679>;
      <D.97678>:
      iftmp.10 = __vtt_parm + 32;
      goto <D.97680>;
      <D.97679>:
      iftmp.10 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.97680>:
      D.97681 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.97681, iftmp.10);
      goto <D.97682>;
      <D.97676>:
      <D.97682>:
      try
        {
          if (0 == 0) goto <D.97684>; else goto <D.97685>;
          <D.97684>:
          iftmp.11 = __vtt_parm + 8;
          goto <D.97686>;
          <D.97685>:
          iftmp.11 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
          <D.97686>:
          D.97687 = &this->D.86042;
          Glib::Object::Object (D.97687, iftmp.11, construct_params);
          try
            {
              if (0 == 0) goto <D.97689>; else goto <D.97690>;
              <D.97689>:
              iftmp.12 = *__vtt_parm;
              goto <D.97691>;
              <D.97690>:
              iftmp.12 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.97691>:
              this->D.86042._vptr.Object = iftmp.12;
              if (0 == 0) goto <D.97693>; else goto <D.97694>;
              <D.97693>:
              D.97695 = this->D.86042._vptr.Object;
              D.97696 = D.97695 + 18446744073709551592;
              D.97697 = MEM[(long int *)D.97696];
              iftmp.13 = (sizetype) D.97697;
              goto <D.97698>;
              <D.97694>:
              iftmp.13 = 8;
              <D.97698>:
              D.97699 = this + iftmp.13;
              if (0 == 0) goto <D.97701>; else goto <D.97702>;
              <D.97701>:
              iftmp.14 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.97703>;
              <D.97702>:
              iftmp.14 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.97703>:
              D.97699->_vptr.ObjectBase = iftmp.14;
            }
          catch
            {
              if (0 == 0) goto <D.97705>; else goto <D.97706>;
              <D.97705>:
              iftmp.15 = __vtt_parm + 8;
              goto <D.97707>;
              <D.97706>:
              iftmp.15 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.97707>:
              D.97687 = &this->D.86042;
              Glib::Object::~Object (D.97687, iftmp.15);
            }
        }
      catch
        {
          if (0 != 0) goto <D.97708>; else goto <D.97709>;
          <D.97708>:
          if (0 == 0) goto <D.97711>; else goto <D.97712>;
          <D.97711>:
          iftmp.16 = __vtt_parm + 32;
          goto <D.97713>;
          <D.97712>:
          iftmp.16 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.97713>:
          D.97681 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.97681, iftmp.16);
          goto <D.97714>;
          <D.97709>:
          <D.97714>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.97715>; else goto <D.97716>;
      <D.97715>:
      D.97673 = &this->D.86045;
      sigc::trackable::~trackable (D.97673);
      goto <D.97717>;
      <D.97716>:
      <D.97717>:
    }
}


Gio::Cancellable::Cancellable(const Glib::ConstructParams&) (struct Cancellable * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.97722;
  const void * * iftmp.17;
  struct ObjectBase * D.97730;
  const void * * iftmp.18;
  struct Object * D.97736;
  int (*__vtbl_ptr_type) () * iftmp.19;
  const void * * D.97740;
  sizetype iftmp.20;
  int (*__vtbl_ptr_type) () * D.97745;
  int (*__vtbl_ptr_type) () * D.97746;
  long int D.97747;
  struct ObjectBase * D.97749;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * iftmp.22;
  const void * * iftmp.23;

  if (1 != 0) goto <D.97720>; else goto <D.97721>;
  <D.97720>:
  D.97722 = &this->D.86045;
  sigc::trackable::trackable (D.97722);
  goto <D.97723>;
  <D.97721>:
  <D.97723>:
  try
    {
      if (1 != 0) goto <D.97724>; else goto <D.97725>;
      <D.97724>:
      if (1 == 0) goto <D.97727>; else goto <D.97728>;
      <D.97727>:
      iftmp.17 = 32B;
      goto <D.97729>;
      <D.97728>:
      iftmp.17 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.97729>:
      D.97730 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.97730, iftmp.17);
      goto <D.97731>;
      <D.97725>:
      <D.97731>:
      try
        {
          if (1 == 0) goto <D.97733>; else goto <D.97734>;
          <D.97733>:
          iftmp.18 = 8B;
          goto <D.97735>;
          <D.97734>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
          <D.97735>:
          D.97736 = &this->D.86042;
          Glib::Object::Object (D.97736, iftmp.18, construct_params);
          try
            {
              if (1 == 0) goto <D.97738>; else goto <D.97739>;
              <D.97738>:
              D.97740 = 0B;
              iftmp.19 = *D.97740;
              goto <D.97741>;
              <D.97739>:
              iftmp.19 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.97741>:
              this->D.86042._vptr.Object = iftmp.19;
              if (1 == 0) goto <D.97743>; else goto <D.97744>;
              <D.97743>:
              D.97745 = this->D.86042._vptr.Object;
              D.97746 = D.97745 + 18446744073709551592;
              D.97747 = MEM[(long int *)D.97746];
              iftmp.20 = (sizetype) D.97747;
              goto <D.97748>;
              <D.97744>:
              iftmp.20 = 8;
              <D.97748>:
              D.97749 = this + iftmp.20;
              if (1 == 0) goto <D.97751>; else goto <D.97752>;
              <D.97751>:
              iftmp.21 = MEM[(const void * *)0B + 24B];
              goto <D.97753>;
              <D.97752>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.97753>:
              D.97749->_vptr.ObjectBase = iftmp.21;
            }
          catch
            {
              if (1 == 0) goto <D.97755>; else goto <D.97756>;
              <D.97755>:
              iftmp.22 = 8B;
              goto <D.97757>;
              <D.97756>:
              iftmp.22 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.97757>:
              D.97736 = &this->D.86042;
              Glib::Object::~Object (D.97736, iftmp.22);
            }
        }
      catch
        {
          if (1 != 0) goto <D.97758>; else goto <D.97759>;
          <D.97758>:
          if (1 == 0) goto <D.97761>; else goto <D.97762>;
          <D.97761>:
          iftmp.23 = 32B;
          goto <D.97763>;
          <D.97762>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.97763>:
          D.97730 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.97730, iftmp.23);
          goto <D.97764>;
          <D.97759>:
          <D.97764>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.97765>; else goto <D.97766>;
      <D.97765>:
      D.97722 = &this->D.86045;
      sigc::trackable::~trackable (D.97722);
      goto <D.97767>;
      <D.97766>:
      <D.97767>:
    }
}


Gio::Cancellable::Cancellable(GCancellable*) (struct Cancellable * const this, const void * * __vtt_parm, struct GCancellable * castitem)
{
  struct trackable * D.97772;
  const void * * iftmp.24;
  struct ObjectBase * D.97780;
  const void * * iftmp.25;
  struct Object * D.97786;
  int (*__vtbl_ptr_type) () * iftmp.26;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.97794;
  int (*__vtbl_ptr_type) () * D.97795;
  long int D.97796;
  struct ObjectBase * D.97798;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * iftmp.29;
  const void * * iftmp.30;

  if (0 != 0) goto <D.97770>; else goto <D.97771>;
  <D.97770>:
  D.97772 = &this->D.86045;
  sigc::trackable::trackable (D.97772);
  goto <D.97773>;
  <D.97771>:
  <D.97773>:
  try
    {
      if (0 != 0) goto <D.97774>; else goto <D.97775>;
      <D.97774>:
      if (0 == 0) goto <D.97777>; else goto <D.97778>;
      <D.97777>:
      iftmp.24 = __vtt_parm + 32;
      goto <D.97779>;
      <D.97778>:
      iftmp.24 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.97779>:
      D.97780 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.97780, iftmp.24);
      goto <D.97781>;
      <D.97775>:
      <D.97781>:
      try
        {
          if (0 == 0) goto <D.97783>; else goto <D.97784>;
          <D.97783>:
          iftmp.25 = __vtt_parm + 8;
          goto <D.97785>;
          <D.97784>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
          <D.97785>:
          D.97786 = &this->D.86042;
          Glib::Object::Object (D.97786, iftmp.25, castitem);
          try
            {
              if (0 == 0) goto <D.97788>; else goto <D.97789>;
              <D.97788>:
              iftmp.26 = *__vtt_parm;
              goto <D.97790>;
              <D.97789>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.97790>:
              this->D.86042._vptr.Object = iftmp.26;
              if (0 == 0) goto <D.97792>; else goto <D.97793>;
              <D.97792>:
              D.97794 = this->D.86042._vptr.Object;
              D.97795 = D.97794 + 18446744073709551592;
              D.97796 = MEM[(long int *)D.97795];
              iftmp.27 = (sizetype) D.97796;
              goto <D.97797>;
              <D.97793>:
              iftmp.27 = 8;
              <D.97797>:
              D.97798 = this + iftmp.27;
              if (0 == 0) goto <D.97800>; else goto <D.97801>;
              <D.97800>:
              iftmp.28 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.97802>;
              <D.97801>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.97802>:
              D.97798->_vptr.ObjectBase = iftmp.28;
            }
          catch
            {
              if (0 == 0) goto <D.97804>; else goto <D.97805>;
              <D.97804>:
              iftmp.29 = __vtt_parm + 8;
              goto <D.97806>;
              <D.97805>:
              iftmp.29 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.97806>:
              D.97786 = &this->D.86042;
              Glib::Object::~Object (D.97786, iftmp.29);
            }
        }
      catch
        {
          if (0 != 0) goto <D.97807>; else goto <D.97808>;
          <D.97807>:
          if (0 == 0) goto <D.97810>; else goto <D.97811>;
          <D.97810>:
          iftmp.30 = __vtt_parm + 32;
          goto <D.97812>;
          <D.97811>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.97812>:
          D.97780 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.97780, iftmp.30);
          goto <D.97813>;
          <D.97808>:
          <D.97813>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.97814>; else goto <D.97815>;
      <D.97814>:
      D.97772 = &this->D.86045;
      sigc::trackable::~trackable (D.97772);
      goto <D.97816>;
      <D.97815>:
      <D.97816>:
    }
}


Gio::Cancellable::Cancellable(GCancellable*) (struct Cancellable * const this, struct GCancellable * castitem)
{
  struct trackable * D.97821;
  const void * * iftmp.31;
  struct ObjectBase * D.97829;
  const void * * iftmp.32;
  struct Object * D.97835;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * D.97839;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.97844;
  int (*__vtbl_ptr_type) () * D.97845;
  long int D.97846;
  struct ObjectBase * D.97848;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * iftmp.36;
  const void * * iftmp.37;

  if (1 != 0) goto <D.97819>; else goto <D.97820>;
  <D.97819>:
  D.97821 = &this->D.86045;
  sigc::trackable::trackable (D.97821);
  goto <D.97822>;
  <D.97820>:
  <D.97822>:
  try
    {
      if (1 != 0) goto <D.97823>; else goto <D.97824>;
      <D.97823>:
      if (1 == 0) goto <D.97826>; else goto <D.97827>;
      <D.97826>:
      iftmp.31 = 32B;
      goto <D.97828>;
      <D.97827>:
      iftmp.31 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.97828>:
      D.97829 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.97829, iftmp.31);
      goto <D.97830>;
      <D.97824>:
      <D.97830>:
      try
        {
          if (1 == 0) goto <D.97832>; else goto <D.97833>;
          <D.97832>:
          iftmp.32 = 8B;
          goto <D.97834>;
          <D.97833>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
          <D.97834>:
          D.97835 = &this->D.86042;
          Glib::Object::Object (D.97835, iftmp.32, castitem);
          try
            {
              if (1 == 0) goto <D.97837>; else goto <D.97838>;
              <D.97837>:
              D.97839 = 0B;
              iftmp.33 = *D.97839;
              goto <D.97840>;
              <D.97838>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.97840>:
              this->D.86042._vptr.Object = iftmp.33;
              if (1 == 0) goto <D.97842>; else goto <D.97843>;
              <D.97842>:
              D.97844 = this->D.86042._vptr.Object;
              D.97845 = D.97844 + 18446744073709551592;
              D.97846 = MEM[(long int *)D.97845];
              iftmp.34 = (sizetype) D.97846;
              goto <D.97847>;
              <D.97843>:
              iftmp.34 = 8;
              <D.97847>:
              D.97848 = this + iftmp.34;
              if (1 == 0) goto <D.97850>; else goto <D.97851>;
              <D.97850>:
              iftmp.35 = MEM[(const void * *)0B + 24B];
              goto <D.97852>;
              <D.97851>:
              iftmp.35 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.97852>:
              D.97848->_vptr.ObjectBase = iftmp.35;
            }
          catch
            {
              if (1 == 0) goto <D.97854>; else goto <D.97855>;
              <D.97854>:
              iftmp.36 = 8B;
              goto <D.97856>;
              <D.97855>:
              iftmp.36 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.97856>:
              D.97835 = &this->D.86042;
              Glib::Object::~Object (D.97835, iftmp.36);
            }
        }
      catch
        {
          if (1 != 0) goto <D.97857>; else goto <D.97858>;
          <D.97857>:
          if (1 == 0) goto <D.97860>; else goto <D.97861>;
          <D.97860>:
          iftmp.37 = 32B;
          goto <D.97862>;
          <D.97861>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.97862>:
          D.97829 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.97829, iftmp.37);
          goto <D.97863>;
          <D.97858>:
          <D.97863>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.97864>; else goto <D.97865>;
      <D.97864>:
      D.97821 = &this->D.86045;
      sigc::trackable::~trackable (D.97821);
      goto <D.97866>;
      <D.97865>:
      <D.97866>:
    }
}


Gio::Cancellable::~Cancellable() (struct Cancellable * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.38;
  sizetype iftmp.39;
  int (*__vtbl_ptr_type) () * D.97876;
  int (*__vtbl_ptr_type) () * D.97877;
  long int D.97878;
  struct ObjectBase * D.97880;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * iftmp.41;
  struct Object * D.97889;
  int D.97890;
  const void * * iftmp.42;
  struct ObjectBase * D.97897;
  struct trackable * D.97901;
  int D.97903;

  {
    if (0 == 0) goto <D.97870>; else goto <D.97871>;
    <D.97870>:
    iftmp.38 = *__vtt_parm;
    goto <D.97872>;
    <D.97871>:
    iftmp.38 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
    <D.97872>:
    this->D.86042._vptr.Object = iftmp.38;
    if (0 == 0) goto <D.97874>; else goto <D.97875>;
    <D.97874>:
    D.97876 = this->D.86042._vptr.Object;
    D.97877 = D.97876 + 18446744073709551592;
    D.97878 = MEM[(long int *)D.97877];
    iftmp.39 = (sizetype) D.97878;
    goto <D.97879>;
    <D.97875>:
    iftmp.39 = 8;
    <D.97879>:
    D.97880 = this + iftmp.39;
    if (0 == 0) goto <D.97882>; else goto <D.97883>;
    <D.97882>:
    iftmp.40 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.97884>;
    <D.97883>:
    iftmp.40 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
    <D.97884>:
    D.97880->_vptr.ObjectBase = iftmp.40;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.97886>; else goto <D.97887>;
                    <D.97886>:
                    iftmp.41 = __vtt_parm + 8;
                    goto <D.97888>;
                    <D.97887>:
                    iftmp.41 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
                    <D.97888>:
                    D.97889 = &this->D.86042;
                    Glib::Object::~Object (D.97889, iftmp.41);
                  }
              }
            finally
              {
                D.97890 = 0;
                if (D.97890 != 0) goto <D.97891>; else goto <D.97892>;
                <D.97891>:
                if (0 == 0) goto <D.97894>; else goto <D.97895>;
                <D.97894>:
                iftmp.42 = __vtt_parm + 32;
                goto <D.97896>;
                <D.97895>:
                iftmp.42 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
                <D.97896>:
                D.97897 = &this->D.86044;
                Glib::ObjectBase::~ObjectBase (D.97897, iftmp.42);
                goto <D.97898>;
                <D.97892>:
                <D.97898>:
              }
          }
        finally
          {
            D.97890 = 0;
            if (D.97890 != 0) goto <D.97899>; else goto <D.97900>;
            <D.97899>:
            D.97901 = &this->D.86045;
            sigc::trackable::~trackable (D.97901);
            goto <D.97902>;
            <D.97900>:
            <D.97902>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96727>:
  D.97903 = 0;
  if (D.97903 != 0) goto <D.97904>; else goto <D.97905>;
  <D.97904>:
  operator delete (this);
  goto <D.97906>;
  <D.97905>:
  <D.97906>:
}


virtual Gio::Cancellable::~Cancellable() (struct Cancellable * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.43;
  const void * * D.97922;
  sizetype iftmp.44;
  int (*__vtbl_ptr_type) () * D.97927;
  int (*__vtbl_ptr_type) () * D.97928;
  long int D.97929;
  struct ObjectBase * D.97931;
  int (*__vtbl_ptr_type) () * iftmp.45;
  const void * * iftmp.46;
  struct Object * D.97940;
  int D.97941;
  const void * * iftmp.47;
  struct ObjectBase * D.97948;
  struct trackable * D.97952;
  int D.97954;

  {
    if (2 == 0) goto <D.97920>; else goto <D.97921>;
    <D.97920>:
    D.97922 = 0B;
    iftmp.43 = *D.97922;
    goto <D.97923>;
    <D.97921>:
    iftmp.43 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
    <D.97923>:
    this->D.86042._vptr.Object = iftmp.43;
    if (2 == 0) goto <D.97925>; else goto <D.97926>;
    <D.97925>:
    D.97927 = this->D.86042._vptr.Object;
    D.97928 = D.97927 + 18446744073709551592;
    D.97929 = MEM[(long int *)D.97928];
    iftmp.44 = (sizetype) D.97929;
    goto <D.97930>;
    <D.97926>:
    iftmp.44 = 8;
    <D.97930>:
    D.97931 = this + iftmp.44;
    if (2 == 0) goto <D.97933>; else goto <D.97934>;
    <D.97933>:
    iftmp.45 = MEM[(const void * *)0B + 24B];
    goto <D.97935>;
    <D.97934>:
    iftmp.45 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
    <D.97935>:
    D.97931->_vptr.ObjectBase = iftmp.45;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.97937>; else goto <D.97938>;
                    <D.97937>:
                    iftmp.46 = 8B;
                    goto <D.97939>;
                    <D.97938>:
                    iftmp.46 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
                    <D.97939>:
                    D.97940 = &this->D.86042;
                    Glib::Object::~Object (D.97940, iftmp.46);
                  }
              }
            finally
              {
                D.97941 = 2;
                if (D.97941 != 0) goto <D.97942>; else goto <D.97943>;
                <D.97942>:
                if (2 == 0) goto <D.97945>; else goto <D.97946>;
                <D.97945>:
                iftmp.47 = 32B;
                goto <D.97947>;
                <D.97946>:
                iftmp.47 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
                <D.97947>:
                D.97948 = &this->D.86044;
                Glib::ObjectBase::~ObjectBase (D.97948, iftmp.47);
                goto <D.97949>;
                <D.97943>:
                <D.97949>:
              }
          }
        finally
          {
            D.97941 = 2;
            if (D.97941 != 0) goto <D.97950>; else goto <D.97951>;
            <D.97950>:
            D.97952 = &this->D.86045;
            sigc::trackable::~trackable (D.97952);
            goto <D.97953>;
            <D.97951>:
            <D.97953>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96730>:
  D.97954 = 0;
  if (D.97954 != 0) goto <D.97955>; else goto <D.97956>;
  <D.97955>:
  operator delete (this);
  goto <D.97957>;
  <D.97956>:
  <D.97957>:
}


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


static GType Gio::Cancellable::get_type() ()
{
  GType D.97970;
  const struct Class & D.97971;

  D.97971 = Gio::Cancellable_Class::init (&cancellable_class_);
  D.97970 = Glib::Class::get_type (D.97971);
  return D.97970;
}


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

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


static GType Gio::Cancellable::get_base_type() ()
{
  GType D.97976;

  D.97976 = g_cancellable_get_type ();
  return D.97976;
}


Gio::Cancellable::Cancellable() (struct Cancellable * const this, const void * * __vtt_parm)
{
  struct trackable * D.97981;
  const void * * iftmp.48;
  struct ObjectBase * D.97989;
  struct ConstructParams D.96753;
  const struct Class & D.97991;
  const void * * iftmp.49;
  struct Object * D.97996;
  int (*__vtbl_ptr_type) () * iftmp.50;
  sizetype iftmp.51;
  int (*__vtbl_ptr_type) () * D.98004;
  int (*__vtbl_ptr_type) () * D.98005;
  long int D.98006;
  struct ObjectBase * D.98008;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * iftmp.53;
  const void * * iftmp.54;

  if (0 != 0) goto <D.97979>; else goto <D.97980>;
  <D.97979>:
  D.97981 = &this->D.86045;
  sigc::trackable::trackable (D.97981);
  goto <D.97982>;
  <D.97980>:
  <D.97982>:
  try
    {
      if (0 != 0) goto <D.97983>; else goto <D.97984>;
      <D.97983>:
      if (0 == 0) goto <D.97986>; else goto <D.97987>;
      <D.97986>:
      iftmp.48 = __vtt_parm + 32;
      goto <D.97988>;
      <D.97987>:
      iftmp.48 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.97988>:
      D.97989 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.97989, iftmp.48, 0B);
      goto <D.97990>;
      <D.97984>:
      <D.97990>:
      try
        {
          D.97991 = Gio::Cancellable_Class::init (&cancellable_class_);
          Glib::ConstructParams::ConstructParams (&D.96753, D.97991);
          try
            {
              if (0 == 0) goto <D.97993>; else goto <D.97994>;
              <D.97993>:
              iftmp.49 = __vtt_parm + 8;
              goto <D.97995>;
              <D.97994>:
              iftmp.49 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.97995>:
              D.97996 = &this->D.86042;
              Glib::Object::Object (D.97996, iftmp.49, &D.96753);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.96753);
              D.96753 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.97998>; else goto <D.97999>;
              <D.97998>:
              iftmp.50 = *__vtt_parm;
              goto <D.98000>;
              <D.97999>:
              iftmp.50 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.98000>:
              this->D.86042._vptr.Object = iftmp.50;
              if (0 == 0) goto <D.98002>; else goto <D.98003>;
              <D.98002>:
              D.98004 = this->D.86042._vptr.Object;
              D.98005 = D.98004 + 18446744073709551592;
              D.98006 = MEM[(long int *)D.98005];
              iftmp.51 = (sizetype) D.98006;
              goto <D.98007>;
              <D.98003>:
              iftmp.51 = 8;
              <D.98007>:
              D.98008 = this + iftmp.51;
              if (0 == 0) goto <D.98010>; else goto <D.98011>;
              <D.98010>:
              iftmp.52 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98012>;
              <D.98011>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.98012>:
              D.98008->_vptr.ObjectBase = iftmp.52;
            }
          catch
            {
              if (0 == 0) goto <D.98014>; else goto <D.98015>;
              <D.98014>:
              iftmp.53 = __vtt_parm + 8;
              goto <D.98016>;
              <D.98015>:
              iftmp.53 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.98016>:
              D.97996 = &this->D.86042;
              Glib::Object::~Object (D.97996, iftmp.53);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98017>; else goto <D.98018>;
          <D.98017>:
          if (0 == 0) goto <D.98020>; else goto <D.98021>;
          <D.98020>:
          iftmp.54 = __vtt_parm + 32;
          goto <D.98022>;
          <D.98021>:
          iftmp.54 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.98022>:
          D.97989 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.97989, iftmp.54);
          goto <D.98023>;
          <D.98018>:
          <D.98023>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98024>; else goto <D.98025>;
      <D.98024>:
      D.97981 = &this->D.86045;
      sigc::trackable::~trackable (D.97981);
      goto <D.98026>;
      <D.98025>:
      <D.98026>:
    }
}


Gio::Cancellable::Cancellable() (struct Cancellable * const this)
{
  struct trackable * D.98033;
  const void * * iftmp.55;
  struct ObjectBase * D.98041;
  struct ConstructParams D.96755;
  const struct Class & D.98043;
  const void * * iftmp.56;
  struct Object * D.98048;
  int (*__vtbl_ptr_type) () * iftmp.57;
  const void * * D.98052;
  sizetype iftmp.58;
  int (*__vtbl_ptr_type) () * D.98057;
  int (*__vtbl_ptr_type) () * D.98058;
  long int D.98059;
  struct ObjectBase * D.98061;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * iftmp.60;
  const void * * iftmp.61;

  if (1 != 0) goto <D.98031>; else goto <D.98032>;
  <D.98031>:
  D.98033 = &this->D.86045;
  sigc::trackable::trackable (D.98033);
  goto <D.98034>;
  <D.98032>:
  <D.98034>:
  try
    {
      if (1 != 0) goto <D.98035>; else goto <D.98036>;
      <D.98035>:
      if (1 == 0) goto <D.98038>; else goto <D.98039>;
      <D.98038>:
      iftmp.55 = 32B;
      goto <D.98040>;
      <D.98039>:
      iftmp.55 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
      <D.98040>:
      D.98041 = &this->D.86044;
      Glib::ObjectBase::ObjectBase (D.98041, iftmp.55, 0B);
      goto <D.98042>;
      <D.98036>:
      <D.98042>:
      try
        {
          D.98043 = Gio::Cancellable_Class::init (&cancellable_class_);
          Glib::ConstructParams::ConstructParams (&D.96755, D.98043);
          try
            {
              if (1 == 0) goto <D.98045>; else goto <D.98046>;
              <D.98045>:
              iftmp.56 = 8B;
              goto <D.98047>;
              <D.98046>:
              iftmp.56 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.98047>:
              D.98048 = &this->D.86042;
              Glib::Object::Object (D.98048, iftmp.56, &D.96755);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.96755);
              D.96755 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.98050>; else goto <D.98051>;
              <D.98050>:
              D.98052 = 0B;
              iftmp.57 = *D.98052;
              goto <D.98053>;
              <D.98051>:
              iftmp.57 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 32B];
              <D.98053>:
              this->D.86042._vptr.Object = iftmp.57;
              if (1 == 0) goto <D.98055>; else goto <D.98056>;
              <D.98055>:
              D.98057 = this->D.86042._vptr.Object;
              D.98058 = D.98057 + 18446744073709551592;
              D.98059 = MEM[(long int *)D.98058];
              iftmp.58 = (sizetype) D.98059;
              goto <D.98060>;
              <D.98056>:
              iftmp.58 = 8;
              <D.98060>:
              D.98061 = this + iftmp.58;
              if (1 == 0) goto <D.98063>; else goto <D.98064>;
              <D.98063>:
              iftmp.59 = MEM[(const void * *)0B + 24B];
              goto <D.98065>;
              <D.98064>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio11CancellableE + 120B];
              <D.98065>:
              D.98061->_vptr.ObjectBase = iftmp.59;
            }
          catch
            {
              if (1 == 0) goto <D.98067>; else goto <D.98068>;
              <D.98067>:
              iftmp.60 = 8B;
              goto <D.98069>;
              <D.98068>:
              iftmp.60 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 8B];
              <D.98069>:
              D.98048 = &this->D.86042;
              Glib::Object::~Object (D.98048, iftmp.60);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98070>; else goto <D.98071>;
          <D.98070>:
          if (1 == 0) goto <D.98073>; else goto <D.98074>;
          <D.98073>:
          iftmp.61 = 32B;
          goto <D.98075>;
          <D.98074>:
          iftmp.61 = &MEM[(void *)&_ZTTN3Gio11CancellableE + 32B];
          <D.98075>:
          D.98041 = &this->D.86044;
          Glib::ObjectBase::~ObjectBase (D.98041, iftmp.61);
          goto <D.98076>;
          <D.98071>:
          <D.98076>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98077>; else goto <D.98078>;
      <D.98077>:
      D.98033 = &this->D.86045;
      sigc::trackable::~trackable (D.98033);
      goto <D.98079>;
      <D.98078>:
      <D.98079>:
    }
}


static Glib::RefPtr<Gio::Cancellable> Gio::Cancellable::create() ()
{
  void * D.96759;

  D.96759 = operator new (48);
  try
    {
      Gio::Cancellable::Cancellable (D.96759);
    }
  catch
    {
      operator delete (D.96759);
    }
  Glib::RefPtr<Gio::Cancellable>::RefPtr (<retval>, D.96759);
  return <retval>;
}


bool Gio::Cancellable::is_cancelled() const (const struct Cancellable * const this)
{
  bool D.98088;
  const struct GCancellable * D.98089;
  int D.98090;

  D.98089 = Gio::Cancellable::gobj (this);
  D.98090 = g_cancellable_is_cancelled (D.98089);
  D.98088 = D.98090 != 0;
  return D.98088;
}


const GCancellable* Gio::Cancellable::gobj() const (const struct Cancellable * const this)
{
  const struct GCancellable * D.98093;
  int (*__vtbl_ptr_type) () * D.98094;
  int (*__vtbl_ptr_type) () * D.98095;
  long int D.98096;
  sizetype D.98097;
  const struct ObjectBase * D.98098;

  D.98094 = this->D.86042._vptr.Object;
  D.98095 = D.98094 + 18446744073709551592;
  D.98096 = MEM[(long int *)D.98095];
  D.98097 = (sizetype) D.98096;
  D.98098 = this + D.98097;
  D.98093 = D.98098->gobject_;
  return D.98093;
}


int Gio::Cancellable::get_fd() const (const struct Cancellable * const this)
{
  int D.98100;
  const struct GCancellable * D.98101;

  D.98101 = Gio::Cancellable::gobj (this);
  D.98100 = g_cancellable_get_fd (D.98101);
  return D.98100;
}


bool Gio::Cancellable::make_pollfd(GPollFD*) (struct Cancellable * const this, struct GPollFD * pollfd)
{
  bool D.98104;
  struct GCancellable * D.98105;
  int D.98106;

  D.98105 = Gio::Cancellable::gobj (this);
  D.98106 = g_cancellable_make_pollfd (D.98105, pollfd);
  D.98104 = D.98106 != 0;
  return D.98104;
}


void Gio::Cancellable::release_fd() (struct Cancellable * const this)
{
  struct GCancellable * D.98109;

  D.98109 = Gio::Cancellable::gobj (this);
  g_cancellable_release_fd (D.98109);
}


void Gio::Cancellable::cancel() (struct Cancellable * const this)
{
  struct GCancellable * D.98110;

  D.98110 = Gio::Cancellable::gobj (this);
  g_cancellable_cancel (D.98110);
}


static Glib::RefPtr<Gio::Cancellable> Gio::Cancellable::get_current() ()
{
  struct GCancellable * D.98112;
  bool retval.62;
  struct Cancellable * D.98116;
  int (*__vtbl_ptr_type) () * D.98117;
  int (*__vtbl_ptr_type) () * D.98118;
  long int D.98119;
  sizetype D.98120;
  struct ObjectBase * D.98121;
  int (*__vtbl_ptr_type) () * D.98122;
  int (*__vtbl_ptr_type) () * D.98123;
  int (*__vtbl_ptr_type) () D.98124;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.98112 = g_cancellable_get_current ();
  *<retval> = Glib::wrap (D.98112, 0); [return slot optimization]
  try
    {
      retval.62 = Glib::RefPtr<Gio::Cancellable>::operator bool (<retval>);
      if (retval.62 != 0) goto <D.98114>; else goto <D.98115>;
      <D.98114>:
      D.98116 = Glib::RefPtr<Gio::Cancellable>::operator-> (<retval>);
      D.98117 = D.98116->D.86042._vptr.Object;
      D.98118 = D.98117 + 18446744073709551592;
      D.98119 = MEM[(long int *)D.98118];
      D.98120 = (sizetype) D.98119;
      D.98121 = D.98116 + D.98120;
      D.98117 = D.98116->D.86042._vptr.Object;
      D.98118 = D.98117 + 18446744073709551592;
      D.98119 = MEM[(long int *)D.98118];
      D.98120 = (sizetype) D.98119;
      D.98121 = D.98116 + D.98120;
      D.98122 = D.98121->_vptr.ObjectBase;
      D.98123 = D.98122 + 16;
      D.98124 = *D.98123;
      D.98117 = D.98116->D.86042._vptr.Object;
      D.98118 = D.98117 + 18446744073709551592;
      D.98119 = MEM[(long int *)D.98118];
      D.98120 = (sizetype) D.98119;
      D.98121 = D.98116 + D.98120;
      OBJ_TYPE_REF(D.98124;(const struct ObjectBase)D.98121->2) (D.98121);
      goto <D.98125>;
      <D.98115>:
      <D.98125>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::Cancellable>::~RefPtr (<retval>);
    }
}


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

  D.98130 = this->pCppObject_;
  D.98129 = D.98130 != 0B;
  return D.98129;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Cancellable] (struct RefPtr * const this)
{
  struct Cancellable * D.98134;
  int (*__vtbl_ptr_type) () * D.98137;
  int (*__vtbl_ptr_type) () * D.98138;
  long int D.98139;
  sizetype D.98140;
  struct ObjectBase * D.98141;
  int (*__vtbl_ptr_type) () * D.98142;
  int (*__vtbl_ptr_type) () * D.98143;
  int (*__vtbl_ptr_type) () D.98144;

  {
    try
      {
        D.98134 = this->pCppObject_;
        if (D.98134 != 0B) goto <D.98135>; else goto <D.98136>;
        <D.98135>:
        D.98134 = this->pCppObject_;
        D.98134 = this->pCppObject_;
        D.98137 = D.98134->D.86042._vptr.Object;
        D.98138 = D.98137 + 18446744073709551592;
        D.98139 = MEM[(long int *)D.98138];
        D.98140 = (sizetype) D.98139;
        D.98141 = D.98134 + D.98140;
        D.98134 = this->pCppObject_;
        D.98134 = this->pCppObject_;
        D.98137 = D.98134->D.86042._vptr.Object;
        D.98138 = D.98137 + 18446744073709551592;
        D.98139 = MEM[(long int *)D.98138];
        D.98140 = (sizetype) D.98139;
        D.98141 = D.98134 + D.98140;
        D.98142 = D.98141->_vptr.ObjectBase;
        D.98143 = D.98142 + 24;
        D.98144 = *D.98143;
        D.98134 = this->pCppObject_;
        D.98134 = this->pCppObject_;
        D.98137 = D.98134->D.86042._vptr.Object;
        D.98138 = D.98137 + 18446744073709551592;
        D.98139 = MEM[(long int *)D.98138];
        D.98140 = (sizetype) D.98139;
        D.98141 = D.98134 + D.98140;
        OBJ_TYPE_REF(D.98144;(const struct ObjectBase)D.98141->3) (D.98141);
        goto <D.98145>;
        <D.98136>:
        <D.98145>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97210>:
}


void Gio::Cancellable::push_current() (struct Cancellable * const this)
{
  struct GCancellable * D.98147;

  D.98147 = Gio::Cancellable::gobj (this);
  g_cancellable_push_current (D.98147);
}


void Gio::Cancellable::pop_current() (struct Cancellable * const this)
{
  struct GCancellable * D.98148;

  D.98148 = Gio::Cancellable::gobj (this);
  g_cancellable_pop_current (D.98148);
}


void Gio::Cancellable::reset() (struct Cancellable * const this)
{
  struct GCancellable * D.98149;

  D.98149 = Gio::Cancellable::gobj (this);
  g_cancellable_reset (D.98149);
}


void Gio::Cancellable::disconnect(gulong) (struct Cancellable * const this, gulong handler_id)
{
  struct GCancellable * D.98150;

  D.98150 = Gio::Cancellable::gobj (this);
  g_cancellable_disconnect (D.98150, handler_id);
}


Glib::SignalProxy0<void> Gio::Cancellable::signal_cancelled() (struct Cancellable * const this)
{
  int (*__vtbl_ptr_type) () * D.98152;
  int (*__vtbl_ptr_type) () * D.98153;
  long int D.98154;
  sizetype D.98155;
  struct ObjectBase * D.98156;

  D.98152 = this->D.86042._vptr.Object;
  D.98153 = D.98152 + 18446744073709551592;
  D.98154 = MEM[(long int *)D.98153];
  D.98155 = (sizetype) D.98154;
  D.98156 = this + D.98155;
  Glib::SignalProxy0<void>::SignalProxy0 (<retval>, D.98156, &Cancellable_signal_cancelled_info);
  return <retval>;
}


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

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

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


virtual void Gio::Cancellable::on_cancelled() (struct Cancellable * const this)
{
  int (*__vtbl_ptr_type) () * D.98159;
  int (*__vtbl_ptr_type) () * D.98160;
  long int D.98161;
  sizetype D.98162;
  struct ObjectBase * D.98163;
  struct GObject * D.98164;
  struct GTypeClass * D.98165;
  void (*<Tfc8b>) (struct GCancellable *) D.98168;
  struct GCancellable * D.98171;
  struct BaseClassType * const base;

  D.98159 = this->D.86042._vptr.Object;
  D.98160 = D.98159 + 18446744073709551592;
  D.98161 = MEM[(long int *)D.98160];
  D.98162 = (sizetype) D.98161;
  D.98163 = this + D.98162;
  D.98164 = D.98163->gobject_;
  D.98165 = MEM[(struct GTypeInstance *)D.98164].g_class;
  base = g_type_class_peek_parent (D.98165);
  if (base != 0B) goto <D.98166>; else goto <D.98167>;
  <D.98166>:
  D.98168 = base->cancelled;
  if (D.98168 != 0B) goto <D.98169>; else goto <D.98170>;
  <D.98169>:
  D.98168 = base->cancelled;
  D.98171 = Gio::Cancellable::gobj (this);
  D.98168 (D.98171);
  goto <D.98172>;
  <D.98170>:
  <D.98172>:
  <D.98167>:
}