Glib::RefPtr<Gio::PollableInputStream> Glib::wrap(GPollableInputStream*, bool) (struct GPollableInputStream * object, bool take_copy)
{
  int D.97743;
  struct PollableInputStream * D.97744;

  D.97743 = (int) take_copy;
  D.97744 = Glib::wrap_auto_interface<Gio::PollableInputStream> (object, D.97743);
  Glib::RefPtr<Gio::PollableInputStream>::RefPtr (<retval>, D.97744);
  return <retval>;
}


TInterface* Glib::wrap_auto_interface(GObject*, bool) [with TInterface = Gio::PollableInputStream; GObject = _GObject] (struct GObject * object, bool take_copy)
{
  struct PollableInputStream * D.97749;
  long unsigned int D.97752;
  struct PollableInputStream * iftmp.0;
  struct ObjectBase * pCppObject.1;
  const struct type_info * iftmp.2;
  int (*__vtbl_ptr_type) () * D.97766;
  const char * D.97768;
  void * result.3;
  bool D.97771;
  bool D.97772;
  int (*__vtbl_ptr_type) () * D.97775;
  int (*__vtbl_ptr_type) () * D.97776;
  long int D.97777;
  sizetype D.97778;
  struct ObjectBase * D.97779;
  int (*__vtbl_ptr_type) () * D.97780;
  int (*__vtbl_ptr_type) () * D.97781;
  int (*__vtbl_ptr_type) () D.97782;
  struct ObjectBase * pCppObject;
  struct PollableInputStream * result;

  if (object == 0B) goto <D.97747>; else goto <D.97748>;
  <D.97747>:
  D.97749 = 0B;
  return D.97749;
  <D.97748>:
  pCppObject = Glib::ObjectBase::_get_current_wrapper (object);
  if (pCppObject == 0B) goto <D.97750>; else goto <D.97751>;
  <D.97750>:
  D.97752 = Gio::PollableInputStream::get_base_type ();
  pCppObject = Glib::wrap_create_new_wrapper_for_interface (object, D.97752);
  goto <D.97753>;
  <D.97751>:
  <D.97753>:
  result = 0B;
  if (pCppObject != 0B) goto <D.97754>; else goto <D.97755>;
  <D.97754>:
  pCppObject.1 = pCppObject;
  if (pCppObject.1 == 0B) goto <D.97758>; else goto <D.97759>;
  <D.97758>:
  iftmp.0 = 0B;
  goto <D.97760>;
  <D.97759>:
  iftmp.0 = __dynamic_cast (pCppObject.1, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio19PollableInputStreamE, -1);
  <D.97760>:
  result = iftmp.0;
  if (result == 0B) goto <D.97761>; else goto <D.97762>;
  <D.97761>:
  if (pCppObject != 0B) goto <D.97764>; else goto <D.97765>;
  <D.97764>:
  D.97766 = pCppObject->_vptr.ObjectBase;
  iftmp.2 = MEM[(int (*__vtbl_ptr_type) () *)D.97766 + -8B];
  goto <D.97767>;
  <D.97765>:
  __cxa_bad_typeid ();
  <D.97767>:
  D.97768 = 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.97768);
  goto <D.97769>;
  <D.97762>:
  <D.97769>:
  goto <D.97770>;
  <D.97755>:
  result.3 = operator new (48);
  try
    {
      Gio::PollableInputStream::PollableInputStream (result.3, object);
    }
  catch
    {
      operator delete (result.3);
    }
  result = result.3;
  <D.97770>:
  D.97771 = result != 0B;
  D.97772 = D.97771 & take_copy;
  if (D.97772 != 0) goto <D.97773>; else goto <D.97774>;
  <D.97773>:
  D.97775 = result->D.86035._vptr.Interface;
  D.97776 = D.97775 + 18446744073709551592;
  D.97777 = MEM[(long int *)D.97776];
  D.97778 = (sizetype) D.97777;
  D.97779 = result + D.97778;
  D.97775 = result->D.86035._vptr.Interface;
  D.97776 = D.97775 + 18446744073709551592;
  D.97777 = MEM[(long int *)D.97776];
  D.97778 = (sizetype) D.97777;
  D.97779 = result + D.97778;
  D.97780 = D.97779->_vptr.ObjectBase;
  D.97781 = D.97780 + 16;
  D.97782 = *D.97781;
  D.97775 = result->D.86035._vptr.Interface;
  D.97776 = D.97775 + 18446744073709551592;
  D.97777 = MEM[(long int *)D.97776];
  D.97778 = (sizetype) D.97777;
  D.97779 = result + D.97778;
  OBJ_TYPE_REF(D.97782;(const struct ObjectBase)D.97779->2) (D.97779);
  goto <D.97783>;
  <D.97774>:
  <D.97783>:
  D.97749 = result;
  return D.97749;
}


const char* std::type_info::name() const (const struct type_info * const this)
{
  const char * D.97791;
  const char * iftmp.4;
  const char * D.97793;
  char D.97794;

  D.97793 = this->__name;
  D.97794 = *D.97793;
  if (D.97794 == 42) goto <D.97795>; else goto <D.97796>;
  <D.97795>:
  D.97793 = this->__name;
  iftmp.4 = D.97793 + 1;
  goto <D.97797>;
  <D.97796>:
  iftmp.4 = this->__name;
  <D.97797>:
  D.97791 = iftmp.4;
  return D.97791;
}


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


const Glib::Interface_Class& Gio::PollableInputStream_Class::init() (struct PollableInputStream_Class * const this)
{
  long unsigned int D.97799;
  long unsigned int D.97802;
  const struct Interface_Class & D.97804;

  D.97799 = this->D.96507.D.86058.gtype_;
  if (D.97799 == 0) goto <D.97800>; else goto <D.97801>;
  <D.97800>:
  this->D.96507.D.86058.class_init_func_ = iface_init_function;
  D.97802 = g_pollable_input_stream_get_type ();
  this->D.96507.D.86058.gtype_ = D.97802;
  goto <D.97803>;
  <D.97801>:
  <D.97803>:
  D.97804 = &this->D.96507;
  return D.97804;
}


static void Gio::PollableInputStream_Class::iface_init_function(void*, void*) (void * g_iface, void * D.96795)
{
  bool retval.5;
  int retval.6;
  long int D.97812;
  long int D.97813;
  struct BaseClassType * const klass;
  static const char __PRETTY_FUNCTION__[78] = "static void Gio::PollableInputStream_Class::iface_init_function(void*, void*)";

  klass = g_iface;
  {
    {
      {
        int _g_boolean_var_;

        if (klass != 0B) goto <D.97809>; else goto <D.97810>;
        <D.97809>:
        _g_boolean_var_ = 1;
        goto <D.97811>;
        <D.97810>:
        _g_boolean_var_ = 0;
        <D.97811>:
        retval.6 = _g_boolean_var_;
      }
      D.97812 = (long int) retval.6;
      D.97813 = __builtin_expect (D.97812, 1);
      retval.5 = D.97813 != 0;
      if (retval.5 != 0) goto <D.97814>; else goto <D.97815>;
      <D.97814>:
      goto <D.97816>;
      <D.97815>:
      g_assertion_message_expr ("giomm", "pollableinputstream.cc", 81, &__PRETTY_FUNCTION__, "klass != 0");
      <D.97816>:
    }
  }
  klass->can_poll = can_poll_vfunc_callback;
  klass->is_readable = is_readable_vfunc_callback;
  klass->read_nonblocking = read_nonblocking_vfunc_callback;
}


