void Gio::IOStream::close_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct IOStream * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.0;
  struct BaseObjectType * D.98909;
  struct GIOStream * D.98910;
  struct SlotAsyncReady * slot_copy;

  slot_copy.0 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.0, slot);
    }
  catch
    {
      operator delete (slot_copy.0);
    }
  slot_copy = slot_copy.0;
  D.98909 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.98910 = Gio::IOStream::gobj (this);
  g_io_stream_close_async (D.98910, io_priority, D.98909, SignalProxy_async_callback, slot_copy);
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.98915;

  D.98915 = &this->D.97381;
  sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::slot1 (D.98915, src);
  try
    {

    }
  catch
    {
      D.98915 = &this->D.97381;
      sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot1 (D.98915);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.98916;
  struct slot_base * D.98917;

  D.98916 = &src->D.97339;
  D.98917 = &this->D.97339;
  sigc::slot_base::slot_base (D.98917, D.98916);
  try
    {

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


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.98918;
  struct BaseObjectType * iftmp.1;
  bool D.98920;
  struct Cancellable * D.98923;

  D.98920 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.98920 != 0) goto <D.98921>; else goto <D.98922>;
  <D.98921>:
  D.98923 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.98923);
  goto <D.98924>;
  <D.98922>:
  iftmp.1 = 0B;
  <D.98924>:
  D.98918 = iftmp.1;
  return D.98918;
}


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

  D.98927 = this->pCppObject_;
  D.98926 = D.98927 != 0B;
  return D.98926;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.98931;
  int (*__vtbl_ptr_type) () * D.98932;
  int (*__vtbl_ptr_type) () * D.98933;
  long int D.98934;
  sizetype D.98935;
  struct ObjectBase * D.98936;

  D.98932 = this->D.86174._vptr.Object;
  D.98933 = D.98932 + 18446744073709551592;
  D.98934 = MEM[(long int *)D.98933];
  D.98935 = (sizetype) D.98934;
  D.98936 = this + D.98935;
  D.98931 = D.98936->gobject_;
  return D.98931;
}


GIOStream* Gio::IOStream::gobj() (struct IOStream * const this)
{
  struct GIOStream * D.98938;
  int (*__vtbl_ptr_type) () * D.98939;
  int (*__vtbl_ptr_type) () * D.98940;
  long int D.98941;
  sizetype D.98942;
  struct ObjectBase * D.98943;

  D.98939 = this->D.86809._vptr.Object;
  D.98940 = D.98939 + 18446744073709551592;
  D.98941 = MEM[(long int *)D.98940];
  D.98942 = (sizetype) D.98941;
  D.98943 = this + D.98942;
  D.98938 = D.98943->gobject_;
  return D.98938;
}


void Gio::IOStream::close_async(const SlotAsyncReady&, int) (struct IOStream * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.2;
  struct GIOStream * D.98945;
  struct SlotAsyncReady * slot_copy;

  slot_copy.2 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.2, slot);
    }
  catch
    {
      operator delete (slot_copy.2);
    }
  slot_copy = slot_copy.2;
  D.98945 = Gio::IOStream::gobj (this);
  g_io_stream_close_async (D.98945, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::IOStream::splice_async(const Glib::RefPtr<Gio::IOStream>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::IOStreamSpliceFlags, int) (struct IOStream * const this, const struct RefPtr & stream2, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, IOStreamSpliceFlags flags, int io_priority)
{
  void * slot_copy.3;
  struct BaseObjectType * D.98948;
  struct BaseObjectType * D.98949;
  struct GIOStream * D.98950;
  struct SlotAsyncReady * slot_copy;

  slot_copy.3 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.3, slot);
    }
  catch
    {
      operator delete (slot_copy.3);
    }
  slot_copy = slot_copy.3;
  D.98948 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.98949 = Glib::unwrap<Gio::IOStream> (stream2);
  D.98950 = Gio::IOStream::gobj (this);
  g_io_stream_splice_async (D.98950, D.98949, flags, io_priority, D.98948, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::IOStream; typename T::BaseObjectType = _GIOStream] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.98955;
  struct BaseObjectType * iftmp.4;
  bool D.98957;
  struct IOStream * D.98960;

  D.98957 = Glib::RefPtr<Gio::IOStream>::operator bool (ptr);
  if (D.98957 != 0) goto <D.98958>; else goto <D.98959>;
  <D.98958>:
  D.98960 = Glib::RefPtr<Gio::IOStream>::operator-> (ptr);
  iftmp.4 = Gio::IOStream::gobj (D.98960);
  goto <D.98961>;
  <D.98959>:
  iftmp.4 = 0B;
  <D.98961>:
  D.98955 = iftmp.4;
  return D.98955;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::IOStream] (const struct RefPtr * const this)
{
  bool D.98963;
  struct IOStream * D.98964;

  D.98964 = this->pCppObject_;
  D.98963 = D.98964 != 0B;
  return D.98963;
}


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

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


