void Gio::OutputStream::write_async(const void*, gsize, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct OutputStream * const this, const void * buffer, gsize count, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.0;
  struct BaseObjectType * D.98978;
  struct GOutputStream * D.98979;
  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.98978 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.98979 = Gio::OutputStream::gobj (this);
  g_output_stream_write_async (D.98979, buffer, count, io_priority, D.98978, 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.98984;

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

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


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.98985;
  struct slot_base * D.98986;

  D.98985 = &src->D.97166;
  D.98986 = &this->D.97166;
  sigc::slot_base::slot_base (D.98986, D.98985);
  try
    {

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


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.98987;
  struct BaseObjectType * iftmp.1;
  bool D.98989;
  struct Cancellable * D.98992;

  D.98989 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.98989 != 0) goto <D.98990>; else goto <D.98991>;
  <D.98990>:
  D.98992 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.1 = Gio::Cancellable::gobj (D.98992);
  goto <D.98993>;
  <D.98991>:
  iftmp.1 = 0B;
  <D.98993>:
  D.98987 = iftmp.1;
  return D.98987;
}


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

  D.98996 = this->pCppObject_;
  D.98995 = D.98996 != 0B;
  return D.98995;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.99000;
  int (*__vtbl_ptr_type) () * D.99001;
  int (*__vtbl_ptr_type) () * D.99002;
  long int D.99003;
  sizetype D.99004;
  struct ObjectBase * D.99005;

  D.99001 = this->D.86174._vptr.Object;
  D.99002 = D.99001 + 18446744073709551592;
  D.99003 = MEM[(long int *)D.99002];
  D.99004 = (sizetype) D.99003;
  D.99005 = this + D.99004;
  D.99000 = D.99005->gobject_;
  return D.99000;
}


GOutputStream* Gio::OutputStream::gobj() (struct OutputStream * const this)
{
  struct GOutputStream * D.99007;
  int (*__vtbl_ptr_type) () * D.99008;
  int (*__vtbl_ptr_type) () * D.99009;
  long int D.99010;
  sizetype D.99011;
  struct ObjectBase * D.99012;

  D.99008 = this->D.86631._vptr.Object;
  D.99009 = D.99008 + 18446744073709551592;
  D.99010 = MEM[(long int *)D.99009];
  D.99011 = (sizetype) D.99010;
  D.99012 = this + D.99011;
  D.99007 = D.99012->gobject_;
  return D.99007;
}


void Gio::OutputStream::write_async(const void*, gsize, const SlotAsyncReady&, int) (struct OutputStream * const this, const void * buffer, gsize count, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.2;
  struct GOutputStream * D.99014;
  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.99014 = Gio::OutputStream::gobj (this);
  g_output_stream_write_async (D.99014, buffer, count, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::OutputStream::splice_async(const Glib::RefPtr<Gio::InputStream>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, Gio::OutputStreamSpliceFlags, int) (struct OutputStream * const this, const struct RefPtr & source, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, OutputStreamSpliceFlags flags, int io_priority)
{
  void * slot_copy.3;
  struct BaseObjectType * D.99017;
  struct BaseObjectType * D.99018;
  struct GOutputStream * D.99019;
  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.99017 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.99018 = Glib::unwrap<Gio::InputStream> (source);
  D.99019 = Gio::OutputStream::gobj (this);
  g_output_stream_splice_async (D.99019, D.99018, flags, io_priority, D.99017, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::InputStream; typename T::BaseObjectType = _GInputStream] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.99024;
  struct BaseObjectType * iftmp.4;
  bool D.99026;
  struct InputStream * D.99029;

  D.99026 = Glib::RefPtr<Gio::InputStream>::operator bool (ptr);
  if (D.99026 != 0) goto <D.99027>; else goto <D.99028>;
  <D.99027>:
  D.99029 = Glib::RefPtr<Gio::InputStream>::operator-> (ptr);
  iftmp.4 = Gio::InputStream::gobj (D.99029);
  goto <D.99030>;
  <D.99028>:
  iftmp.4 = 0B;
  <D.99030>:
  D.99024 = iftmp.4;
  return D.99024;
}


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

  D.99033 = this->pCppObject_;
  D.99032 = D.99033 != 0B;
  return D.99032;
}


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

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


GInputStream* Gio::InputStream::gobj() (struct InputStream * const this)
{
  struct GInputStream * D.99037;
  int (*__vtbl_ptr_type) () * D.99038;
  int (*__vtbl_ptr_type) () * D.99039;
  long int D.99040;
  sizetype D.99041;
  struct ObjectBase * D.99042;

  D.99038 = this->D.86366._vptr.Object;
  D.99039 = D.99038 + 18446744073709551592;
  D.99040 = MEM[(long int *)D.99039];
  D.99041 = (sizetype) D.99040;
  D.99042 = this + D.99041;
  D.99037 = D.99042->gobject_;
  return D.99037;
}


void Gio::OutputStream::splice_async(const Glib::RefPtr<Gio::InputStream>&, const SlotAsyncReady&, Gio::OutputStreamSpliceFlags, int) (struct OutputStream * const this, const struct RefPtr & source, const struct SlotAsyncReady & slot, OutputStreamSpliceFlags flags, int io_priority)
{
  void * slot_copy.5;
  struct BaseObjectType * D.99044;
  struct GOutputStream * D.99045;
  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.99044 = Glib::unwrap<Gio::InputStream> (source);
  D.99045 = Gio::OutputStream::gobj (this);
  g_output_stream_splice_async (D.99045, D.99044, flags, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


void Gio::OutputStream::flush_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct OutputStream * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.6;
  struct BaseObjectType * D.99049;
  struct GOutputStream * D.99050;
  struct SlotAsyncReady * slot_copy;

  slot_copy.6 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.6, slot);
    }
  catch
    {
      operator delete (slot_copy.6);
    }
  slot_copy = slot_copy.6;
  D.99049 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.99050 = Gio::OutputStream::gobj (this);
  g_output_stream_flush_async (D.99050, io_priority, D.99049, SignalProxy_async_callback, slot_copy);
}


void Gio::OutputStream::flush_async(const SlotAsyncReady&, int) (struct OutputStream * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.7;
  struct GOutputStream * D.99054;
  struct SlotAsyncReady * slot_copy;

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


void Gio::OutputStream::close_async(const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct OutputStream * const this, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.8;
  struct BaseObjectType * D.99057;
  struct GOutputStream * D.99058;
  struct SlotAsyncReady * slot_copy;

  slot_copy.8 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.8, slot);
    }
  catch
    {
      operator delete (slot_copy.8);
    }
  slot_copy = slot_copy.8;
  D.99057 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.99058 = Gio::OutputStream::gobj (this);
  g_output_stream_close_async (D.99058, io_priority, D.99057, SignalProxy_async_callback, slot_copy);
}