static gboolean Gio::PollableInputStream_Class::can_poll_vfunc_callback(GPollableInputStream*) (struct GPollableInputStream * self)
{
  bool retval.7;
  bool iftmp.8;
  bool D.97822;
  struct CppObjectType * const iftmp.9;
  gboolean D.97832;
  int (*__vtbl_ptr_type) () * D.97833;
  int (*__vtbl_ptr_type) () * D.97834;
  int (*__vtbl_ptr_type) () D.97835;
  bool D.97836;
  void * D.97837;
  long unsigned int D.97840;
  struct GTypeClass * D.97841;
  void * D.97842;
  gboolean (*<T10be0>) (struct GPollableInputStream *) D.97845;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97821>; else goto <D.97819>;
    <D.97821>:
    D.97822 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97822 != 0) goto <D.97823>; else goto <D.97819>;
    <D.97823>:
    iftmp.8 = 1;
    goto <D.97820>;
    <D.97819>:
    iftmp.8 = 0;
    <D.97820>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.97824>; else goto <D.97825>;
    <D.97824>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97827>; else goto <D.97828>;
      <D.97827>:
      iftmp.9 = 0B;
      goto <D.97829>;
      <D.97828>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio19PollableInputStreamE, -1);
      <D.97829>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.97830>; else goto <D.97831>;
      <D.97830>:
      try
        {
          D.97833 = obj->D.86035._vptr.Interface;
          D.97834 = D.97833 + 16;
          D.97835 = *D.97834;
          D.97836 = OBJ_TYPE_REF(D.97835;(const struct PollableInputStream)obj->2) (obj);
          D.97832 = (gboolean) D.97836;
          return D.97832;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97837 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97837);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97838>;
      <D.97831>:
      <D.97838>:
    }
    goto <D.97839>;
    <D.97825>:
    <D.97839>:
  }
  D.97840 = Gio::PollableInputStream::get_type ();
  D.97841 = MEM[(struct GTypeInstance *)self].g_class;
  D.97842 = g_type_interface_peek (D.97841, D.97840);
  base = g_type_interface_peek_parent (D.97842);
  {
    if (base != 0B) goto <D.97843>; else goto <D.97844>;
    <D.97843>:
    D.97845 = base->can_poll;
    if (D.97845 != 0B) goto <D.97846>; else goto <D.97847>;
    <D.97846>:
    {
      gboolean retval;

      D.97845 = base->can_poll;
      retval = D.97845 (self);
      D.97832 = retval;
      return D.97832;
    }
    <D.97847>:
    <D.97844>:
  }
  D.97832 = 0;
  return D.97832;
}


static gboolean Gio::PollableInputStream_Class::is_readable_vfunc_callback(GPollableInputStream*) (struct GPollableInputStream * self)
{
  bool retval.10;
  bool iftmp.11;
  bool D.97864;
  struct CppObjectType * const iftmp.12;
  gboolean D.97874;
  int (*__vtbl_ptr_type) () * D.97875;
  int (*__vtbl_ptr_type) () * D.97876;
  int (*__vtbl_ptr_type) () D.97877;
  bool D.97878;
  void * D.97879;
  long unsigned int D.97882;
  struct GTypeClass * D.97883;
  void * D.97884;
  gboolean (*<T10be0>) (struct GPollableInputStream *) D.97887;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97863>; else goto <D.97861>;
    <D.97863>:
    D.97864 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97864 != 0) goto <D.97865>; else goto <D.97861>;
    <D.97865>:
    iftmp.11 = 1;
    goto <D.97862>;
    <D.97861>:
    iftmp.11 = 0;
    <D.97862>:
    retval.10 = iftmp.11;
    if (retval.10 != 0) goto <D.97866>; else goto <D.97867>;
    <D.97866>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97869>; else goto <D.97870>;
      <D.97869>:
      iftmp.12 = 0B;
      goto <D.97871>;
      <D.97870>:
      iftmp.12 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio19PollableInputStreamE, -1);
      <D.97871>:
      obj = iftmp.12;
      if (obj != 0B) goto <D.97872>; else goto <D.97873>;
      <D.97872>:
      try
        {
          D.97875 = obj->D.86035._vptr.Interface;
          D.97876 = D.97875 + 24;
          D.97877 = *D.97876;
          D.97878 = OBJ_TYPE_REF(D.97877;(const struct PollableInputStream)obj->3) (obj);
          D.97874 = (gboolean) D.97878;
          return D.97874;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97879 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97879);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97880>;
      <D.97873>:
      <D.97880>:
    }
    goto <D.97881>;
    <D.97867>:
    <D.97881>:
  }
  D.97882 = Gio::PollableInputStream::get_type ();
  D.97883 = MEM[(struct GTypeInstance *)self].g_class;
  D.97884 = g_type_interface_peek (D.97883, D.97882);
  base = g_type_interface_peek_parent (D.97884);
  {
    if (base != 0B) goto <D.97885>; else goto <D.97886>;
    <D.97885>:
    D.97887 = base->is_readable;
    if (D.97887 != 0B) goto <D.97888>; else goto <D.97889>;
    <D.97888>:
    {
      gboolean retval;

      D.97887 = base->is_readable;
      retval = D.97887 (self);
      D.97874 = retval;
      return D.97874;
    }
    <D.97889>:
    <D.97886>:
  }
  D.97874 = 0;
  return D.97874;
}


static gssize Gio::PollableInputStream_Class::read_nonblocking_vfunc_callback(GPollableInputStream*, void*, gsize, GError**) (struct GPollableInputStream * self, void * buffer, gsize count, struct GError * * error)
{
  bool retval.13;
  bool iftmp.14;
  bool D.97906;
  struct CppObjectType * const iftmp.15;
  gssize D.97916;
  int (*__vtbl_ptr_type) () * D.97917;
  int (*__vtbl_ptr_type) () * D.97918;
  int (*__vtbl_ptr_type) () D.97919;
  void * D.97920;
  long unsigned int D.97923;
  struct GTypeClass * D.97924;
  void * D.97925;
  gssize (*<T10bea>) (struct GPollableInputStream *, void *, gsize, struct GError * *) D.97928;
  struct GError * D.97931;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.97905>; else goto <D.97903>;
    <D.97905>:
    D.97906 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.97906 != 0) goto <D.97907>; else goto <D.97903>;
    <D.97907>:
    iftmp.14 = 1;
    goto <D.97904>;
    <D.97903>:
    iftmp.14 = 0;
    <D.97904>:
    retval.13 = iftmp.14;
    if (retval.13 != 0) goto <D.97908>; else goto <D.97909>;
    <D.97908>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.97911>; else goto <D.97912>;
      <D.97911>:
      iftmp.15 = 0B;
      goto <D.97913>;
      <D.97912>:
      iftmp.15 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio19PollableInputStreamE, -1);
      <D.97913>:
      obj = iftmp.15;
      if (obj != 0B) goto <D.97914>; else goto <D.97915>;
      <D.97914>:
      try
        {
          D.97917 = obj->D.86035._vptr.Interface;
          D.97918 = D.97917 + 32;
          D.97919 = *D.97918;
          D.97916 = OBJ_TYPE_REF(D.97919;(struct PollableInputStream)obj->4) (obj, buffer, count);
          return D.97916;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.97920 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.97920);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.97921>;
      <D.97915>:
      <D.97921>:
    }
    goto <D.97922>;
    <D.97909>:
    <D.97922>:
  }
  D.97923 = Gio::PollableInputStream::get_type ();
  D.97924 = MEM[(struct GTypeInstance *)self].g_class;
  D.97925 = g_type_interface_peek (D.97924, D.97923);
  base = g_type_interface_peek_parent (D.97925);
  {
    if (base != 0B) goto <D.97926>; else goto <D.97927>;
    <D.97926>:
    D.97928 = base->read_nonblocking;
    if (D.97928 != 0B) goto <D.97929>; else goto <D.97930>;
    <D.97929>:
    {
      gssize retval;

      D.97928 = base->read_nonblocking;
      retval = D.97928 (self, buffer, count, error);
      D.97931 = *error;
      if (D.97931 != 0B) goto <D.97932>; else goto <D.97933>;
      <D.97932>:
      D.97931 = *error;
      Glib::Error::throw_exception (D.97931);
      <D.97933>:
      D.97916 = retval;
      return D.97916;
    }
    <D.97930>:
    <D.97927>:
  }
  D.97916 = 0;
  return D.97916;
}