void Gio::IOStream::splice_async(const Glib::RefPtr<Gio::IOStream>&, const SlotAsyncReady&, Gio::IOStreamSpliceFlags, int) (struct IOStream * const this, const struct RefPtr & stream2, const struct SlotAsyncReady & slot, IOStreamSpliceFlags flags, int io_priority)
{
  void * slot_copy.5;
  struct BaseObjectType * D.98968;
  struct GIOStream * D.98969;
  struct SlotAsyncReady * slot_copy;

  slot_copy.5 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.5, slot);
    }
  catch
    {
      operator delete (slot_copy.5);
    }
  slot_copy = slot_copy.5;
  D.98968 = Glib::unwrap<Gio::IOStream> (stream2);
  D.98969 = Gio::IOStream::gobj (this);
  g_io_stream_splice_async (D.98969, D.98968, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::IOStream> Glib::wrap(GIOStream*, bool) (struct GIOStream * object, bool take_copy)
{
  struct IOStream * iftmp.6;
  int D.98975;
  struct ObjectBase * D.98976;

  D.98975 = (int) take_copy;
  D.98976 = Glib::wrap_auto (object, D.98975);
  if (D.98976 == 0B) goto <D.98977>; else goto <D.98978>;
  <D.98977>:
  iftmp.6 = 0B;
  goto <D.98979>;
  <D.98978>:
  iftmp.6 = __dynamic_cast (D.98976, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8IOStreamE, -1);
  <D.98979>:
  Glib::RefPtr<Gio::IOStream>::RefPtr (<retval>, iftmp.6);
  return <retval>;
}


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


const Glib::Class& Gio::IOStream_Class::init() (struct IOStream_Class * const this)
{
  long unsigned int D.98982;
  long unsigned int D.98985;
  struct Class * D.98986;
  const struct Class & D.98988;

  D.98982 = this->D.86851.gtype_;
  if (D.98982 == 0) goto <D.98983>; else goto <D.98984>;
  <D.98983>:
  this->D.86851.class_init_func_ = class_init_function;
  D.98985 = g_io_stream_get_type ();
  D.98986 = &this->D.86851;
  Glib::Class::register_derived_type (D.98986, D.98985);
  goto <D.98987>;
  <D.98984>:
  <D.98987>:
  D.98988 = &this->D.86851;
  return D.98988;
}


static void Gio::IOStream_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);
}


static Glib::ObjectBase* Gio::IOStream_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.98991;
  struct ObjectBase * iftmp.7;
  void * D.97824;
  void * D.98993;
  int (*__vtbl_ptr_type) () * D.98996;
  int (*__vtbl_ptr_type) () * D.98997;
  long int D.98998;
  sizetype D.98999;

  D.97824 = operator new (48);
  try
    {
      Gio::IOStream::IOStream (D.97824, object);
    }
  catch
    {
      operator delete (D.97824);
    }
  D.98993 = D.97824;
  if (D.98993 != 0B) goto <D.98994>; else goto <D.98995>;
  <D.98994>:
  D.98996 = MEM[(struct IOStream *)D.98993].D.86809._vptr.Object;
  D.98997 = D.98996 + 18446744073709551592;
  D.98998 = MEM[(long int *)D.98997];
  D.98999 = (sizetype) D.98998;
  iftmp.7 = D.98993 + D.98999;
  goto <D.99000>;
  <D.98995>:
  iftmp.7 = 0B;
  <D.99000>:
  D.98991 = iftmp.7;
  return D.98991;
}


GIOStream* Gio::IOStream::gobj_copy() (struct IOStream * const this)
{
  int (*__vtbl_ptr_type) () * D.99004;
  int (*__vtbl_ptr_type) () * D.99005;
  long int D.99006;
  sizetype D.99007;
  struct ObjectBase * D.99008;
  int (*__vtbl_ptr_type) () * D.99009;
  int (*__vtbl_ptr_type) () * D.99010;
  int (*__vtbl_ptr_type) () D.99011;
  struct GIOStream * D.99012;

  D.99004 = this->D.86809._vptr.Object;
  D.99005 = D.99004 + 18446744073709551592;
  D.99006 = MEM[(long int *)D.99005];
  D.99007 = (sizetype) D.99006;
  D.99008 = this + D.99007;
  D.99004 = this->D.86809._vptr.Object;
  D.99005 = D.99004 + 18446744073709551592;
  D.99006 = MEM[(long int *)D.99005];
  D.99007 = (sizetype) D.99006;
  D.99008 = this + D.99007;
  D.99009 = D.99008->_vptr.ObjectBase;
  D.99010 = D.99009 + 16;
  D.99011 = *D.99010;
  D.99004 = this->D.86809._vptr.Object;
  D.99005 = D.99004 + 18446744073709551592;
  D.99006 = MEM[(long int *)D.99005];
  D.99007 = (sizetype) D.99006;
  D.99008 = this + D.99007;
  OBJ_TYPE_REF(D.99011;(const struct ObjectBase)D.99008->2) (D.99008);
  D.99012 = Gio::IOStream::gobj (this);
  return D.99012;
}