void Gio::OutputStream::close_async(const SlotAsyncReady&, int) (struct OutputStream * const this, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.9;
  struct GOutputStream * D.99062;
  struct SlotAsyncReady * slot_copy;

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


gssize Gio::OutputStream::write(const string&, const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const struct string & buffer, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99065;
  long unsigned int D.99066;
  const char * D.99067;
  struct GOutputStream * D.99068;
  struct GError * gerror.10;
  gssize D.99072;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99065 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99066 = std::basic_string<char>::size (buffer);
      D.99067 = std::basic_string<char>::data (buffer);
      D.99068 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write (D.99068, D.99067, D.99066, D.99065, &gerror);
      gerror.10 = gerror;
      if (gerror.10 != 0B) goto <D.99070>; else goto <D.99071>;
      <D.99070>:
      gerror.10 = gerror;
      Glib::Error::throw_exception (gerror.10);
      <D.99071>:
      D.99072 = retvalue;
      return D.99072;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.99080;
  struct _Rep * D.99081;

  D.99081 = std::basic_string<char>::_M_rep (this);
  D.99080 = D.99081->D.18966._M_length;
  return D.99080;
}


std::basic_string<_CharT, _Traits, _Alloc>::_Rep* std::basic_string<_CharT, _Traits, _Alloc>::_M_rep() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Rep * D.99084;
  char * D.99085;

  D.99085 = std::basic_string<char>::_M_data (this);
  D.99084 = D.99085 + 18446744073709551592;
  return D.99084;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_M_data() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  char * D.99088;

  D.99088 = this->_M_dataplus._M_p;
  return D.99088;
}


const _CharT* std::basic_string<_CharT, _Traits, _Alloc>::data() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  const char * D.99090;

  D.99090 = std::basic_string<char>::_M_data (this);
  return D.99090;
}


gssize Gio::OutputStream::write(const string&) (struct OutputStream * const this, const struct string & buffer)
{
  long unsigned int D.99093;
  const char * D.99094;
  struct GOutputStream * D.99095;
  struct GError * gerror.11;
  gssize D.99099;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99093 = std::basic_string<char>::size (buffer);
      D.99094 = std::basic_string<char>::data (buffer);
      D.99095 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write (D.99095, D.99094, D.99093, 0B, &gerror);
      gerror.11 = gerror;
      if (gerror.11 != 0B) goto <D.99097>; else goto <D.99098>;
      <D.99097>:
      gerror.11 = gerror;
      Glib::Error::throw_exception (gerror.11);
      <D.99098>:
      D.99099 = retvalue;
      return D.99099;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::write_all(const string&, gsize&, const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const struct string & buffer, gsize & bytes_written, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99106;
  long unsigned int D.99107;
  const char * D.99108;
  struct GOutputStream * D.99109;
  int D.99110;
  struct GError * gerror.12;
  bool D.99114;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99106 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99107 = std::basic_string<char>::size (buffer);
      D.99108 = std::basic_string<char>::data (buffer);
      D.99109 = Gio::OutputStream::gobj (this);
      D.99110 = g_output_stream_write_all (D.99109, D.99108, D.99107, bytes_written, D.99106, &gerror);
      retvalue = D.99110 != 0;
      gerror.12 = gerror;
      if (gerror.12 != 0B) goto <D.99112>; else goto <D.99113>;
      <D.99112>:
      gerror.12 = gerror;
      Glib::Error::throw_exception (gerror.12);
      <D.99113>:
      D.99114 = retvalue;
      return D.99114;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::write_all(const string&, gsize&) (struct OutputStream * const this, const struct string & buffer, gsize & bytes_written)
{
  long unsigned int D.99122;
  const char * D.99123;
  struct GOutputStream * D.99124;
  int D.99125;
  struct GError * gerror.13;
  bool D.99129;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99122 = std::basic_string<char>::size (buffer);
      D.99123 = std::basic_string<char>::data (buffer);
      D.99124 = Gio::OutputStream::gobj (this);
      D.99125 = g_output_stream_write_all (D.99124, D.99123, D.99122, bytes_written, 0B, &gerror);
      retvalue = D.99125 != 0;
      gerror.13 = gerror;
      if (gerror.13 != 0B) goto <D.99127>; else goto <D.99128>;
      <D.99127>:
      gerror.13 = gerror;
      Glib::Error::throw_exception (gerror.13);
      <D.99128>:
      D.99129 = retvalue;
      return D.99129;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


void Gio::OutputStream::write_bytes_async(const Glib::RefPtr<const Glib::Bytes>&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, int) (struct OutputStream * const this, const struct RefPtr & bytes, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, int io_priority)
{
  void * slot_copy.14;
  struct BaseObjectType * D.99136;
  const struct BaseObjectType * D.99137;
  struct GOutputStream * D.99138;
  struct SlotAsyncReady * slot_copy;

  slot_copy.14 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.14, slot);
    }
  catch
    {
      operator delete (slot_copy.14);
    }
  slot_copy = slot_copy.14;
  D.99136 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.99137 = Glib::unwrap<Glib::Bytes> (bytes);
  D.99138 = Gio::OutputStream::gobj (this);
  g_output_stream_write_bytes_async (D.99138, D.99137, io_priority, D.99136, SignalProxy_async_callback, slot_copy);
}


const typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<const T>&) [with T = Glib::Bytes; typename T::BaseObjectType = _GBytes] (const struct RefPtr & ptr)
{
  const struct BaseObjectType * D.99143;
  const struct BaseObjectType * iftmp.15;
  bool D.99145;
  const struct Bytes * D.99148;

  D.99145 = Glib::RefPtr<const Glib::Bytes>::operator bool (ptr);
  if (D.99145 != 0) goto <D.99146>; else goto <D.99147>;
  <D.99146>:
  D.99148 = Glib::RefPtr<const Glib::Bytes>::operator-> (ptr);
  iftmp.15 = Glib::Bytes::gobj (D.99148);
  goto <D.99149>;
  <D.99147>:
  iftmp.15 = 0B;
  <D.99149>:
  D.99143 = iftmp.15;
  return D.99143;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = const Glib::Bytes] (const struct RefPtr * const this)
{
  bool D.99152;
  const struct Bytes * D.99153;

  D.99153 = this->pCppObject_;
  D.99152 = D.99153 != 0B;
  return D.99152;
}


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

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