static Glib::ObjectBase* Gio::PollableInputStream_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.97945;
  struct ObjectBase * iftmp.16;
  void * D.96839;
  void * D.97947;
  int (*__vtbl_ptr_type) () * D.97950;
  int (*__vtbl_ptr_type) () * D.97951;
  long int D.97952;
  sizetype D.97953;

  D.96839 = operator new (48);
  try
    {
      Gio::PollableInputStream::PollableInputStream (D.96839, object);
    }
  catch
    {
      operator delete (D.96839);
    }
  D.97947 = D.96839;
  if (D.97947 != 0B) goto <D.97948>; else goto <D.97949>;
  <D.97948>:
  D.97950 = MEM[(struct PollableInputStream *)D.97947].D.86035._vptr.Interface;
  D.97951 = D.97950 + 18446744073709551592;
  D.97952 = MEM[(long int *)D.97951];
  D.97953 = (sizetype) D.97952;
  iftmp.16 = D.97947 + D.97953;
  goto <D.97954>;
  <D.97949>:
  iftmp.16 = 0B;
  <D.97954>:
  D.97945 = iftmp.16;
  return D.97945;
}


Gio::PollableInputStream::PollableInputStream() (struct PollableInputStream * const this, const void * * __vtt_parm)
{
  struct trackable * D.97960;
  const void * * iftmp.17;
  struct ObjectBase * D.97968;
  const struct Interface_Class & D.97970;
  const void * * iftmp.18;
  struct Interface * D.97975;
  int (*__vtbl_ptr_type) () * iftmp.19;
  sizetype iftmp.20;
  int (*__vtbl_ptr_type) () * D.97983;
  int (*__vtbl_ptr_type) () * D.97984;
  long int D.97985;
  struct ObjectBase * D.97987;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * iftmp.22;
  const void * * iftmp.23;

  if (0 != 0) goto <D.97958>; else goto <D.97959>;
  <D.97958>:
  D.97960 = &this->D.86038;
  sigc::trackable::trackable (D.97960);
  goto <D.97961>;
  <D.97959>:
  <D.97961>:
  try
    {
      if (0 != 0) goto <D.97962>; else goto <D.97963>;
      <D.97962>:
      if (0 == 0) goto <D.97965>; else goto <D.97966>;
      <D.97965>:
      iftmp.17 = __vtt_parm + 32;
      goto <D.97967>;
      <D.97966>:
      iftmp.17 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.97967>:
      D.97968 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.97968, iftmp.17);
      goto <D.97969>;
      <D.97963>:
      <D.97969>:
      try
        {
          D.97970 = Gio::PollableInputStream_Class::init (&pollableinputstream_class_);
          if (0 == 0) goto <D.97972>; else goto <D.97973>;
          <D.97972>:
          iftmp.18 = __vtt_parm + 8;
          goto <D.97974>;
          <D.97973>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.97974>:
          D.97975 = &this->D.86035;
          Glib::Interface::Interface (D.97975, iftmp.18, D.97970);
          try
            {
              if (0 == 0) goto <D.97977>; else goto <D.97978>;
              <D.97977>:
              iftmp.19 = *__vtt_parm;
              goto <D.97979>;
              <D.97978>:
              iftmp.19 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.97979>:
              this->D.86035._vptr.Interface = iftmp.19;
              if (0 == 0) goto <D.97981>; else goto <D.97982>;
              <D.97981>:
              D.97983 = this->D.86035._vptr.Interface;
              D.97984 = D.97983 + 18446744073709551592;
              D.97985 = MEM[(long int *)D.97984];
              iftmp.20 = (sizetype) D.97985;
              goto <D.97986>;
              <D.97982>:
              iftmp.20 = 8;
              <D.97986>:
              D.97987 = this + iftmp.20;
              if (0 == 0) goto <D.97989>; else goto <D.97990>;
              <D.97989>:
              iftmp.21 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.97991>;
              <D.97990>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.97991>:
              D.97987->_vptr.ObjectBase = iftmp.21;
            }
          catch
            {
              if (0 == 0) goto <D.97993>; else goto <D.97994>;
              <D.97993>:
              iftmp.22 = __vtt_parm + 8;
              goto <D.97995>;
              <D.97994>:
              iftmp.22 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.97995>:
              D.97975 = &this->D.86035;
              Glib::Interface::~Interface (D.97975, iftmp.22);
            }
        }
      catch
        {
          if (0 != 0) goto <D.97996>; else goto <D.97997>;
          <D.97996>:
          if (0 == 0) goto <D.97999>; else goto <D.98000>;
          <D.97999>:
          iftmp.23 = __vtt_parm + 32;
          goto <D.98001>;
          <D.98000>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98001>:
          D.97968 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.97968, iftmp.23);
          goto <D.98002>;
          <D.97997>:
          <D.98002>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98003>; else goto <D.98004>;
      <D.98003>:
      D.97960 = &this->D.86038;
      sigc::trackable::~trackable (D.97960);
      goto <D.98005>;
      <D.98004>:
      <D.98005>:
    }
}