Gio::IOStream::IOStream(const Glib::ConstructParams&) (struct IOStream * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.99016;
  const void * * iftmp.8;
  struct ObjectBase * D.99024;
  const void * * iftmp.9;
  struct Object * D.99030;
  int (*__vtbl_ptr_type) () * iftmp.10;
  sizetype iftmp.11;
  int (*__vtbl_ptr_type) () * D.99038;
  int (*__vtbl_ptr_type) () * D.99039;
  long int D.99040;
  struct ObjectBase * D.99042;
  int (*__vtbl_ptr_type) () * iftmp.12;
  const void * * iftmp.13;
  const void * * iftmp.14;

  if (0 != 0) goto <D.99014>; else goto <D.99015>;
  <D.99014>:
  D.99016 = &this->D.86812;
  sigc::trackable::trackable (D.99016);
  goto <D.99017>;
  <D.99015>:
  <D.99017>:
  try
    {
      if (0 != 0) goto <D.99018>; else goto <D.99019>;
      <D.99018>:
      if (0 == 0) goto <D.99021>; else goto <D.99022>;
      <D.99021>:
      iftmp.8 = __vtt_parm + 32;
      goto <D.99023>;
      <D.99022>:
      iftmp.8 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
      <D.99023>:
      D.99024 = &this->D.86811;
      Glib::ObjectBase::ObjectBase (D.99024, iftmp.8);
      goto <D.99025>;
      <D.99019>:
      <D.99025>:
      try
        {
          if (0 == 0) goto <D.99027>; else goto <D.99028>;
          <D.99027>:
          iftmp.9 = __vtt_parm + 8;
          goto <D.99029>;
          <D.99028>:
          iftmp.9 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
          <D.99029>:
          D.99030 = &this->D.86809;
          Glib::Object::Object (D.99030, iftmp.9, construct_params);
          try
            {
              if (0 == 0) goto <D.99032>; else goto <D.99033>;
              <D.99032>:
              iftmp.10 = *__vtt_parm;
              goto <D.99034>;
              <D.99033>:
              iftmp.10 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
              <D.99034>:
              this->D.86809._vptr.Object = iftmp.10;
              if (0 == 0) goto <D.99036>; else goto <D.99037>;
              <D.99036>:
              D.99038 = this->D.86809._vptr.Object;
              D.99039 = D.99038 + 18446744073709551592;
              D.99040 = MEM[(long int *)D.99039];
              iftmp.11 = (sizetype) D.99040;
              goto <D.99041>;
              <D.99037>:
              iftmp.11 = 8;
              <D.99041>:
              D.99042 = this + iftmp.11;
              if (0 == 0) goto <D.99044>; else goto <D.99045>;
              <D.99044>:
              iftmp.12 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99046>;
              <D.99045>:
              iftmp.12 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
              <D.99046>:
              D.99042->_vptr.ObjectBase = iftmp.12;
            }
          catch
            {
              if (0 == 0) goto <D.99048>; else goto <D.99049>;
              <D.99048>:
              iftmp.13 = __vtt_parm + 8;
              goto <D.99050>;
              <D.99049>:
              iftmp.13 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
              <D.99050>:
              D.99030 = &this->D.86809;
              Glib::Object::~Object (D.99030, iftmp.13);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99051>; else goto <D.99052>;
          <D.99051>:
          if (0 == 0) goto <D.99054>; else goto <D.99055>;
          <D.99054>:
          iftmp.14 = __vtt_parm + 32;
          goto <D.99056>;
          <D.99055>:
          iftmp.14 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
          <D.99056>:
          D.99024 = &this->D.86811;
          Glib::ObjectBase::~ObjectBase (D.99024, iftmp.14);
          goto <D.99057>;
          <D.99052>:
          <D.99057>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99058>; else goto <D.99059>;
      <D.99058>:
      D.99016 = &this->D.86812;
      sigc::trackable::~trackable (D.99016);
      goto <D.99060>;
      <D.99059>:
      <D.99060>:
    }
}


Gio::IOStream::IOStream(const Glib::ConstructParams&) (struct IOStream * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.99065;
  const void * * iftmp.15;
  struct ObjectBase * D.99073;
  const void * * iftmp.16;
  struct Object * D.99079;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.99083;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.99088;
  int (*__vtbl_ptr_type) () * D.99089;
  long int D.99090;
  struct ObjectBase * D.99092;
  int (*__vtbl_ptr_type) () * iftmp.19;
  const void * * iftmp.20;
  const void * * iftmp.21;

  if (1 != 0) goto <D.99063>; else goto <D.99064>;
  <D.99063>:
  D.99065 = &this->D.86812;
  sigc::trackable::trackable (D.99065);
  goto <D.99066>;
  <D.99064>:
  <D.99066>:
  try
    {
      if (1 != 0) goto <D.99067>; else goto <D.99068>;
      <D.99067>:
      if (1 == 0) goto <D.99070>; else goto <D.99071>;
      <D.99070>:
      iftmp.15 = 32B;
      goto <D.99072>;
      <D.99071>:
      iftmp.15 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
      <D.99072>:
      D.99073 = &this->D.86811;
      Glib::ObjectBase::ObjectBase (D.99073, iftmp.15);
      goto <D.99074>;
      <D.99068>:
      <D.99074>:
      try
        {
          if (1 == 0) goto <D.99076>; else goto <D.99077>;
          <D.99076>:
          iftmp.16 = 8B;
          goto <D.99078>;
          <D.99077>:
          iftmp.16 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
          <D.99078>:
          D.99079 = &this->D.86809;
          Glib::Object::Object (D.99079, iftmp.16, construct_params);
          try
            {
              if (1 == 0) goto <D.99081>; else goto <D.99082>;
              <D.99081>:
              D.99083 = 0B;
              iftmp.17 = *D.99083;
              goto <D.99084>;
              <D.99082>:
              iftmp.17 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
              <D.99084>:
              this->D.86809._vptr.Object = iftmp.17;
              if (1 == 0) goto <D.99086>; else goto <D.99087>;
              <D.99086>:
              D.99088 = this->D.86809._vptr.Object;
              D.99089 = D.99088 + 18446744073709551592;
              D.99090 = MEM[(long int *)D.99089];
              iftmp.18 = (sizetype) D.99090;
              goto <D.99091>;
              <D.99087>:
              iftmp.18 = 8;
              <D.99091>:
              D.99092 = this + iftmp.18;
              if (1 == 0) goto <D.99094>; else goto <D.99095>;
              <D.99094>:
              iftmp.19 = MEM[(const void * *)0B + 24B];
              goto <D.99096>;
              <D.99095>:
              iftmp.19 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
              <D.99096>:
              D.99092->_vptr.ObjectBase = iftmp.19;
            }
          catch
            {
              if (1 == 0) goto <D.99098>; else goto <D.99099>;
              <D.99098>:
              iftmp.20 = 8B;
              goto <D.99100>;
              <D.99099>:
              iftmp.20 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
              <D.99100>:
              D.99079 = &this->D.86809;
              Glib::Object::~Object (D.99079, iftmp.20);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99101>; else goto <D.99102>;
          <D.99101>:
          if (1 == 0) goto <D.99104>; else goto <D.99105>;
          <D.99104>:
          iftmp.21 = 32B;
          goto <D.99106>;
          <D.99105>:
          iftmp.21 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
          <D.99106>:
          D.99073 = &this->D.86811;
          Glib::ObjectBase::~ObjectBase (D.99073, iftmp.21);
          goto <D.99107>;
          <D.99102>:
          <D.99107>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99108>; else goto <D.99109>;
      <D.99108>:
      D.99065 = &this->D.86812;
      sigc::trackable::~trackable (D.99065);
      goto <D.99110>;
      <D.99109>:
      <D.99110>:
    }
}


Gio::IOStream::IOStream(GIOStream*) (struct IOStream * const this, const void * * __vtt_parm, struct GIOStream * castitem)
{
  struct trackable * D.99115;
  const void * * iftmp.22;
  struct ObjectBase * D.99123;
  const void * * iftmp.23;
  struct Object * D.99129;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.99137;
  int (*__vtbl_ptr_type) () * D.99138;
  long int D.99139;
  struct ObjectBase * D.99141;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * iftmp.27;
  const void * * iftmp.28;

  if (0 != 0) goto <D.99113>; else goto <D.99114>;
  <D.99113>:
  D.99115 = &this->D.86812;
  sigc::trackable::trackable (D.99115);
  goto <D.99116>;
  <D.99114>:
  <D.99116>:
  try
    {
      if (0 != 0) goto <D.99117>; else goto <D.99118>;
      <D.99117>:
      if (0 == 0) goto <D.99120>; else goto <D.99121>;
      <D.99120>:
      iftmp.22 = __vtt_parm + 32;
      goto <D.99122>;
      <D.99121>:
      iftmp.22 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
      <D.99122>:
      D.99123 = &this->D.86811;
      Glib::ObjectBase::ObjectBase (D.99123, iftmp.22);
      goto <D.99124>;
      <D.99118>:
      <D.99124>:
      try
        {
          if (0 == 0) goto <D.99126>; else goto <D.99127>;
          <D.99126>:
          iftmp.23 = __vtt_parm + 8;
          goto <D.99128>;
          <D.99127>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
          <D.99128>:
          D.99129 = &this->D.86809;
          Glib::Object::Object (D.99129, iftmp.23, castitem);
          try
            {
              if (0 == 0) goto <D.99131>; else goto <D.99132>;
              <D.99131>:
              iftmp.24 = *__vtt_parm;
              goto <D.99133>;
              <D.99132>:
              iftmp.24 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
              <D.99133>:
              this->D.86809._vptr.Object = iftmp.24;
              if (0 == 0) goto <D.99135>; else goto <D.99136>;
              <D.99135>:
              D.99137 = this->D.86809._vptr.Object;
              D.99138 = D.99137 + 18446744073709551592;
              D.99139 = MEM[(long int *)D.99138];
              iftmp.25 = (sizetype) D.99139;
              goto <D.99140>;
              <D.99136>:
              iftmp.25 = 8;
              <D.99140>:
              D.99141 = this + iftmp.25;
              if (0 == 0) goto <D.99143>; else goto <D.99144>;
              <D.99143>:
              iftmp.26 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99145>;
              <D.99144>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
              <D.99145>:
              D.99141->_vptr.ObjectBase = iftmp.26;
            }
          catch
            {
              if (0 == 0) goto <D.99147>; else goto <D.99148>;
              <D.99147>:
              iftmp.27 = __vtt_parm + 8;
              goto <D.99149>;
              <D.99148>:
              iftmp.27 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
              <D.99149>:
              D.99129 = &this->D.86809;
              Glib::Object::~Object (D.99129, iftmp.27);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99150>; else goto <D.99151>;
          <D.99150>:
          if (0 == 0) goto <D.99153>; else goto <D.99154>;
          <D.99153>:
          iftmp.28 = __vtt_parm + 32;
          goto <D.99155>;
          <D.99154>:
          iftmp.28 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
          <D.99155>:
          D.99123 = &this->D.86811;
          Glib::ObjectBase::~ObjectBase (D.99123, iftmp.28);
          goto <D.99156>;
          <D.99151>:
          <D.99156>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99157>; else goto <D.99158>;
      <D.99157>:
      D.99115 = &this->D.86812;
      sigc::trackable::~trackable (D.99115);
      goto <D.99159>;
      <D.99158>:
      <D.99159>:
    }
}


Gio::IOStream::IOStream(GIOStream*) (struct IOStream * const this, struct GIOStream * castitem)
{
  struct trackable * D.99164;
  const void * * iftmp.29;
  struct ObjectBase * D.99172;
  const void * * iftmp.30;
  struct Object * D.99178;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * D.99182;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.99187;
  int (*__vtbl_ptr_type) () * D.99188;
  long int D.99189;
  struct ObjectBase * D.99191;
  int (*__vtbl_ptr_type) () * iftmp.33;
  const void * * iftmp.34;
  const void * * iftmp.35;

  if (1 != 0) goto <D.99162>; else goto <D.99163>;
  <D.99162>:
  D.99164 = &this->D.86812;
  sigc::trackable::trackable (D.99164);
  goto <D.99165>;
  <D.99163>:
  <D.99165>:
  try
    {
      if (1 != 0) goto <D.99166>; else goto <D.99167>;
      <D.99166>:
      if (1 == 0) goto <D.99169>; else goto <D.99170>;
      <D.99169>:
      iftmp.29 = 32B;
      goto <D.99171>;
      <D.99170>:
      iftmp.29 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
      <D.99171>:
      D.99172 = &this->D.86811;
      Glib::ObjectBase::ObjectBase (D.99172, iftmp.29);
      goto <D.99173>;
      <D.99167>:
      <D.99173>:
      try
        {
          if (1 == 0) goto <D.99175>; else goto <D.99176>;
          <D.99175>:
          iftmp.30 = 8B;
          goto <D.99177>;
          <D.99176>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
          <D.99177>:
          D.99178 = &this->D.86809;
          Glib::Object::Object (D.99178, iftmp.30, castitem);
          try
            {
              if (1 == 0) goto <D.99180>; else goto <D.99181>;
              <D.99180>:
              D.99182 = 0B;
              iftmp.31 = *D.99182;
              goto <D.99183>;
              <D.99181>:
              iftmp.31 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
              <D.99183>:
              this->D.86809._vptr.Object = iftmp.31;
              if (1 == 0) goto <D.99185>; else goto <D.99186>;
              <D.99185>:
              D.99187 = this->D.86809._vptr.Object;
              D.99188 = D.99187 + 18446744073709551592;
              D.99189 = MEM[(long int *)D.99188];
              iftmp.32 = (sizetype) D.99189;
              goto <D.99190>;
              <D.99186>:
              iftmp.32 = 8;
              <D.99190>:
              D.99191 = this + iftmp.32;
              if (1 == 0) goto <D.99193>; else goto <D.99194>;
              <D.99193>:
              iftmp.33 = MEM[(const void * *)0B + 24B];
              goto <D.99195>;
              <D.99194>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
              <D.99195>:
              D.99191->_vptr.ObjectBase = iftmp.33;
            }
          catch
            {
              if (1 == 0) goto <D.99197>; else goto <D.99198>;
              <D.99197>:
              iftmp.34 = 8B;
              goto <D.99199>;
              <D.99198>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
              <D.99199>:
              D.99178 = &this->D.86809;
              Glib::Object::~Object (D.99178, iftmp.34);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99200>; else goto <D.99201>;
          <D.99200>:
          if (1 == 0) goto <D.99203>; else goto <D.99204>;
          <D.99203>:
          iftmp.35 = 32B;
          goto <D.99205>;
          <D.99204>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
          <D.99205>:
          D.99172 = &this->D.86811;
          Glib::ObjectBase::~ObjectBase (D.99172, iftmp.35);
          goto <D.99206>;
          <D.99201>:
          <D.99206>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99207>; else goto <D.99208>;
      <D.99207>:
      D.99164 = &this->D.86812;
      sigc::trackable::~trackable (D.99164);
      goto <D.99209>;
      <D.99208>:
      <D.99209>:
    }
}


Gio::IOStream::~IOStream() (struct IOStream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.36;
  sizetype iftmp.37;
  int (*__vtbl_ptr_type) () * D.99219;
  int (*__vtbl_ptr_type) () * D.99220;
  long int D.99221;
  struct ObjectBase * D.99223;
  int (*__vtbl_ptr_type) () * iftmp.38;
  const void * * iftmp.39;
  struct Object * D.99232;
  int D.99233;
  const void * * iftmp.40;
  struct ObjectBase * D.99240;
  struct trackable * D.99244;
  int D.99246;

  {
    if (0 == 0) goto <D.99213>; else goto <D.99214>;
    <D.99213>:
    iftmp.36 = *__vtt_parm;
    goto <D.99215>;
    <D.99214>:
    iftmp.36 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
    <D.99215>:
    this->D.86809._vptr.Object = iftmp.36;
    if (0 == 0) goto <D.99217>; else goto <D.99218>;
    <D.99217>:
    D.99219 = this->D.86809._vptr.Object;
    D.99220 = D.99219 + 18446744073709551592;
    D.99221 = MEM[(long int *)D.99220];
    iftmp.37 = (sizetype) D.99221;
    goto <D.99222>;
    <D.99218>:
    iftmp.37 = 8;
    <D.99222>:
    D.99223 = this + iftmp.37;
    if (0 == 0) goto <D.99225>; else goto <D.99226>;
    <D.99225>:
    iftmp.38 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.99227>;
    <D.99226>:
    iftmp.38 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
    <D.99227>:
    D.99223->_vptr.ObjectBase = iftmp.38;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.99229>; else goto <D.99230>;
                    <D.99229>:
                    iftmp.39 = __vtt_parm + 8;
                    goto <D.99231>;
                    <D.99230>:
                    iftmp.39 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
                    <D.99231>:
                    D.99232 = &this->D.86809;
                    Glib::Object::~Object (D.99232, iftmp.39);
                  }
              }
            finally
              {
                D.99233 = 0;
                if (D.99233 != 0) goto <D.99234>; else goto <D.99235>;
                <D.99234>:
                if (0 == 0) goto <D.99237>; else goto <D.99238>;
                <D.99237>:
                iftmp.40 = __vtt_parm + 32;
                goto <D.99239>;
                <D.99238>:
                iftmp.40 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
                <D.99239>:
                D.99240 = &this->D.86811;
                Glib::ObjectBase::~ObjectBase (D.99240, iftmp.40);
                goto <D.99241>;
                <D.99235>:
                <D.99241>:
              }
          }
        finally
          {
            D.99233 = 0;
            if (D.99233 != 0) goto <D.99242>; else goto <D.99243>;
            <D.99242>:
            D.99244 = &this->D.86812;
            sigc::trackable::~trackable (D.99244);
            goto <D.99245>;
            <D.99243>:
            <D.99245>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97852>:
  D.99246 = 0;
  if (D.99246 != 0) goto <D.99247>; else goto <D.99248>;
  <D.99247>:
  operator delete (this);
  goto <D.99249>;
  <D.99248>:
  <D.99249>:
}


virtual Gio::IOStream::~IOStream() (struct IOStream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.41;
  const void * * D.99265;
  sizetype iftmp.42;
  int (*__vtbl_ptr_type) () * D.99270;
  int (*__vtbl_ptr_type) () * D.99271;
  long int D.99272;
  struct ObjectBase * D.99274;
  int (*__vtbl_ptr_type) () * iftmp.43;
  const void * * iftmp.44;
  struct Object * D.99283;
  int D.99284;
  const void * * iftmp.45;
  struct ObjectBase * D.99291;
  struct trackable * D.99295;
  int D.99297;

  {
    if (2 == 0) goto <D.99263>; else goto <D.99264>;
    <D.99263>:
    D.99265 = 0B;
    iftmp.41 = *D.99265;
    goto <D.99266>;
    <D.99264>:
    iftmp.41 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 32B];
    <D.99266>:
    this->D.86809._vptr.Object = iftmp.41;
    if (2 == 0) goto <D.99268>; else goto <D.99269>;
    <D.99268>:
    D.99270 = this->D.86809._vptr.Object;
    D.99271 = D.99270 + 18446744073709551592;
    D.99272 = MEM[(long int *)D.99271];
    iftmp.42 = (sizetype) D.99272;
    goto <D.99273>;
    <D.99269>:
    iftmp.42 = 8;
    <D.99273>:
    D.99274 = this + iftmp.42;
    if (2 == 0) goto <D.99276>; else goto <D.99277>;
    <D.99276>:
    iftmp.43 = MEM[(const void * *)0B + 24B];
    goto <D.99278>;
    <D.99277>:
    iftmp.43 = &MEM[(void *)&_ZTVN3Gio8IOStreamE + 112B];
    <D.99278>:
    D.99274->_vptr.ObjectBase = iftmp.43;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.99280>; else goto <D.99281>;
                    <D.99280>:
                    iftmp.44 = 8B;
                    goto <D.99282>;
                    <D.99281>:
                    iftmp.44 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 8B];
                    <D.99282>:
                    D.99283 = &this->D.86809;
                    Glib::Object::~Object (D.99283, iftmp.44);
                  }
              }
            finally
              {
                D.99284 = 2;
                if (D.99284 != 0) goto <D.99285>; else goto <D.99286>;
                <D.99285>:
                if (2 == 0) goto <D.99288>; else goto <D.99289>;
                <D.99288>:
                iftmp.45 = 32B;
                goto <D.99290>;
                <D.99289>:
                iftmp.45 = &MEM[(void *)&_ZTTN3Gio8IOStreamE + 32B];
                <D.99290>:
                D.99291 = &this->D.86811;
                Glib::ObjectBase::~ObjectBase (D.99291, iftmp.45);
                goto <D.99292>;
                <D.99286>:
                <D.99292>:
              }
          }
        finally
          {
            D.99284 = 2;
            if (D.99284 != 0) goto <D.99293>; else goto <D.99294>;
            <D.99293>:
            D.99295 = &this->D.86812;
            sigc::trackable::~trackable (D.99295);
            goto <D.99296>;
            <D.99294>:
            <D.99296>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97855>:
  D.99297 = 0;
  if (D.99297 != 0) goto <D.99298>; else goto <D.99299>;
  <D.99298>:
  operator delete (this);
  goto <D.99300>;
  <D.99299>:
  <D.99300>:
}


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


static GType Gio::IOStream::get_type() ()
{
  GType D.99313;
  const struct Class & D.99314;

  D.99314 = Gio::IOStream_Class::init (&iostream_class_);
  D.99313 = Glib::Class::get_type (D.99314);
  return D.99313;
}


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

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


static GType Gio::IOStream::get_base_type() ()
{
  GType D.99319;

  D.99319 = g_io_stream_get_type ();
  return D.99319;
}


static bool Gio::IOStream::splice_finish(const Glib::RefPtr<Gio::AsyncResult>&) (const struct RefPtr & result)
{
  struct BaseObjectType * D.99322;
  int D.99323;
  struct GError * gerror.46;
  bool D.99327;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99322 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99323 = g_io_stream_splice_finish (D.99322, &gerror);
      retvalue = D.99323 != 0;
      gerror.46 = gerror;
      if (gerror.46 != 0B) goto <D.99325>; else goto <D.99326>;
      <D.99325>:
      gerror.46 = gerror;
      Glib::Error::throw_exception (gerror.46);
      <D.99326>:
      D.99327 = retvalue;
      return D.99327;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::AsyncResult; typename T::BaseObjectType = _GAsyncResult] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.99333;
  struct BaseObjectType * iftmp.47;
  bool D.99335;
  struct AsyncResult * D.99338;

  D.99335 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.99335 != 0) goto <D.99336>; else goto <D.99337>;
  <D.99336>:
  D.99338 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.47 = Gio::AsyncResult::gobj (D.99338);
  goto <D.99339>;
  <D.99337>:
  iftmp.47 = 0B;
  <D.99339>:
  D.99333 = iftmp.47;
  return D.99333;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::AsyncResult] (const struct RefPtr * const this)
{
  bool D.99341;
  struct AsyncResult * D.99342;

  D.99342 = this->pCppObject_;
  D.99341 = D.99342 != 0B;
  return D.99341;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.99346;
  int (*__vtbl_ptr_type) () * D.99347;
  int (*__vtbl_ptr_type) () * D.99348;
  long int D.99349;
  sizetype D.99350;
  struct ObjectBase * D.99351;

  D.99347 = this->D.86030._vptr.Interface;
  D.99348 = D.99347 + 18446744073709551592;
  D.99349 = MEM[(long int *)D.99348];
  D.99350 = (sizetype) D.99349;
  D.99351 = this + D.99350;
  D.99346 = D.99351->gobject_;
  return D.99346;
}


Glib::RefPtr<Gio::InputStream> Gio::IOStream::get_input_stream() (struct IOStream * const this)
{
  struct GIOStream * D.99354;
  struct GInputStream * D.99355;
  bool retval.48;
  struct InputStream * D.99359;
  int (*__vtbl_ptr_type) () * D.99360;
  int (*__vtbl_ptr_type) () * D.99361;
  long int D.99362;
  sizetype D.99363;
  struct ObjectBase * D.99364;
  int (*__vtbl_ptr_type) () * D.99365;
  int (*__vtbl_ptr_type) () * D.99366;
  int (*__vtbl_ptr_type) () D.99367;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.99354 = Gio::IOStream::gobj (this);
  D.99355 = g_io_stream_get_input_stream (D.99354);
  *<retval> = Glib::wrap (D.99355, 0); [return slot optimization]
  try
    {
      retval.48 = Glib::RefPtr<Gio::InputStream>::operator bool (<retval>);
      if (retval.48 != 0) goto <D.99357>; else goto <D.99358>;
      <D.99357>:
      D.99359 = Glib::RefPtr<Gio::InputStream>::operator-> (<retval>);
      D.99360 = D.99359->D.86366._vptr.Object;
      D.99361 = D.99360 + 18446744073709551592;
      D.99362 = MEM[(long int *)D.99361];
      D.99363 = (sizetype) D.99362;
      D.99364 = D.99359 + D.99363;
      D.99360 = D.99359->D.86366._vptr.Object;
      D.99361 = D.99360 + 18446744073709551592;
      D.99362 = MEM[(long int *)D.99361];
      D.99363 = (sizetype) D.99362;
      D.99364 = D.99359 + D.99363;
      D.99365 = D.99364->_vptr.ObjectBase;
      D.99366 = D.99365 + 16;
      D.99367 = *D.99366;
      D.99360 = D.99359->D.86366._vptr.Object;
      D.99361 = D.99360 + 18446744073709551592;
      D.99362 = MEM[(long int *)D.99361];
      D.99363 = (sizetype) D.99362;
      D.99364 = D.99359 + D.99363;
      OBJ_TYPE_REF(D.99367;(const struct ObjectBase)D.99364->2) (D.99364);
      goto <D.99368>;
      <D.99358>:
      <D.99368>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::InputStream>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::InputStream] (const struct RefPtr * const this)
{
  bool D.99372;
  struct InputStream * D.99373;

  D.99373 = this->pCppObject_;
  D.99372 = D.99373 != 0B;
  return D.99372;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::InputStream] (struct RefPtr * const this)
{
  struct InputStream * D.99377;
  int (*__vtbl_ptr_type) () * D.99380;
  int (*__vtbl_ptr_type) () * D.99381;
  long int D.99382;
  sizetype D.99383;
  struct ObjectBase * D.99384;
  int (*__vtbl_ptr_type) () * D.99385;
  int (*__vtbl_ptr_type) () * D.99386;
  int (*__vtbl_ptr_type) () D.99387;

  {
    try
      {
        D.99377 = this->pCppObject_;
        if (D.99377 != 0B) goto <D.99378>; else goto <D.99379>;
        <D.99378>:
        D.99377 = this->pCppObject_;
        D.99377 = this->pCppObject_;
        D.99380 = D.99377->D.86366._vptr.Object;
        D.99381 = D.99380 + 18446744073709551592;
        D.99382 = MEM[(long int *)D.99381];
        D.99383 = (sizetype) D.99382;
        D.99384 = D.99377 + D.99383;
        D.99377 = this->pCppObject_;
        D.99377 = this->pCppObject_;
        D.99380 = D.99377->D.86366._vptr.Object;
        D.99381 = D.99380 + 18446744073709551592;
        D.99382 = MEM[(long int *)D.99381];
        D.99383 = (sizetype) D.99382;
        D.99384 = D.99377 + D.99383;
        D.99385 = D.99384->_vptr.ObjectBase;
        D.99386 = D.99385 + 24;
        D.99387 = *D.99386;
        D.99377 = this->pCppObject_;
        D.99377 = this->pCppObject_;
        D.99380 = D.99377->D.86366._vptr.Object;
        D.99381 = D.99380 + 18446744073709551592;
        D.99382 = MEM[(long int *)D.99381];
        D.99383 = (sizetype) D.99382;
        D.99384 = D.99377 + D.99383;
        OBJ_TYPE_REF(D.99387;(const struct ObjectBase)D.99384->3) (D.99384);
        goto <D.99388>;
        <D.99379>:
        <D.99388>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98571>:
}


Glib::RefPtr<Gio::OutputStream> Gio::IOStream::get_output_stream() (struct IOStream * const this)
{
  struct GIOStream * D.99391;
  struct GOutputStream * D.99392;
  bool retval.49;
  struct OutputStream * D.99396;
  int (*__vtbl_ptr_type) () * D.99397;
  int (*__vtbl_ptr_type) () * D.99398;
  long int D.99399;
  sizetype D.99400;
  struct ObjectBase * D.99401;
  int (*__vtbl_ptr_type) () * D.99402;
  int (*__vtbl_ptr_type) () * D.99403;
  int (*__vtbl_ptr_type) () D.99404;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.99391 = Gio::IOStream::gobj (this);
  D.99392 = g_io_stream_get_output_stream (D.99391);
  *<retval> = Glib::wrap (D.99392, 0); [return slot optimization]
  try
    {
      retval.49 = Glib::RefPtr<Gio::OutputStream>::operator bool (<retval>);
      if (retval.49 != 0) goto <D.99394>; else goto <D.99395>;
      <D.99394>:
      D.99396 = Glib::RefPtr<Gio::OutputStream>::operator-> (<retval>);
      D.99397 = D.99396->D.86631._vptr.Object;
      D.99398 = D.99397 + 18446744073709551592;
      D.99399 = MEM[(long int *)D.99398];
      D.99400 = (sizetype) D.99399;
      D.99401 = D.99396 + D.99400;
      D.99397 = D.99396->D.86631._vptr.Object;
      D.99398 = D.99397 + 18446744073709551592;
      D.99399 = MEM[(long int *)D.99398];
      D.99400 = (sizetype) D.99399;
      D.99401 = D.99396 + D.99400;
      D.99402 = D.99401->_vptr.ObjectBase;
      D.99403 = D.99402 + 16;
      D.99404 = *D.99403;
      D.99397 = D.99396->D.86631._vptr.Object;
      D.99398 = D.99397 + 18446744073709551592;
      D.99399 = MEM[(long int *)D.99398];
      D.99400 = (sizetype) D.99399;
      D.99401 = D.99396 + D.99400;
      OBJ_TYPE_REF(D.99404;(const struct ObjectBase)D.99401->2) (D.99401);
      goto <D.99405>;
      <D.99395>:
      <D.99405>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Gio::OutputStream>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::OutputStream] (const struct RefPtr * const this)
{
  bool D.99409;
  struct OutputStream * D.99410;

  D.99410 = this->pCppObject_;
  D.99409 = D.99410 != 0B;
  return D.99409;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::OutputStream] (struct RefPtr * const this)
{
  struct OutputStream * D.99414;
  int (*__vtbl_ptr_type) () * D.99417;
  int (*__vtbl_ptr_type) () * D.99418;
  long int D.99419;
  sizetype D.99420;
  struct ObjectBase * D.99421;
  int (*__vtbl_ptr_type) () * D.99422;
  int (*__vtbl_ptr_type) () * D.99423;
  int (*__vtbl_ptr_type) () D.99424;

  {
    try
      {
        D.99414 = this->pCppObject_;
        if (D.99414 != 0B) goto <D.99415>; else goto <D.99416>;
        <D.99415>:
        D.99414 = this->pCppObject_;
        D.99414 = this->pCppObject_;
        D.99417 = D.99414->D.86631._vptr.Object;
        D.99418 = D.99417 + 18446744073709551592;
        D.99419 = MEM[(long int *)D.99418];
        D.99420 = (sizetype) D.99419;
        D.99421 = D.99414 + D.99420;
        D.99414 = this->pCppObject_;
        D.99414 = this->pCppObject_;
        D.99417 = D.99414->D.86631._vptr.Object;
        D.99418 = D.99417 + 18446744073709551592;
        D.99419 = MEM[(long int *)D.99418];
        D.99420 = (sizetype) D.99419;
        D.99421 = D.99414 + D.99420;
        D.99422 = D.99421->_vptr.ObjectBase;
        D.99423 = D.99422 + 24;
        D.99424 = *D.99423;
        D.99414 = this->pCppObject_;
        D.99414 = this->pCppObject_;
        D.99417 = D.99414->D.86631._vptr.Object;
        D.99418 = D.99417 + 18446744073709551592;
        D.99419 = MEM[(long int *)D.99418];
        D.99420 = (sizetype) D.99419;
        D.99421 = D.99414 + D.99420;
        OBJ_TYPE_REF(D.99424;(const struct ObjectBase)D.99421->3) (D.99421);
        goto <D.99425>;
        <D.99416>:
        <D.99425>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98583>:
}


bool Gio::IOStream::close(const Glib::RefPtr<Gio::Cancellable>&) (struct IOStream * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99427;
  struct GIOStream * D.99428;
  int D.99429;
  struct GError * gerror.50;
  bool D.99433;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99427 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99428 = Gio::IOStream::gobj (this);
      D.99429 = g_io_stream_close (D.99428, D.99427, &gerror);
      retvalue = D.99429 != 0;
      gerror.50 = gerror;
      if (gerror.50 != 0B) goto <D.99431>; else goto <D.99432>;
      <D.99431>:
      gerror.50 = gerror;
      Glib::Error::throw_exception (gerror.50);
      <D.99432>:
      D.99433 = retvalue;
      return D.99433;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::IOStream::close() (struct IOStream * const this)
{
  struct GIOStream * D.99439;
  int D.99440;
  struct GError * gerror.51;
  bool D.99444;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99439 = Gio::IOStream::gobj (this);
      D.99440 = g_io_stream_close (D.99439, 0B, &gerror);
      retvalue = D.99440 != 0;
      gerror.51 = gerror;
      if (gerror.51 != 0B) goto <D.99442>; else goto <D.99443>;
      <D.99442>:
      gerror.51 = gerror;
      Glib::Error::throw_exception (gerror.51);
      <D.99443>:
      D.99444 = retvalue;
      return D.99444;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::IOStream::close_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct IOStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99449;
  struct GIOStream * D.99450;
  int D.99451;
  struct GError * gerror.52;
  bool D.99455;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99449 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99450 = Gio::IOStream::gobj (this);
      D.99451 = g_io_stream_close_finish (D.99450, D.99449, &gerror);
      retvalue = D.99451 != 0;
      gerror.52 = gerror;
      if (gerror.52 != 0B) goto <D.99453>; else goto <D.99454>;
      <D.99453>:
      gerror.52 = gerror;
      Glib::Error::throw_exception (gerror.52);
      <D.99454>:
      D.99455 = retvalue;
      return D.99455;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::IOStream::is_closed() const (const struct IOStream * const this)
{
  bool D.99461;
  const struct GIOStream * D.99462;
  int D.99463;

  D.99462 = Gio::IOStream::gobj (this);
  D.99463 = g_io_stream_is_closed (D.99462);
  D.99461 = D.99463 != 0;
  return D.99461;
}


const GIOStream* Gio::IOStream::gobj() const (const struct IOStream * const this)
{
  const struct GIOStream * D.99466;
  int (*__vtbl_ptr_type) () * D.99467;
  int (*__vtbl_ptr_type) () * D.99468;
  long int D.99469;
  sizetype D.99470;
  const struct ObjectBase * D.99471;

  D.99467 = this->D.86809._vptr.Object;
  D.99468 = D.99467 + 18446744073709551592;
  D.99469 = MEM[(long int *)D.99468];
  D.99470 = (sizetype) D.99469;
  D.99471 = this + D.99470;
  D.99466 = D.99471->gobject_;
  return D.99466;
}


bool Gio::IOStream::has_pending() const (const struct IOStream * const this)
{
  bool D.99473;
  const struct GIOStream * D.99474;
  int D.99475;

  D.99474 = Gio::IOStream::gobj (this);
  D.99475 = g_io_stream_has_pending (D.99474);
  D.99473 = D.99475 != 0;
  return D.99473;
}


bool Gio::IOStream::set_pending() (struct IOStream * const this)
{
  struct GIOStream * D.99478;
  int D.99479;
  struct GError * gerror.53;
  bool D.99483;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99478 = Gio::IOStream::gobj (this);
      D.99479 = g_io_stream_set_pending (D.99478, &gerror);
      retvalue = D.99479 != 0;
      gerror.53 = gerror;
      if (gerror.53 != 0B) goto <D.99481>; else goto <D.99482>;
      <D.99481>:
      gerror.53 = gerror;
      Glib::Error::throw_exception (gerror.53);
      <D.99482>:
      D.99483 = retvalue;
      return D.99483;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::IOStream::clear_pending() (struct IOStream * const this)
{
  struct GIOStream * D.99488;

  D.99488 = Gio::IOStream::gobj (this);
  g_io_stream_clear_pending (D.99488);
}