void Gio::OutputStream::write_bytes_async(const Glib::RefPtr<const Glib::Bytes>&, const SlotAsyncReady&, int) (struct OutputStream * const this, const struct RefPtr & bytes, const struct SlotAsyncReady & slot, int io_priority)
{
  void * slot_copy.16;
  const struct BaseObjectType * D.99157;
  struct GOutputStream * D.99158;
  struct SlotAsyncReady * slot_copy;

  slot_copy.16 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.16, slot);
    }
  catch
    {
      operator delete (slot_copy.16);
    }
  slot_copy = slot_copy.16;
  D.99157 = Glib::unwrap<Glib::Bytes> (bytes);
  D.99158 = Gio::OutputStream::gobj (this);
  g_output_stream_write_bytes_async (D.99158, D.99157, io_priority, 0B, SignalProxy_async_callback, slot_copy);
}


gssize Gio::OutputStream::splice(const Glib::RefPtr<Gio::InputStream>&, const Glib::RefPtr<Gio::Cancellable>&, Gio::OutputStreamSpliceFlags) (struct OutputStream * const this, const struct RefPtr & source, const struct RefPtr & cancellable, OutputStreamSpliceFlags flags)
{
  struct BaseObjectType * D.99162;
  struct BaseObjectType * D.99163;
  struct GOutputStream * D.99164;
  struct GError * gerror.17;
  gssize D.99168;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99162 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99163 = Glib::unwrap<Gio::InputStream> (source);
      D.99164 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_splice (D.99164, D.99163, flags, D.99162, &gerror);
      gerror.17 = gerror;
      if (gerror.17 != 0B) goto <D.99166>; else goto <D.99167>;
      <D.99166>:
      gerror.17 = gerror;
      Glib::Error::throw_exception (gerror.17);
      <D.99167>:
      D.99168 = retvalue;
      return D.99168;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::splice(const Glib::RefPtr<Gio::InputStream>&, Gio::OutputStreamSpliceFlags) (struct OutputStream * const this, const struct RefPtr & source, OutputStreamSpliceFlags flags)
{
  struct BaseObjectType * D.99175;
  struct GOutputStream * D.99176;
  struct GError * gerror.18;
  gssize D.99180;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99175 = Glib::unwrap<Gio::InputStream> (source);
      D.99176 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_splice (D.99176, D.99175, flags, 0B, &gerror);
      gerror.18 = gerror;
      if (gerror.18 != 0B) goto <D.99178>; else goto <D.99179>;
      <D.99178>:
      gerror.18 = gerror;
      Glib::Error::throw_exception (gerror.18);
      <D.99179>:
      D.99180 = retvalue;
      return D.99180;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Gio::OutputStream> Glib::wrap(GOutputStream*, bool) (struct GOutputStream * object, bool take_copy)
{
  struct OutputStream * iftmp.19;
  int D.99188;
  struct ObjectBase * D.99189;

  D.99188 = (int) take_copy;
  D.99189 = Glib::wrap_auto (object, D.99188);
  if (D.99189 == 0B) goto <D.99190>; else goto <D.99191>;
  <D.99190>:
  iftmp.19 = 0B;
  goto <D.99192>;
  <D.99191>:
  iftmp.19 = __dynamic_cast (D.99189, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio12OutputStreamE, -1);
  <D.99192>:
  Glib::RefPtr<Gio::OutputStream>::RefPtr (<retval>, iftmp.19);
  return <retval>;
}


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


const Glib::Class& Gio::OutputStream_Class::init() (struct OutputStream_Class * const this)
{
  long unsigned int D.99195;
  long unsigned int D.99198;
  struct Class * D.99199;
  const struct Class & D.99201;

  D.99195 = this->D.86674.gtype_;
  if (D.99195 == 0) goto <D.99196>; else goto <D.99197>;
  <D.99196>:
  this->D.86674.class_init_func_ = class_init_function;
  D.99198 = g_output_stream_get_type ();
  D.99199 = &this->D.86674;
  Glib::Class::register_derived_type (D.99199, D.99198);
  goto <D.99200>;
  <D.99197>:
  <D.99200>:
  D.99201 = &this->D.86674;
  return D.99201;
}


static void Gio::OutputStream_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::OutputStream_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.99204;
  struct ObjectBase * iftmp.20;
  void * D.97871;
  void * D.99206;
  int (*__vtbl_ptr_type) () * D.99209;
  int (*__vtbl_ptr_type) () * D.99210;
  long int D.99211;
  sizetype D.99212;

  D.97871 = operator new (48);
  try
    {
      Gio::OutputStream::OutputStream (D.97871, object);
    }
  catch
    {
      operator delete (D.97871);
    }
  D.99206 = D.97871;
  if (D.99206 != 0B) goto <D.99207>; else goto <D.99208>;
  <D.99207>:
  D.99209 = MEM[(struct OutputStream *)D.99206].D.86631._vptr.Object;
  D.99210 = D.99209 + 18446744073709551592;
  D.99211 = MEM[(long int *)D.99210];
  D.99212 = (sizetype) D.99211;
  iftmp.20 = D.99206 + D.99212;
  goto <D.99213>;
  <D.99208>:
  iftmp.20 = 0B;
  <D.99213>:
  D.99204 = iftmp.20;
  return D.99204;
}


GOutputStream* Gio::OutputStream::gobj_copy() (struct OutputStream * const this)
{
  int (*__vtbl_ptr_type) () * D.99217;
  int (*__vtbl_ptr_type) () * D.99218;
  long int D.99219;
  sizetype D.99220;
  struct ObjectBase * D.99221;
  int (*__vtbl_ptr_type) () * D.99222;
  int (*__vtbl_ptr_type) () * D.99223;
  int (*__vtbl_ptr_type) () D.99224;
  struct GOutputStream * D.99225;

  D.99217 = this->D.86631._vptr.Object;
  D.99218 = D.99217 + 18446744073709551592;
  D.99219 = MEM[(long int *)D.99218];
  D.99220 = (sizetype) D.99219;
  D.99221 = this + D.99220;
  D.99217 = this->D.86631._vptr.Object;
  D.99218 = D.99217 + 18446744073709551592;
  D.99219 = MEM[(long int *)D.99218];
  D.99220 = (sizetype) D.99219;
  D.99221 = this + D.99220;
  D.99222 = D.99221->_vptr.ObjectBase;
  D.99223 = D.99222 + 16;
  D.99224 = *D.99223;
  D.99217 = this->D.86631._vptr.Object;
  D.99218 = D.99217 + 18446744073709551592;
  D.99219 = MEM[(long int *)D.99218];
  D.99220 = (sizetype) D.99219;
  D.99221 = this + D.99220;
  OBJ_TYPE_REF(D.99224;(const struct ObjectBase)D.99221->2) (D.99221);
  D.99225 = Gio::OutputStream::gobj (this);
  return D.99225;
}


Gio::OutputStream::OutputStream(const Glib::ConstructParams&) (struct OutputStream * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.99229;
  const void * * iftmp.21;
  struct ObjectBase * D.99237;
  const void * * iftmp.22;
  struct Object * D.99243;
  int (*__vtbl_ptr_type) () * iftmp.23;
  sizetype iftmp.24;
  int (*__vtbl_ptr_type) () * D.99251;
  int (*__vtbl_ptr_type) () * D.99252;
  long int D.99253;
  struct ObjectBase * D.99255;
  int (*__vtbl_ptr_type) () * iftmp.25;
  const void * * iftmp.26;
  const void * * iftmp.27;

  if (0 != 0) goto <D.99227>; else goto <D.99228>;
  <D.99227>:
  D.99229 = &this->D.86634;
  sigc::trackable::trackable (D.99229);
  goto <D.99230>;
  <D.99228>:
  <D.99230>:
  try
    {
      if (0 != 0) goto <D.99231>; else goto <D.99232>;
      <D.99231>:
      if (0 == 0) goto <D.99234>; else goto <D.99235>;
      <D.99234>:
      iftmp.21 = __vtt_parm + 32;
      goto <D.99236>;
      <D.99235>:
      iftmp.21 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
      <D.99236>:
      D.99237 = &this->D.86633;
      Glib::ObjectBase::ObjectBase (D.99237, iftmp.21);
      goto <D.99238>;
      <D.99232>:
      <D.99238>:
      try
        {
          if (0 == 0) goto <D.99240>; else goto <D.99241>;
          <D.99240>:
          iftmp.22 = __vtt_parm + 8;
          goto <D.99242>;
          <D.99241>:
          iftmp.22 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
          <D.99242>:
          D.99243 = &this->D.86631;
          Glib::Object::Object (D.99243, iftmp.22, construct_params);
          try
            {
              if (0 == 0) goto <D.99245>; else goto <D.99246>;
              <D.99245>:
              iftmp.23 = *__vtt_parm;
              goto <D.99247>;
              <D.99246>:
              iftmp.23 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
              <D.99247>:
              this->D.86631._vptr.Object = iftmp.23;
              if (0 == 0) goto <D.99249>; else goto <D.99250>;
              <D.99249>:
              D.99251 = this->D.86631._vptr.Object;
              D.99252 = D.99251 + 18446744073709551592;
              D.99253 = MEM[(long int *)D.99252];
              iftmp.24 = (sizetype) D.99253;
              goto <D.99254>;
              <D.99250>:
              iftmp.24 = 8;
              <D.99254>:
              D.99255 = this + iftmp.24;
              if (0 == 0) goto <D.99257>; else goto <D.99258>;
              <D.99257>:
              iftmp.25 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99259>;
              <D.99258>:
              iftmp.25 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
              <D.99259>:
              D.99255->_vptr.ObjectBase = iftmp.25;
            }
          catch
            {
              if (0 == 0) goto <D.99261>; else goto <D.99262>;
              <D.99261>:
              iftmp.26 = __vtt_parm + 8;
              goto <D.99263>;
              <D.99262>:
              iftmp.26 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
              <D.99263>:
              D.99243 = &this->D.86631;
              Glib::Object::~Object (D.99243, iftmp.26);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99264>; else goto <D.99265>;
          <D.99264>:
          if (0 == 0) goto <D.99267>; else goto <D.99268>;
          <D.99267>:
          iftmp.27 = __vtt_parm + 32;
          goto <D.99269>;
          <D.99268>:
          iftmp.27 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
          <D.99269>:
          D.99237 = &this->D.86633;
          Glib::ObjectBase::~ObjectBase (D.99237, iftmp.27);
          goto <D.99270>;
          <D.99265>:
          <D.99270>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99271>; else goto <D.99272>;
      <D.99271>:
      D.99229 = &this->D.86634;
      sigc::trackable::~trackable (D.99229);
      goto <D.99273>;
      <D.99272>:
      <D.99273>:
    }
}


Gio::OutputStream::OutputStream(const Glib::ConstructParams&) (struct OutputStream * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.99278;
  const void * * iftmp.28;
  struct ObjectBase * D.99286;
  const void * * iftmp.29;
  struct Object * D.99292;
  int (*__vtbl_ptr_type) () * iftmp.30;
  const void * * D.99296;
  sizetype iftmp.31;
  int (*__vtbl_ptr_type) () * D.99301;
  int (*__vtbl_ptr_type) () * D.99302;
  long int D.99303;
  struct ObjectBase * D.99305;
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * iftmp.33;
  const void * * iftmp.34;

  if (1 != 0) goto <D.99276>; else goto <D.99277>;
  <D.99276>:
  D.99278 = &this->D.86634;
  sigc::trackable::trackable (D.99278);
  goto <D.99279>;
  <D.99277>:
  <D.99279>:
  try
    {
      if (1 != 0) goto <D.99280>; else goto <D.99281>;
      <D.99280>:
      if (1 == 0) goto <D.99283>; else goto <D.99284>;
      <D.99283>:
      iftmp.28 = 32B;
      goto <D.99285>;
      <D.99284>:
      iftmp.28 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
      <D.99285>:
      D.99286 = &this->D.86633;
      Glib::ObjectBase::ObjectBase (D.99286, iftmp.28);
      goto <D.99287>;
      <D.99281>:
      <D.99287>:
      try
        {
          if (1 == 0) goto <D.99289>; else goto <D.99290>;
          <D.99289>:
          iftmp.29 = 8B;
          goto <D.99291>;
          <D.99290>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
          <D.99291>:
          D.99292 = &this->D.86631;
          Glib::Object::Object (D.99292, iftmp.29, construct_params);
          try
            {
              if (1 == 0) goto <D.99294>; else goto <D.99295>;
              <D.99294>:
              D.99296 = 0B;
              iftmp.30 = *D.99296;
              goto <D.99297>;
              <D.99295>:
              iftmp.30 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
              <D.99297>:
              this->D.86631._vptr.Object = iftmp.30;
              if (1 == 0) goto <D.99299>; else goto <D.99300>;
              <D.99299>:
              D.99301 = this->D.86631._vptr.Object;
              D.99302 = D.99301 + 18446744073709551592;
              D.99303 = MEM[(long int *)D.99302];
              iftmp.31 = (sizetype) D.99303;
              goto <D.99304>;
              <D.99300>:
              iftmp.31 = 8;
              <D.99304>:
              D.99305 = this + iftmp.31;
              if (1 == 0) goto <D.99307>; else goto <D.99308>;
              <D.99307>:
              iftmp.32 = MEM[(const void * *)0B + 24B];
              goto <D.99309>;
              <D.99308>:
              iftmp.32 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
              <D.99309>:
              D.99305->_vptr.ObjectBase = iftmp.32;
            }
          catch
            {
              if (1 == 0) goto <D.99311>; else goto <D.99312>;
              <D.99311>:
              iftmp.33 = 8B;
              goto <D.99313>;
              <D.99312>:
              iftmp.33 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
              <D.99313>:
              D.99292 = &this->D.86631;
              Glib::Object::~Object (D.99292, iftmp.33);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99314>; else goto <D.99315>;
          <D.99314>:
          if (1 == 0) goto <D.99317>; else goto <D.99318>;
          <D.99317>:
          iftmp.34 = 32B;
          goto <D.99319>;
          <D.99318>:
          iftmp.34 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
          <D.99319>:
          D.99286 = &this->D.86633;
          Glib::ObjectBase::~ObjectBase (D.99286, iftmp.34);
          goto <D.99320>;
          <D.99315>:
          <D.99320>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99321>; else goto <D.99322>;
      <D.99321>:
      D.99278 = &this->D.86634;
      sigc::trackable::~trackable (D.99278);
      goto <D.99323>;
      <D.99322>:
      <D.99323>:
    }
}


Gio::OutputStream::OutputStream(GOutputStream*) (struct OutputStream * const this, const void * * __vtt_parm, struct GOutputStream * castitem)
{
  struct trackable * D.99328;
  const void * * iftmp.35;
  struct ObjectBase * D.99336;
  const void * * iftmp.36;
  struct Object * D.99342;
  int (*__vtbl_ptr_type) () * iftmp.37;
  sizetype iftmp.38;
  int (*__vtbl_ptr_type) () * D.99350;
  int (*__vtbl_ptr_type) () * D.99351;
  long int D.99352;
  struct ObjectBase * D.99354;
  int (*__vtbl_ptr_type) () * iftmp.39;
  const void * * iftmp.40;
  const void * * iftmp.41;

  if (0 != 0) goto <D.99326>; else goto <D.99327>;
  <D.99326>:
  D.99328 = &this->D.86634;
  sigc::trackable::trackable (D.99328);
  goto <D.99329>;
  <D.99327>:
  <D.99329>:
  try
    {
      if (0 != 0) goto <D.99330>; else goto <D.99331>;
      <D.99330>:
      if (0 == 0) goto <D.99333>; else goto <D.99334>;
      <D.99333>:
      iftmp.35 = __vtt_parm + 32;
      goto <D.99335>;
      <D.99334>:
      iftmp.35 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
      <D.99335>:
      D.99336 = &this->D.86633;
      Glib::ObjectBase::ObjectBase (D.99336, iftmp.35);
      goto <D.99337>;
      <D.99331>:
      <D.99337>:
      try
        {
          if (0 == 0) goto <D.99339>; else goto <D.99340>;
          <D.99339>:
          iftmp.36 = __vtt_parm + 8;
          goto <D.99341>;
          <D.99340>:
          iftmp.36 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
          <D.99341>:
          D.99342 = &this->D.86631;
          Glib::Object::Object (D.99342, iftmp.36, castitem);
          try
            {
              if (0 == 0) goto <D.99344>; else goto <D.99345>;
              <D.99344>:
              iftmp.37 = *__vtt_parm;
              goto <D.99346>;
              <D.99345>:
              iftmp.37 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
              <D.99346>:
              this->D.86631._vptr.Object = iftmp.37;
              if (0 == 0) goto <D.99348>; else goto <D.99349>;
              <D.99348>:
              D.99350 = this->D.86631._vptr.Object;
              D.99351 = D.99350 + 18446744073709551592;
              D.99352 = MEM[(long int *)D.99351];
              iftmp.38 = (sizetype) D.99352;
              goto <D.99353>;
              <D.99349>:
              iftmp.38 = 8;
              <D.99353>:
              D.99354 = this + iftmp.38;
              if (0 == 0) goto <D.99356>; else goto <D.99357>;
              <D.99356>:
              iftmp.39 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.99358>;
              <D.99357>:
              iftmp.39 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
              <D.99358>:
              D.99354->_vptr.ObjectBase = iftmp.39;
            }
          catch
            {
              if (0 == 0) goto <D.99360>; else goto <D.99361>;
              <D.99360>:
              iftmp.40 = __vtt_parm + 8;
              goto <D.99362>;
              <D.99361>:
              iftmp.40 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
              <D.99362>:
              D.99342 = &this->D.86631;
              Glib::Object::~Object (D.99342, iftmp.40);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99363>; else goto <D.99364>;
          <D.99363>:
          if (0 == 0) goto <D.99366>; else goto <D.99367>;
          <D.99366>:
          iftmp.41 = __vtt_parm + 32;
          goto <D.99368>;
          <D.99367>:
          iftmp.41 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
          <D.99368>:
          D.99336 = &this->D.86633;
          Glib::ObjectBase::~ObjectBase (D.99336, iftmp.41);
          goto <D.99369>;
          <D.99364>:
          <D.99369>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99370>; else goto <D.99371>;
      <D.99370>:
      D.99328 = &this->D.86634;
      sigc::trackable::~trackable (D.99328);
      goto <D.99372>;
      <D.99371>:
      <D.99372>:
    }
}


Gio::OutputStream::OutputStream(GOutputStream*) (struct OutputStream * const this, struct GOutputStream * castitem)
{
  struct trackable * D.99377;
  const void * * iftmp.42;
  struct ObjectBase * D.99385;
  const void * * iftmp.43;
  struct Object * D.99391;
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * D.99395;
  sizetype iftmp.45;
  int (*__vtbl_ptr_type) () * D.99400;
  int (*__vtbl_ptr_type) () * D.99401;
  long int D.99402;
  struct ObjectBase * D.99404;
  int (*__vtbl_ptr_type) () * iftmp.46;
  const void * * iftmp.47;
  const void * * iftmp.48;

  if (1 != 0) goto <D.99375>; else goto <D.99376>;
  <D.99375>:
  D.99377 = &this->D.86634;
  sigc::trackable::trackable (D.99377);
  goto <D.99378>;
  <D.99376>:
  <D.99378>:
  try
    {
      if (1 != 0) goto <D.99379>; else goto <D.99380>;
      <D.99379>:
      if (1 == 0) goto <D.99382>; else goto <D.99383>;
      <D.99382>:
      iftmp.42 = 32B;
      goto <D.99384>;
      <D.99383>:
      iftmp.42 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
      <D.99384>:
      D.99385 = &this->D.86633;
      Glib::ObjectBase::ObjectBase (D.99385, iftmp.42);
      goto <D.99386>;
      <D.99380>:
      <D.99386>:
      try
        {
          if (1 == 0) goto <D.99388>; else goto <D.99389>;
          <D.99388>:
          iftmp.43 = 8B;
          goto <D.99390>;
          <D.99389>:
          iftmp.43 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
          <D.99390>:
          D.99391 = &this->D.86631;
          Glib::Object::Object (D.99391, iftmp.43, castitem);
          try
            {
              if (1 == 0) goto <D.99393>; else goto <D.99394>;
              <D.99393>:
              D.99395 = 0B;
              iftmp.44 = *D.99395;
              goto <D.99396>;
              <D.99394>:
              iftmp.44 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
              <D.99396>:
              this->D.86631._vptr.Object = iftmp.44;
              if (1 == 0) goto <D.99398>; else goto <D.99399>;
              <D.99398>:
              D.99400 = this->D.86631._vptr.Object;
              D.99401 = D.99400 + 18446744073709551592;
              D.99402 = MEM[(long int *)D.99401];
              iftmp.45 = (sizetype) D.99402;
              goto <D.99403>;
              <D.99399>:
              iftmp.45 = 8;
              <D.99403>:
              D.99404 = this + iftmp.45;
              if (1 == 0) goto <D.99406>; else goto <D.99407>;
              <D.99406>:
              iftmp.46 = MEM[(const void * *)0B + 24B];
              goto <D.99408>;
              <D.99407>:
              iftmp.46 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
              <D.99408>:
              D.99404->_vptr.ObjectBase = iftmp.46;
            }
          catch
            {
              if (1 == 0) goto <D.99410>; else goto <D.99411>;
              <D.99410>:
              iftmp.47 = 8B;
              goto <D.99412>;
              <D.99411>:
              iftmp.47 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
              <D.99412>:
              D.99391 = &this->D.86631;
              Glib::Object::~Object (D.99391, iftmp.47);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99413>; else goto <D.99414>;
          <D.99413>:
          if (1 == 0) goto <D.99416>; else goto <D.99417>;
          <D.99416>:
          iftmp.48 = 32B;
          goto <D.99418>;
          <D.99417>:
          iftmp.48 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
          <D.99418>:
          D.99385 = &this->D.86633;
          Glib::ObjectBase::~ObjectBase (D.99385, iftmp.48);
          goto <D.99419>;
          <D.99414>:
          <D.99419>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99420>; else goto <D.99421>;
      <D.99420>:
      D.99377 = &this->D.86634;
      sigc::trackable::~trackable (D.99377);
      goto <D.99422>;
      <D.99421>:
      <D.99422>:
    }
}


Gio::OutputStream::~OutputStream() (struct OutputStream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.49;
  sizetype iftmp.50;
  int (*__vtbl_ptr_type) () * D.99432;
  int (*__vtbl_ptr_type) () * D.99433;
  long int D.99434;
  struct ObjectBase * D.99436;
  int (*__vtbl_ptr_type) () * iftmp.51;
  const void * * iftmp.52;
  struct Object * D.99445;
  int D.99446;
  const void * * iftmp.53;
  struct ObjectBase * D.99453;
  struct trackable * D.99457;
  int D.99459;

  {
    if (0 == 0) goto <D.99426>; else goto <D.99427>;
    <D.99426>:
    iftmp.49 = *__vtt_parm;
    goto <D.99428>;
    <D.99427>:
    iftmp.49 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
    <D.99428>:
    this->D.86631._vptr.Object = iftmp.49;
    if (0 == 0) goto <D.99430>; else goto <D.99431>;
    <D.99430>:
    D.99432 = this->D.86631._vptr.Object;
    D.99433 = D.99432 + 18446744073709551592;
    D.99434 = MEM[(long int *)D.99433];
    iftmp.50 = (sizetype) D.99434;
    goto <D.99435>;
    <D.99431>:
    iftmp.50 = 8;
    <D.99435>:
    D.99436 = this + iftmp.50;
    if (0 == 0) goto <D.99438>; else goto <D.99439>;
    <D.99438>:
    iftmp.51 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.99440>;
    <D.99439>:
    iftmp.51 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
    <D.99440>:
    D.99436->_vptr.ObjectBase = iftmp.51;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.99442>; else goto <D.99443>;
                    <D.99442>:
                    iftmp.52 = __vtt_parm + 8;
                    goto <D.99444>;
                    <D.99443>:
                    iftmp.52 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
                    <D.99444>:
                    D.99445 = &this->D.86631;
                    Glib::Object::~Object (D.99445, iftmp.52);
                  }
              }
            finally
              {
                D.99446 = 0;
                if (D.99446 != 0) goto <D.99447>; else goto <D.99448>;
                <D.99447>:
                if (0 == 0) goto <D.99450>; else goto <D.99451>;
                <D.99450>:
                iftmp.53 = __vtt_parm + 32;
                goto <D.99452>;
                <D.99451>:
                iftmp.53 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
                <D.99452>:
                D.99453 = &this->D.86633;
                Glib::ObjectBase::~ObjectBase (D.99453, iftmp.53);
                goto <D.99454>;
                <D.99448>:
                <D.99454>:
              }
          }
        finally
          {
            D.99446 = 0;
            if (D.99446 != 0) goto <D.99455>; else goto <D.99456>;
            <D.99455>:
            D.99457 = &this->D.86634;
            sigc::trackable::~trackable (D.99457);
            goto <D.99458>;
            <D.99456>:
            <D.99458>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97899>:
  D.99459 = 0;
  if (D.99459 != 0) goto <D.99460>; else goto <D.99461>;
  <D.99460>:
  operator delete (this);
  goto <D.99462>;
  <D.99461>:
  <D.99462>:
}


virtual Gio::OutputStream::~OutputStream() (struct OutputStream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.54;
  const void * * D.99478;
  sizetype iftmp.55;
  int (*__vtbl_ptr_type) () * D.99483;
  int (*__vtbl_ptr_type) () * D.99484;
  long int D.99485;
  struct ObjectBase * D.99487;
  int (*__vtbl_ptr_type) () * iftmp.56;
  const void * * iftmp.57;
  struct Object * D.99496;
  int D.99497;
  const void * * iftmp.58;
  struct ObjectBase * D.99504;
  struct trackable * D.99508;
  int D.99510;

  {
    if (2 == 0) goto <D.99476>; else goto <D.99477>;
    <D.99476>:
    D.99478 = 0B;
    iftmp.54 = *D.99478;
    goto <D.99479>;
    <D.99477>:
    iftmp.54 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 32B];
    <D.99479>:
    this->D.86631._vptr.Object = iftmp.54;
    if (2 == 0) goto <D.99481>; else goto <D.99482>;
    <D.99481>:
    D.99483 = this->D.86631._vptr.Object;
    D.99484 = D.99483 + 18446744073709551592;
    D.99485 = MEM[(long int *)D.99484];
    iftmp.55 = (sizetype) D.99485;
    goto <D.99486>;
    <D.99482>:
    iftmp.55 = 8;
    <D.99486>:
    D.99487 = this + iftmp.55;
    if (2 == 0) goto <D.99489>; else goto <D.99490>;
    <D.99489>:
    iftmp.56 = MEM[(const void * *)0B + 24B];
    goto <D.99491>;
    <D.99490>:
    iftmp.56 = &MEM[(void *)&_ZTVN3Gio12OutputStreamE + 112B];
    <D.99491>:
    D.99487->_vptr.ObjectBase = iftmp.56;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.99493>; else goto <D.99494>;
                    <D.99493>:
                    iftmp.57 = 8B;
                    goto <D.99495>;
                    <D.99494>:
                    iftmp.57 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 8B];
                    <D.99495>:
                    D.99496 = &this->D.86631;
                    Glib::Object::~Object (D.99496, iftmp.57);
                  }
              }
            finally
              {
                D.99497 = 2;
                if (D.99497 != 0) goto <D.99498>; else goto <D.99499>;
                <D.99498>:
                if (2 == 0) goto <D.99501>; else goto <D.99502>;
                <D.99501>:
                iftmp.58 = 32B;
                goto <D.99503>;
                <D.99502>:
                iftmp.58 = &MEM[(void *)&_ZTTN3Gio12OutputStreamE + 32B];
                <D.99503>:
                D.99504 = &this->D.86633;
                Glib::ObjectBase::~ObjectBase (D.99504, iftmp.58);
                goto <D.99505>;
                <D.99499>:
                <D.99505>:
              }
          }
        finally
          {
            D.99497 = 2;
            if (D.99497 != 0) goto <D.99506>; else goto <D.99507>;
            <D.99506>:
            D.99508 = &this->D.86634;
            sigc::trackable::~trackable (D.99508);
            goto <D.99509>;
            <D.99507>:
            <D.99509>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.97902>:
  D.99510 = 0;
  if (D.99510 != 0) goto <D.99511>; else goto <D.99512>;
  <D.99511>:
  operator delete (this);
  goto <D.99513>;
  <D.99512>:
  <D.99513>:
}


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


static GType Gio::OutputStream::get_type() ()
{
  GType D.99526;
  const struct Class & D.99527;

  D.99527 = Gio::OutputStream_Class::init (&outputstream_class_);
  D.99526 = Glib::Class::get_type (D.99527);
  return D.99526;
}


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

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


static GType Gio::OutputStream::get_base_type() ()
{
  GType D.99532;

  D.99532 = g_output_stream_get_type ();
  return D.99532;
}


gssize Gio::OutputStream::write(const void*, gsize, const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const void * buffer, gsize count, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99535;
  struct GOutputStream * D.99536;
  struct GError * gerror.59;
  gssize D.99540;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99535 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99536 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write (D.99536, buffer, count, D.99535, &gerror);
      gerror.59 = gerror;
      if (gerror.59 != 0B) goto <D.99538>; else goto <D.99539>;
      <D.99538>:
      gerror.59 = gerror;
      Glib::Error::throw_exception (gerror.59);
      <D.99539>:
      D.99540 = retvalue;
      return D.99540;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::write(const void*, gsize) (struct OutputStream * const this, const void * buffer, gsize count)
{
  struct GOutputStream * D.99546;
  struct GError * gerror.60;
  gssize D.99550;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99546 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write (D.99546, buffer, count, 0B, &gerror);
      gerror.60 = gerror;
      if (gerror.60 != 0B) goto <D.99548>; else goto <D.99549>;
      <D.99548>:
      gerror.60 = gerror;
      Glib::Error::throw_exception (gerror.60);
      <D.99549>:
      D.99550 = retvalue;
      return D.99550;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::write_all(const void*, gsize, gsize&, const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const void * buffer, gsize count, gsize & bytes_written, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99555;
  struct GOutputStream * D.99556;
  int D.99557;
  struct GError * gerror.61;
  bool D.99561;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99555 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99556 = Gio::OutputStream::gobj (this);
      D.99557 = g_output_stream_write_all (D.99556, buffer, count, bytes_written, D.99555, &gerror);
      retvalue = D.99557 != 0;
      gerror.61 = gerror;
      if (gerror.61 != 0B) goto <D.99559>; else goto <D.99560>;
      <D.99559>:
      gerror.61 = gerror;
      Glib::Error::throw_exception (gerror.61);
      <D.99560>:
      D.99561 = retvalue;
      return D.99561;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::write_all(const void*, gsize, gsize&) (struct OutputStream * const this, const void * buffer, gsize count, gsize & bytes_written)
{
  struct GOutputStream * D.99567;
  int D.99568;
  struct GError * gerror.62;
  bool D.99572;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99567 = Gio::OutputStream::gobj (this);
      D.99568 = g_output_stream_write_all (D.99567, buffer, count, bytes_written, 0B, &gerror);
      retvalue = D.99568 != 0;
      gerror.62 = gerror;
      if (gerror.62 != 0B) goto <D.99570>; else goto <D.99571>;
      <D.99570>:
      gerror.62 = gerror;
      Glib::Error::throw_exception (gerror.62);
      <D.99571>:
      D.99572 = retvalue;
      return D.99572;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::write_bytes(const Glib::RefPtr<const Glib::Bytes>&, const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const struct RefPtr & bytes, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99577;
  const struct BaseObjectType * D.99578;
  struct GOutputStream * D.99579;
  struct GError * gerror.63;
  gssize D.99583;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99577 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99578 = Glib::unwrap<Glib::Bytes> (bytes);
      D.99579 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write_bytes (D.99579, D.99578, D.99577, &gerror);
      gerror.63 = gerror;
      if (gerror.63 != 0B) goto <D.99581>; else goto <D.99582>;
      <D.99581>:
      gerror.63 = gerror;
      Glib::Error::throw_exception (gerror.63);
      <D.99582>:
      D.99583 = retvalue;
      return D.99583;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::write_bytes(const Glib::RefPtr<const Glib::Bytes>&) (struct OutputStream * const this, const struct RefPtr & bytes)
{
  const struct BaseObjectType * D.99590;
  struct GOutputStream * D.99591;
  struct GError * gerror.64;
  gssize D.99595;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99590 = Glib::unwrap<Glib::Bytes> (bytes);
      D.99591 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write_bytes (D.99591, D.99590, 0B, &gerror);
      gerror.64 = gerror;
      if (gerror.64 != 0B) goto <D.99593>; else goto <D.99594>;
      <D.99593>:
      gerror.64 = gerror;
      Glib::Error::throw_exception (gerror.64);
      <D.99594>:
      D.99595 = retvalue;
      return D.99595;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::write_bytes_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct OutputStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99601;
  struct GOutputStream * D.99602;
  struct GError * gerror.65;
  gssize D.99606;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99601 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99602 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write_bytes_finish (D.99602, D.99601, &gerror);
      gerror.65 = gerror;
      if (gerror.65 != 0B) goto <D.99604>; else goto <D.99605>;
      <D.99604>:
      gerror.65 = gerror;
      Glib::Error::throw_exception (gerror.65);
      <D.99605>:
      D.99606 = retvalue;
      return D.99606;
    }
  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.99612;
  struct BaseObjectType * iftmp.66;
  bool D.99614;
  struct AsyncResult * D.99617;

  D.99614 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.99614 != 0) goto <D.99615>; else goto <D.99616>;
  <D.99615>:
  D.99617 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.66 = Gio::AsyncResult::gobj (D.99617);
  goto <D.99618>;
  <D.99616>:
  iftmp.66 = 0B;
  <D.99618>:
  D.99612 = iftmp.66;
  return D.99612;
}


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

  D.99621 = this->pCppObject_;
  D.99620 = D.99621 != 0B;
  return D.99620;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.99625;
  int (*__vtbl_ptr_type) () * D.99626;
  int (*__vtbl_ptr_type) () * D.99627;
  long int D.99628;
  sizetype D.99629;
  struct ObjectBase * D.99630;

  D.99626 = this->D.86030._vptr.Interface;
  D.99627 = D.99626 + 18446744073709551592;
  D.99628 = MEM[(long int *)D.99627];
  D.99629 = (sizetype) D.99628;
  D.99630 = this + D.99629;
  D.99625 = D.99630->gobject_;
  return D.99625;
}


bool Gio::OutputStream::flush(const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99632;
  struct GOutputStream * D.99633;
  int D.99634;
  struct GError * gerror.67;
  bool D.99638;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99632 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99633 = Gio::OutputStream::gobj (this);
      D.99634 = g_output_stream_flush (D.99633, D.99632, &gerror);
      retvalue = D.99634 != 0;
      gerror.67 = gerror;
      if (gerror.67 != 0B) goto <D.99636>; else goto <D.99637>;
      <D.99636>:
      gerror.67 = gerror;
      Glib::Error::throw_exception (gerror.67);
      <D.99637>:
      D.99638 = retvalue;
      return D.99638;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::flush() (struct OutputStream * const this)
{
  struct GOutputStream * D.99644;
  int D.99645;
  struct GError * gerror.68;
  bool D.99649;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99644 = Gio::OutputStream::gobj (this);
      D.99645 = g_output_stream_flush (D.99644, 0B, &gerror);
      retvalue = D.99645 != 0;
      gerror.68 = gerror;
      if (gerror.68 != 0B) goto <D.99647>; else goto <D.99648>;
      <D.99647>:
      gerror.68 = gerror;
      Glib::Error::throw_exception (gerror.68);
      <D.99648>:
      D.99649 = retvalue;
      return D.99649;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::close(const Glib::RefPtr<Gio::Cancellable>&) (struct OutputStream * const this, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99654;
  struct GOutputStream * D.99655;
  int D.99656;
  struct GError * gerror.69;
  bool D.99660;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99654 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99655 = Gio::OutputStream::gobj (this);
      D.99656 = g_output_stream_close (D.99655, D.99654, &gerror);
      retvalue = D.99656 != 0;
      gerror.69 = gerror;
      if (gerror.69 != 0B) goto <D.99658>; else goto <D.99659>;
      <D.99658>:
      gerror.69 = gerror;
      Glib::Error::throw_exception (gerror.69);
      <D.99659>:
      D.99660 = retvalue;
      return D.99660;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::close() (struct OutputStream * const this)
{
  struct GOutputStream * D.99666;
  int D.99667;
  struct GError * gerror.70;
  bool D.99671;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99666 = Gio::OutputStream::gobj (this);
      D.99667 = g_output_stream_close (D.99666, 0B, &gerror);
      retvalue = D.99667 != 0;
      gerror.70 = gerror;
      if (gerror.70 != 0B) goto <D.99669>; else goto <D.99670>;
      <D.99669>:
      gerror.70 = gerror;
      Glib::Error::throw_exception (gerror.70);
      <D.99670>:
      D.99671 = retvalue;
      return D.99671;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::write_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct OutputStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99676;
  struct GOutputStream * D.99677;
  struct GError * gerror.71;
  gssize D.99681;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99676 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99677 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_write_finish (D.99677, D.99676, &gerror);
      gerror.71 = gerror;
      if (gerror.71 != 0B) goto <D.99679>; else goto <D.99680>;
      <D.99679>:
      gerror.71 = gerror;
      Glib::Error::throw_exception (gerror.71);
      <D.99680>:
      D.99681 = retvalue;
      return D.99681;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


gssize Gio::OutputStream::splice_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct OutputStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99687;
  struct GOutputStream * D.99688;
  struct GError * gerror.72;
  gssize D.99692;
  struct GError * gerror;
  gssize retvalue;

  try
    {
      gerror = 0B;
      D.99687 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99688 = Gio::OutputStream::gobj (this);
      retvalue = g_output_stream_splice_finish (D.99688, D.99687, &gerror);
      gerror.72 = gerror;
      if (gerror.72 != 0B) goto <D.99690>; else goto <D.99691>;
      <D.99690>:
      gerror.72 = gerror;
      Glib::Error::throw_exception (gerror.72);
      <D.99691>:
      D.99692 = retvalue;
      return D.99692;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::flush_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct OutputStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99698;
  struct GOutputStream * D.99699;
  int D.99700;
  struct GError * gerror.73;
  bool D.99704;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99698 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99699 = Gio::OutputStream::gobj (this);
      D.99700 = g_output_stream_flush_finish (D.99699, D.99698, &gerror);
      retvalue = D.99700 != 0;
      gerror.73 = gerror;
      if (gerror.73 != 0B) goto <D.99702>; else goto <D.99703>;
      <D.99702>:
      gerror.73 = gerror;
      Glib::Error::throw_exception (gerror.73);
      <D.99703>:
      D.99704 = retvalue;
      return D.99704;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::OutputStream::close_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct OutputStream * const this, const struct RefPtr & result)
{
  struct BaseObjectType * D.99710;
  struct GOutputStream * D.99711;
  int D.99712;
  struct GError * gerror.74;
  bool D.99716;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99710 = Glib::unwrap<Gio::AsyncResult> (result);
      D.99711 = Gio::OutputStream::gobj (this);
      D.99712 = g_output_stream_close_finish (D.99711, D.99710, &gerror);
      retvalue = D.99712 != 0;
      gerror.74 = gerror;
      if (gerror.74 != 0B) goto <D.99714>; else goto <D.99715>;
      <D.99714>:
      gerror.74 = gerror;
      Glib::Error::throw_exception (gerror.74);
      <D.99715>:
      D.99716 = retvalue;
      return D.99716;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}