Gio::PollableInputStream::PollableInputStream() (struct PollableInputStream * const this)
{
  struct trackable * D.98011;
  const void * * iftmp.24;
  struct ObjectBase * D.98019;
  const struct Interface_Class & D.98021;
  const void * * iftmp.25;
  struct Interface * D.98026;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * D.98030;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.98035;
  int (*__vtbl_ptr_type) () * D.98036;
  long int D.98037;
  struct ObjectBase * D.98039;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * iftmp.29;
  const void * * iftmp.30;

  if (1 != 0) goto <D.98009>; else goto <D.98010>;
  <D.98009>:
  D.98011 = &this->D.86038;
  sigc::trackable::trackable (D.98011);
  goto <D.98012>;
  <D.98010>:
  <D.98012>:
  try
    {
      if (1 != 0) goto <D.98013>; else goto <D.98014>;
      <D.98013>:
      if (1 == 0) goto <D.98016>; else goto <D.98017>;
      <D.98016>:
      iftmp.24 = 32B;
      goto <D.98018>;
      <D.98017>:
      iftmp.24 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.98018>:
      D.98019 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.98019, iftmp.24);
      goto <D.98020>;
      <D.98014>:
      <D.98020>:
      try
        {
          D.98021 = Gio::PollableInputStream_Class::init (&pollableinputstream_class_);
          if (1 == 0) goto <D.98023>; else goto <D.98024>;
          <D.98023>:
          iftmp.25 = 8B;
          goto <D.98025>;
          <D.98024>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.98025>:
          D.98026 = &this->D.86035;
          Glib::Interface::Interface (D.98026, iftmp.25, D.98021);
          try
            {
              if (1 == 0) goto <D.98028>; else goto <D.98029>;
              <D.98028>:
              D.98030 = 0B;
              iftmp.26 = *D.98030;
              goto <D.98031>;
              <D.98029>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.98031>:
              this->D.86035._vptr.Interface = iftmp.26;
              if (1 == 0) goto <D.98033>; else goto <D.98034>;
              <D.98033>:
              D.98035 = this->D.86035._vptr.Interface;
              D.98036 = D.98035 + 18446744073709551592;
              D.98037 = MEM[(long int *)D.98036];
              iftmp.27 = (sizetype) D.98037;
              goto <D.98038>;
              <D.98034>:
              iftmp.27 = 8;
              <D.98038>:
              D.98039 = this + iftmp.27;
              if (1 == 0) goto <D.98041>; else goto <D.98042>;
              <D.98041>:
              iftmp.28 = MEM[(const void * *)0B + 24B];
              goto <D.98043>;
              <D.98042>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.98043>:
              D.98039->_vptr.ObjectBase = iftmp.28;
            }
          catch
            {
              if (1 == 0) goto <D.98045>; else goto <D.98046>;
              <D.98045>:
              iftmp.29 = 8B;
              goto <D.98047>;
              <D.98046>:
              iftmp.29 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.98047>:
              D.98026 = &this->D.86035;
              Glib::Interface::~Interface (D.98026, iftmp.29);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98048>; else goto <D.98049>;
          <D.98048>:
          if (1 == 0) goto <D.98051>; else goto <D.98052>;
          <D.98051>:
          iftmp.30 = 32B;
          goto <D.98053>;
          <D.98052>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98053>:
          D.98019 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.98019, iftmp.30);
          goto <D.98054>;
          <D.98049>:
          <D.98054>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98055>; else goto <D.98056>;
      <D.98055>:
      D.98011 = &this->D.86038;
      sigc::trackable::~trackable (D.98011);
      goto <D.98057>;
      <D.98056>:
      <D.98057>:
    }
}


Gio::PollableInputStream::PollableInputStream(GPollableInputStream*) (struct PollableInputStream * const this, const void * * __vtt_parm, struct GPollableInputStream * castitem)
{
  struct trackable * D.98063;
  const void * * iftmp.31;
  struct ObjectBase * D.98071;
  const void * * iftmp.32;
  struct Interface * D.98077;
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.98085;
  int (*__vtbl_ptr_type) () * D.98086;
  long int D.98087;
  struct ObjectBase * D.98089;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * iftmp.36;
  const void * * iftmp.37;

  if (0 != 0) goto <D.98061>; else goto <D.98062>;
  <D.98061>:
  D.98063 = &this->D.86038;
  sigc::trackable::trackable (D.98063);
  goto <D.98064>;
  <D.98062>:
  <D.98064>:
  try
    {
      if (0 != 0) goto <D.98065>; else goto <D.98066>;
      <D.98065>:
      if (0 == 0) goto <D.98068>; else goto <D.98069>;
      <D.98068>:
      iftmp.31 = __vtt_parm + 32;
      goto <D.98070>;
      <D.98069>:
      iftmp.31 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.98070>:
      D.98071 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.98071, iftmp.31);
      goto <D.98072>;
      <D.98066>:
      <D.98072>:
      try
        {
          if (0 == 0) goto <D.98074>; else goto <D.98075>;
          <D.98074>:
          iftmp.32 = __vtt_parm + 8;
          goto <D.98076>;
          <D.98075>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.98076>:
          D.98077 = &this->D.86035;
          Glib::Interface::Interface (D.98077, iftmp.32, castitem);
          try
            {
              if (0 == 0) goto <D.98079>; else goto <D.98080>;
              <D.98079>:
              iftmp.33 = *__vtt_parm;
              goto <D.98081>;
              <D.98080>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.98081>:
              this->D.86035._vptr.Interface = iftmp.33;
              if (0 == 0) goto <D.98083>; else goto <D.98084>;
              <D.98083>:
              D.98085 = this->D.86035._vptr.Interface;
              D.98086 = D.98085 + 18446744073709551592;
              D.98087 = MEM[(long int *)D.98086];
              iftmp.34 = (sizetype) D.98087;
              goto <D.98088>;
              <D.98084>:
              iftmp.34 = 8;
              <D.98088>:
              D.98089 = this + iftmp.34;
              if (0 == 0) goto <D.98091>; else goto <D.98092>;
              <D.98091>:
              iftmp.35 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98093>;
              <D.98092>:
              iftmp.35 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.98093>:
              D.98089->_vptr.ObjectBase = iftmp.35;
            }
          catch
            {
              if (0 == 0) goto <D.98095>; else goto <D.98096>;
              <D.98095>:
              iftmp.36 = __vtt_parm + 8;
              goto <D.98097>;
              <D.98096>:
              iftmp.36 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.98097>:
              D.98077 = &this->D.86035;
              Glib::Interface::~Interface (D.98077, iftmp.36);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98098>; else goto <D.98099>;
          <D.98098>:
          if (0 == 0) goto <D.98101>; else goto <D.98102>;
          <D.98101>:
          iftmp.37 = __vtt_parm + 32;
          goto <D.98103>;
          <D.98102>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98103>:
          D.98071 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.98071, iftmp.37);
          goto <D.98104>;
          <D.98099>:
          <D.98104>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98105>; else goto <D.98106>;
      <D.98105>:
      D.98063 = &this->D.86038;
      sigc::trackable::~trackable (D.98063);
      goto <D.98107>;
      <D.98106>:
      <D.98107>:
    }
}


Gio::PollableInputStream::PollableInputStream(GPollableInputStream*) (struct PollableInputStream * const this, struct GPollableInputStream * castitem)
{
  struct trackable * D.98112;
  const void * * iftmp.38;
  struct ObjectBase * D.98120;
  const void * * iftmp.39;
  struct Interface * D.98126;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * D.98130;
  sizetype iftmp.41;
  int (*__vtbl_ptr_type) () * D.98135;
  int (*__vtbl_ptr_type) () * D.98136;
  long int D.98137;
  struct ObjectBase * D.98139;
  int (*__vtbl_ptr_type) () * iftmp.42;
  const void * * iftmp.43;
  const void * * iftmp.44;

  if (1 != 0) goto <D.98110>; else goto <D.98111>;
  <D.98110>:
  D.98112 = &this->D.86038;
  sigc::trackable::trackable (D.98112);
  goto <D.98113>;
  <D.98111>:
  <D.98113>:
  try
    {
      if (1 != 0) goto <D.98114>; else goto <D.98115>;
      <D.98114>:
      if (1 == 0) goto <D.98117>; else goto <D.98118>;
      <D.98117>:
      iftmp.38 = 32B;
      goto <D.98119>;
      <D.98118>:
      iftmp.38 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.98119>:
      D.98120 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.98120, iftmp.38);
      goto <D.98121>;
      <D.98115>:
      <D.98121>:
      try
        {
          if (1 == 0) goto <D.98123>; else goto <D.98124>;
          <D.98123>:
          iftmp.39 = 8B;
          goto <D.98125>;
          <D.98124>:
          iftmp.39 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.98125>:
          D.98126 = &this->D.86035;
          Glib::Interface::Interface (D.98126, iftmp.39, castitem);
          try
            {
              if (1 == 0) goto <D.98128>; else goto <D.98129>;
              <D.98128>:
              D.98130 = 0B;
              iftmp.40 = *D.98130;
              goto <D.98131>;
              <D.98129>:
              iftmp.40 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.98131>:
              this->D.86035._vptr.Interface = iftmp.40;
              if (1 == 0) goto <D.98133>; else goto <D.98134>;
              <D.98133>:
              D.98135 = this->D.86035._vptr.Interface;
              D.98136 = D.98135 + 18446744073709551592;
              D.98137 = MEM[(long int *)D.98136];
              iftmp.41 = (sizetype) D.98137;
              goto <D.98138>;
              <D.98134>:
              iftmp.41 = 8;
              <D.98138>:
              D.98139 = this + iftmp.41;
              if (1 == 0) goto <D.98141>; else goto <D.98142>;
              <D.98141>:
              iftmp.42 = MEM[(const void * *)0B + 24B];
              goto <D.98143>;
              <D.98142>:
              iftmp.42 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.98143>:
              D.98139->_vptr.ObjectBase = iftmp.42;
            }
          catch
            {
              if (1 == 0) goto <D.98145>; else goto <D.98146>;
              <D.98145>:
              iftmp.43 = 8B;
              goto <D.98147>;
              <D.98146>:
              iftmp.43 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.98147>:
              D.98126 = &this->D.86035;
              Glib::Interface::~Interface (D.98126, iftmp.43);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98148>; else goto <D.98149>;
          <D.98148>:
          if (1 == 0) goto <D.98151>; else goto <D.98152>;
          <D.98151>:
          iftmp.44 = 32B;
          goto <D.98153>;
          <D.98152>:
          iftmp.44 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98153>:
          D.98120 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.98120, iftmp.44);
          goto <D.98154>;
          <D.98149>:
          <D.98154>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98155>; else goto <D.98156>;
      <D.98155>:
      D.98112 = &this->D.86038;
      sigc::trackable::~trackable (D.98112);
      goto <D.98157>;
      <D.98156>:
      <D.98157>:
    }
}


Gio::PollableInputStream::PollableInputStream(const Glib::Interface_Class&) (struct PollableInputStream * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.98162;
  const void * * iftmp.45;
  struct ObjectBase * D.98170;
  const void * * iftmp.46;
  struct Interface * D.98176;
  int (*__vtbl_ptr_type) () * iftmp.47;
  sizetype iftmp.48;
  int (*__vtbl_ptr_type) () * D.98184;
  int (*__vtbl_ptr_type) () * D.98185;
  long int D.98186;
  struct ObjectBase * D.98188;
  int (*__vtbl_ptr_type) () * iftmp.49;
  const void * * iftmp.50;
  const void * * iftmp.51;

  if (0 != 0) goto <D.98160>; else goto <D.98161>;
  <D.98160>:
  D.98162 = &this->D.86038;
  sigc::trackable::trackable (D.98162);
  goto <D.98163>;
  <D.98161>:
  <D.98163>:
  try
    {
      if (0 != 0) goto <D.98164>; else goto <D.98165>;
      <D.98164>:
      if (0 == 0) goto <D.98167>; else goto <D.98168>;
      <D.98167>:
      iftmp.45 = __vtt_parm + 32;
      goto <D.98169>;
      <D.98168>:
      iftmp.45 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.98169>:
      D.98170 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.98170, iftmp.45);
      goto <D.98171>;
      <D.98165>:
      <D.98171>:
      try
        {
          if (0 == 0) goto <D.98173>; else goto <D.98174>;
          <D.98173>:
          iftmp.46 = __vtt_parm + 8;
          goto <D.98175>;
          <D.98174>:
          iftmp.46 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.98175>:
          D.98176 = &this->D.86035;
          Glib::Interface::Interface (D.98176, iftmp.46, interface_class);
          try
            {
              if (0 == 0) goto <D.98178>; else goto <D.98179>;
              <D.98178>:
              iftmp.47 = *__vtt_parm;
              goto <D.98180>;
              <D.98179>:
              iftmp.47 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.98180>:
              this->D.86035._vptr.Interface = iftmp.47;
              if (0 == 0) goto <D.98182>; else goto <D.98183>;
              <D.98182>:
              D.98184 = this->D.86035._vptr.Interface;
              D.98185 = D.98184 + 18446744073709551592;
              D.98186 = MEM[(long int *)D.98185];
              iftmp.48 = (sizetype) D.98186;
              goto <D.98187>;
              <D.98183>:
              iftmp.48 = 8;
              <D.98187>:
              D.98188 = this + iftmp.48;
              if (0 == 0) goto <D.98190>; else goto <D.98191>;
              <D.98190>:
              iftmp.49 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.98192>;
              <D.98191>:
              iftmp.49 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.98192>:
              D.98188->_vptr.ObjectBase = iftmp.49;
            }
          catch
            {
              if (0 == 0) goto <D.98194>; else goto <D.98195>;
              <D.98194>:
              iftmp.50 = __vtt_parm + 8;
              goto <D.98196>;
              <D.98195>:
              iftmp.50 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.98196>:
              D.98176 = &this->D.86035;
              Glib::Interface::~Interface (D.98176, iftmp.50);
            }
        }
      catch
        {
          if (0 != 0) goto <D.98197>; else goto <D.98198>;
          <D.98197>:
          if (0 == 0) goto <D.98200>; else goto <D.98201>;
          <D.98200>:
          iftmp.51 = __vtt_parm + 32;
          goto <D.98202>;
          <D.98201>:
          iftmp.51 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98202>:
          D.98170 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.98170, iftmp.51);
          goto <D.98203>;
          <D.98198>:
          <D.98203>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.98204>; else goto <D.98205>;
      <D.98204>:
      D.98162 = &this->D.86038;
      sigc::trackable::~trackable (D.98162);
      goto <D.98206>;
      <D.98205>:
      <D.98206>:
    }
}


Gio::PollableInputStream::PollableInputStream(const Glib::Interface_Class&) (struct PollableInputStream * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.98211;
  const void * * iftmp.52;
  struct ObjectBase * D.98219;
  const void * * iftmp.53;
  struct Interface * D.98225;
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * D.98229;
  sizetype iftmp.55;
  int (*__vtbl_ptr_type) () * D.98234;
  int (*__vtbl_ptr_type) () * D.98235;
  long int D.98236;
  struct ObjectBase * D.98238;
  int (*__vtbl_ptr_type) () * iftmp.56;
  const void * * iftmp.57;
  const void * * iftmp.58;

  if (1 != 0) goto <D.98209>; else goto <D.98210>;
  <D.98209>:
  D.98211 = &this->D.86038;
  sigc::trackable::trackable (D.98211);
  goto <D.98212>;
  <D.98210>:
  <D.98212>:
  try
    {
      if (1 != 0) goto <D.98213>; else goto <D.98214>;
      <D.98213>:
      if (1 == 0) goto <D.98216>; else goto <D.98217>;
      <D.98216>:
      iftmp.52 = 32B;
      goto <D.98218>;
      <D.98217>:
      iftmp.52 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
      <D.98218>:
      D.98219 = &this->D.86037;
      Glib::ObjectBase::ObjectBase (D.98219, iftmp.52);
      goto <D.98220>;
      <D.98214>:
      <D.98220>:
      try
        {
          if (1 == 0) goto <D.98222>; else goto <D.98223>;
          <D.98222>:
          iftmp.53 = 8B;
          goto <D.98224>;
          <D.98223>:
          iftmp.53 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
          <D.98224>:
          D.98225 = &this->D.86035;
          Glib::Interface::Interface (D.98225, iftmp.53, interface_class);
          try
            {
              if (1 == 0) goto <D.98227>; else goto <D.98228>;
              <D.98227>:
              D.98229 = 0B;
              iftmp.54 = *D.98229;
              goto <D.98230>;
              <D.98228>:
              iftmp.54 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
              <D.98230>:
              this->D.86035._vptr.Interface = iftmp.54;
              if (1 == 0) goto <D.98232>; else goto <D.98233>;
              <D.98232>:
              D.98234 = this->D.86035._vptr.Interface;
              D.98235 = D.98234 + 18446744073709551592;
              D.98236 = MEM[(long int *)D.98235];
              iftmp.55 = (sizetype) D.98236;
              goto <D.98237>;
              <D.98233>:
              iftmp.55 = 8;
              <D.98237>:
              D.98238 = this + iftmp.55;
              if (1 == 0) goto <D.98240>; else goto <D.98241>;
              <D.98240>:
              iftmp.56 = MEM[(const void * *)0B + 24B];
              goto <D.98242>;
              <D.98241>:
              iftmp.56 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
              <D.98242>:
              D.98238->_vptr.ObjectBase = iftmp.56;
            }
          catch
            {
              if (1 == 0) goto <D.98244>; else goto <D.98245>;
              <D.98244>:
              iftmp.57 = 8B;
              goto <D.98246>;
              <D.98245>:
              iftmp.57 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
              <D.98246>:
              D.98225 = &this->D.86035;
              Glib::Interface::~Interface (D.98225, iftmp.57);
            }
        }
      catch
        {
          if (1 != 0) goto <D.98247>; else goto <D.98248>;
          <D.98247>:
          if (1 == 0) goto <D.98250>; else goto <D.98251>;
          <D.98250>:
          iftmp.58 = 32B;
          goto <D.98252>;
          <D.98251>:
          iftmp.58 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
          <D.98252>:
          D.98219 = &this->D.86037;
          Glib::ObjectBase::~ObjectBase (D.98219, iftmp.58);
          goto <D.98253>;
          <D.98248>:
          <D.98253>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.98254>; else goto <D.98255>;
      <D.98254>:
      D.98211 = &this->D.86038;
      sigc::trackable::~trackable (D.98211);
      goto <D.98256>;
      <D.98255>:
      <D.98256>:
    }
}


Gio::PollableInputStream::~PollableInputStream() (struct PollableInputStream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.59;
  sizetype iftmp.60;
  int (*__vtbl_ptr_type) () * D.98266;
  int (*__vtbl_ptr_type) () * D.98267;
  long int D.98268;
  struct ObjectBase * D.98270;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * iftmp.62;
  struct Interface * D.98279;
  int D.98280;
  const void * * iftmp.63;
  struct ObjectBase * D.98287;
  struct trackable * D.98291;
  int D.98293;

  {
    if (0 == 0) goto <D.98260>; else goto <D.98261>;
    <D.98260>:
    iftmp.59 = *__vtt_parm;
    goto <D.98262>;
    <D.98261>:
    iftmp.59 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
    <D.98262>:
    this->D.86035._vptr.Interface = iftmp.59;
    if (0 == 0) goto <D.98264>; else goto <D.98265>;
    <D.98264>:
    D.98266 = this->D.86035._vptr.Interface;
    D.98267 = D.98266 + 18446744073709551592;
    D.98268 = MEM[(long int *)D.98267];
    iftmp.60 = (sizetype) D.98268;
    goto <D.98269>;
    <D.98265>:
    iftmp.60 = 8;
    <D.98269>:
    D.98270 = this + iftmp.60;
    if (0 == 0) goto <D.98272>; else goto <D.98273>;
    <D.98272>:
    iftmp.61 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.98274>;
    <D.98273>:
    iftmp.61 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
    <D.98274>:
    D.98270->_vptr.ObjectBase = iftmp.61;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.98276>; else goto <D.98277>;
                    <D.98276>:
                    iftmp.62 = __vtt_parm + 8;
                    goto <D.98278>;
                    <D.98277>:
                    iftmp.62 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
                    <D.98278>:
                    D.98279 = &this->D.86035;
                    Glib::Interface::~Interface (D.98279, iftmp.62);
                  }
              }
            finally
              {
                D.98280 = 0;
                if (D.98280 != 0) goto <D.98281>; else goto <D.98282>;
                <D.98281>:
                if (0 == 0) goto <D.98284>; else goto <D.98285>;
                <D.98284>:
                iftmp.63 = __vtt_parm + 32;
                goto <D.98286>;
                <D.98285>:
                iftmp.63 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
                <D.98286>:
                D.98287 = &this->D.86037;
                Glib::ObjectBase::~ObjectBase (D.98287, iftmp.63);
                goto <D.98288>;
                <D.98282>:
                <D.98288>:
              }
          }
        finally
          {
            D.98280 = 0;
            if (D.98280 != 0) goto <D.98289>; else goto <D.98290>;
            <D.98289>:
            D.98291 = &this->D.86038;
            sigc::trackable::~trackable (D.98291);
            goto <D.98292>;
            <D.98290>:
            <D.98292>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96886>:
  D.98293 = 0;
  if (D.98293 != 0) goto <D.98294>; else goto <D.98295>;
  <D.98294>:
  operator delete (this);
  goto <D.98296>;
  <D.98295>:
  <D.98296>:
}


virtual Gio::PollableInputStream::~PollableInputStream() (struct PollableInputStream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.64;
  const void * * D.98312;
  sizetype iftmp.65;
  int (*__vtbl_ptr_type) () * D.98317;
  int (*__vtbl_ptr_type) () * D.98318;
  long int D.98319;
  struct ObjectBase * D.98321;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * iftmp.67;
  struct Interface * D.98330;
  int D.98331;
  const void * * iftmp.68;
  struct ObjectBase * D.98338;
  struct trackable * D.98342;
  int D.98344;

  {
    if (2 == 0) goto <D.98310>; else goto <D.98311>;
    <D.98310>:
    D.98312 = 0B;
    iftmp.64 = *D.98312;
    goto <D.98313>;
    <D.98311>:
    iftmp.64 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 32B];
    <D.98313>:
    this->D.86035._vptr.Interface = iftmp.64;
    if (2 == 0) goto <D.98315>; else goto <D.98316>;
    <D.98315>:
    D.98317 = this->D.86035._vptr.Interface;
    D.98318 = D.98317 + 18446744073709551592;
    D.98319 = MEM[(long int *)D.98318];
    iftmp.65 = (sizetype) D.98319;
    goto <D.98320>;
    <D.98316>:
    iftmp.65 = 8;
    <D.98320>:
    D.98321 = this + iftmp.65;
    if (2 == 0) goto <D.98323>; else goto <D.98324>;
    <D.98323>:
    iftmp.66 = MEM[(const void * *)0B + 24B];
    goto <D.98325>;
    <D.98324>:
    iftmp.66 = &MEM[(void *)&_ZTVN3Gio19PollableInputStreamE + 136B];
    <D.98325>:
    D.98321->_vptr.ObjectBase = iftmp.66;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.98327>; else goto <D.98328>;
                    <D.98327>:
                    iftmp.67 = 8B;
                    goto <D.98329>;
                    <D.98328>:
                    iftmp.67 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 8B];
                    <D.98329>:
                    D.98330 = &this->D.86035;
                    Glib::Interface::~Interface (D.98330, iftmp.67);
                  }
              }
            finally
              {
                D.98331 = 2;
                if (D.98331 != 0) goto <D.98332>; else goto <D.98333>;
                <D.98332>:
                if (2 == 0) goto <D.98335>; else goto <D.98336>;
                <D.98335>:
                iftmp.68 = 32B;
                goto <D.98337>;
                <D.98336>:
                iftmp.68 = &MEM[(void *)&_ZTTN3Gio19PollableInputStreamE + 32B];
                <D.98337>:
                D.98338 = &this->D.86037;
                Glib::ObjectBase::~ObjectBase (D.98338, iftmp.68);
                goto <D.98339>;
                <D.98333>:
                <D.98339>:
              }
          }
        finally
          {
            D.98331 = 2;
            if (D.98331 != 0) goto <D.98340>; else goto <D.98341>;
            <D.98340>:
            D.98342 = &this->D.86038;
            sigc::trackable::~trackable (D.98342);
            goto <D.98343>;
            <D.98341>:
            <D.98343>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.96889>:
  D.98344 = 0;
  if (D.98344 != 0) goto <D.98345>; else goto <D.98346>;
  <D.98345>:
  operator delete (this);
  goto <D.98347>;
  <D.98346>:
  <D.98347>:
}


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


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

  D.98360 = Gio::PollableInputStream_Class::init (&pollableinputstream_class_);
  Glib::Interface_Class::add_interface (D.98360, gtype_implementer);
}


static GType Gio::PollableInputStream::get_type() ()
{
  GType D.98362;
  const struct Interface_Class & D.98363;
  const struct Class * D.98364;

  D.98363 = Gio::PollableInputStream_Class::init (&pollableinputstream_class_);
  D.98364 = &D.98363->D.86058;
  D.98362 = Glib::Class::get_type (D.98364);
  return D.98362;
}


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

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


static GType Gio::PollableInputStream::get_base_type() ()
{
  GType D.98369;

  D.98369 = g_pollable_input_stream_get_type ();
  return D.98369;
}


bool Gio::PollableInputStream::can_poll() const (const struct PollableInputStream * const this)
{
  bool D.98372;
  const struct GPollableInputStream * D.98373;
  int D.98374;

  D.98373 = Gio::PollableInputStream::gobj (this);
  D.98374 = g_pollable_input_stream_can_poll (D.98373);
  D.98372 = D.98374 != 0;
  return D.98372;
}


const GPollableInputStream* Gio::PollableInputStream::gobj() const (const struct PollableInputStream * const this)
{
  const struct GPollableInputStream * D.98377;
  int (*__vtbl_ptr_type) () * D.98378;
  int (*__vtbl_ptr_type) () * D.98379;
  long int D.98380;
  sizetype D.98381;
  const struct ObjectBase * D.98382;

  D.98378 = this->D.86035._vptr.Interface;
  D.98379 = D.98378 + 18446744073709551592;
  D.98380 = MEM[(long int *)D.98379];
  D.98381 = (sizetype) D.98380;
  D.98382 = this + D.98381;
  D.98377 = D.98382->gobject_;
  return D.98377;
}


bool Gio::PollableInputStream::is_readable() const (const struct PollableInputStream * const this)
{
  bool D.98384;
  const struct GPollableInputStream * D.98385;
  int D.98386;

  D.98385 = Gio::PollableInputStream::gobj (this);
  D.98386 = g_pollable_input_stream_is_readable (D.98385);
  D.98384 = D.98386 != 0;
  return D.98384;
}


gssize Gio::PollableInputStream::read_nonblocking(void*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct PollableInputStream * const this, void * buffer, gsize count, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.98389;
  struct GPollableInputStream * D.98390;
  struct GError * gerror.69;
  gssize D.98394;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.98389 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.98390 = Gio::PollableInputStream::gobj (this);
      retvalue = g_pollable_input_stream_read_nonblocking (D.98390, buffer, count, D.98389, &gerror);
      gerror.69 = gerror;
      if (gerror.69 != 0B) goto <D.98392>; else goto <D.98393>;
      <D.98392>:
      gerror.69 = gerror;
      Glib::Error::throw_exception (gerror.69);
      <D.98393>:
      D.98394 = retvalue;
      return D.98394;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.98400;
  struct BaseObjectType * iftmp.70;
  bool D.98402;
  struct Cancellable * D.98405;

  D.98402 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.98402 != 0) goto <D.98403>; else goto <D.98404>;
  <D.98403>:
  D.98405 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.70 = Gio::Cancellable::gobj (D.98405);
  goto <D.98406>;
  <D.98404>:
  iftmp.70 = 0B;
  <D.98406>:
  D.98400 = iftmp.70;
  return D.98400;
}


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

  D.98409 = this->pCppObject_;
  D.98408 = D.98409 != 0B;
  return D.98408;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.98413;
  int (*__vtbl_ptr_type) () * D.98414;
  int (*__vtbl_ptr_type) () * D.98415;
  long int D.98416;
  sizetype D.98417;
  struct ObjectBase * D.98418;

  D.98414 = this->D.96633._vptr.Object;
  D.98415 = D.98414 + 18446744073709551592;
  D.98416 = MEM[(long int *)D.98415];
  D.98417 = (sizetype) D.98416;
  D.98418 = this + D.98417;
  D.98413 = D.98418->gobject_;
  return D.98413;
}


GPollableInputStream* Gio::PollableInputStream::gobj() (struct PollableInputStream * const this)
{
  struct GPollableInputStream * D.98420;
  int (*__vtbl_ptr_type) () * D.98421;
  int (*__vtbl_ptr_type) () * D.98422;
  long int D.98423;
  sizetype D.98424;
  struct ObjectBase * D.98425;

  D.98421 = this->D.86035._vptr.Interface;
  D.98422 = D.98421 + 18446744073709551592;
  D.98423 = MEM[(long int *)D.98422];
  D.98424 = (sizetype) D.98423;
  D.98425 = this + D.98424;
  D.98420 = D.98425->gobject_;
  return D.98420;
}


gssize Gio::PollableInputStream::read_nonblocking(void*, gsize) (struct PollableInputStream * const this, void * buffer, gsize count)
{
  struct GPollableInputStream * D.98427;
  struct GError * gerror.71;
  gssize D.98431;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.98427 = Gio::PollableInputStream::gobj (this);
      retvalue = g_pollable_input_stream_read_nonblocking (D.98427, buffer, count, 0B, &gerror);
      gerror.71 = gerror;
      if (gerror.71 != 0B) goto <D.98429>; else goto <D.98430>;
      <D.98429>:
      gerror.71 = gerror;
      Glib::Error::throw_exception (gerror.71);
      <D.98430>:
      D.98431 = retvalue;
      return D.98431;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


virtual bool Gio::PollableInputStream::can_poll_vfunc() const (const struct PollableInputStream * const this)
{
  long unsigned int D.98436;
  int (*__vtbl_ptr_type) () * D.98437;
  int (*__vtbl_ptr_type) () * D.98438;
  long int D.98439;
  sizetype D.98440;
  const struct ObjectBase * D.98441;
  struct GObject * D.98442;
  struct GTypeClass * D.98443;
  void * D.98444;
  gboolean (*<T10be0>) (struct GPollableInputStream *) D.98447;
  const struct GPollableInputStream * D.98450;
  int D.98451;
  bool D.98452;
  struct BaseClassType * const base;
  typedef RType RType;

  D.98436 = Gio::PollableInputStream::get_type ();
  D.98437 = this->D.86035._vptr.Interface;
  D.98438 = D.98437 + 18446744073709551592;
  D.98439 = MEM[(long int *)D.98438];
  D.98440 = (sizetype) D.98439;
  D.98441 = this + D.98440;
  D.98442 = D.98441->gobject_;
  D.98443 = MEM[(struct GTypeInstance *)D.98442].g_class;
  D.98444 = g_type_interface_peek (D.98443, D.98436);
  base = g_type_interface_peek_parent (D.98444);
  {
    if (base != 0B) goto <D.98445>; else goto <D.98446>;
    <D.98445>:
    D.98447 = base->can_poll;
    if (D.98447 != 0B) goto <D.98448>; else goto <D.98449>;
    <D.98448>:
    {
      bool retval;

      D.98447 = base->can_poll;
      D.98450 = Gio::PollableInputStream::gobj (this);
      D.98451 = D.98447 (D.98450);
      retval = D.98451 != 0;
      D.98452 = retval;
      return D.98452;
    }
    <D.98449>:
    <D.98446>:
  }
  D.98452 = 0;
  return D.98452;
}


virtual bool Gio::PollableInputStream::is_readable_vfunc() const (const struct PollableInputStream * const this)
{
  long unsigned int D.98458;
  int (*__vtbl_ptr_type) () * D.98459;
  int (*__vtbl_ptr_type) () * D.98460;
  long int D.98461;
  sizetype D.98462;
  const struct ObjectBase * D.98463;
  struct GObject * D.98464;
  struct GTypeClass * D.98465;
  void * D.98466;
  gboolean (*<T10be0>) (struct GPollableInputStream *) D.98469;
  const struct GPollableInputStream * D.98472;
  int D.98473;
  bool D.98474;
  struct BaseClassType * const base;
  typedef RType RType;

  D.98458 = Gio::PollableInputStream::get_type ();
  D.98459 = this->D.86035._vptr.Interface;
  D.98460 = D.98459 + 18446744073709551592;
  D.98461 = MEM[(long int *)D.98460];
  D.98462 = (sizetype) D.98461;
  D.98463 = this + D.98462;
  D.98464 = D.98463->gobject_;
  D.98465 = MEM[(struct GTypeInstance *)D.98464].g_class;
  D.98466 = g_type_interface_peek (D.98465, D.98458);
  base = g_type_interface_peek_parent (D.98466);
  {
    if (base != 0B) goto <D.98467>; else goto <D.98468>;
    <D.98467>:
    D.98469 = base->is_readable;
    if (D.98469 != 0B) goto <D.98470>; else goto <D.98471>;
    <D.98470>:
    {
      bool retval;

      D.98469 = base->is_readable;
      D.98472 = Gio::PollableInputStream::gobj (this);
      D.98473 = D.98469 (D.98472);
      retval = D.98473 != 0;
      D.98474 = retval;
      return D.98474;
    }
    <D.98471>:
    <D.98468>:
  }
  D.98474 = 0;
  return D.98474;
}


virtual gssize Gio::PollableInputStream::read_nonblocking_vfunc(void*, gsize) (struct PollableInputStream * const this, void * buffer, gsize count)
{
  long unsigned int D.98480;
  int (*__vtbl_ptr_type) () * D.98481;
  int (*__vtbl_ptr_type) () * D.98482;
  long int D.98483;
  sizetype D.98484;
  struct ObjectBase * D.98485;
  struct GObject * D.98486;
  struct GTypeClass * D.98487;
  void * D.98488;
  gssize (*<T10bea>) (struct GPollableInputStream *, void *, gsize, struct GError * *) D.98491;
  struct GPollableInputStream * D.98494;
  struct GError * gerror.72;
  gssize D.98498;
  struct BaseClassType * const base;
  typedef RType RType;

  D.98480 = Gio::PollableInputStream::get_type ();
  D.98481 = this->D.86035._vptr.Interface;
  D.98482 = D.98481 + 18446744073709551592;
  D.98483 = MEM[(long int *)D.98482];
  D.98484 = (sizetype) D.98483;
  D.98485 = this + D.98484;
  D.98486 = D.98485->gobject_;
  D.98487 = MEM[(struct GTypeInstance *)D.98486].g_class;
  D.98488 = g_type_interface_peek (D.98487, D.98480);
  base = g_type_interface_peek_parent (D.98488);
  {
    if (base != 0B) goto <D.98489>; else goto <D.98490>;
    <D.98489>:
    D.98491 = base->read_nonblocking;
    if (D.98491 != 0B) goto <D.98492>; else goto <D.98493>;
    <D.98492>:
    {
      struct GError * gerror;
      gssize retval;

      try
        {
          gerror = 0B;
          D.98491 = base->read_nonblocking;
          D.98494 = Gio::PollableInputStream::gobj (this);
          retval = D.98491 (D.98494, buffer, count, &gerror);
          gerror.72 = gerror;
          if (gerror.72 != 0B) goto <D.98496>; else goto <D.98497>;
          <D.98496>:
          gerror.72 = gerror;
          Glib::Error::throw_exception (gerror.72);
          <D.98497>:
          D.98498 = retval;
          return D.98498;
        }
      finally
        {
          gerror = {CLOBBER};
        }
    }
    <D.98493>:
    <D.98490>:
  }
  D.98498 = 0;
  return D.98498;
}