Glib::RefPtr<Gio::DataOutputStream> Glib::wrap(GDataOutputStream*, bool) (struct GDataOutputStream * object, bool take_copy)
{
  struct DataOutputStream * iftmp.0;
  int D.99089;
  struct ObjectBase * D.99090;

  D.99089 = (int) take_copy;
  D.99090 = Glib::wrap_auto (object, D.99089);
  if (D.99090 == 0B) goto <D.99091>; else goto <D.99092>;
  <D.99091>:
  iftmp.0 = 0B;
  goto <D.99093>;
  <D.99092>:
  iftmp.0 = __dynamic_cast (D.99090, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio16DataOutputStreamE, -1);
  <D.99093>:
  Glib::RefPtr<Gio::DataOutputStream>::RefPtr (<retval>, iftmp.0);
  return <retval>;
}


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


const Glib::Class& Gio::DataOutputStream_Class::init() (struct DataOutputStream_Class * const this)
{
  long unsigned int D.99096;
  long unsigned int D.99099;
  struct Class * D.99100;
  const struct Class & D.99102;

  D.99096 = this->D.97747.gtype_;
  if (D.99096 == 0) goto <D.99097>; else goto <D.99098>;
  <D.99097>:
  this->D.97747.class_init_func_ = class_init_function;
  D.99099 = g_data_output_stream_get_type ();
  D.99100 = &this->D.97747;
  Glib::Class::register_derived_type (D.99100, D.99099);
  goto <D.99101>;
  <D.99098>:
  <D.99101>:
  D.99102 = &this->D.97747;
  return D.99102;
}


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

  klass = g_class;
  Gio::BufferedOutputStream_Class::class_init_function (klass, class_data);
}


static Glib::ObjectBase* Gio::DataOutputStream_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.99105;
  struct ObjectBase * iftmp.1;
  void * D.97902;
  void * D.99107;
  int (*__vtbl_ptr_type) () * D.99110;
  int (*__vtbl_ptr_type) () * D.99111;
  long int D.99112;
  sizetype D.99113;

  D.97902 = operator new (48);
  try
    {
      Gio::DataOutputStream::DataOutputStream (D.97902, object);
    }
  catch
    {
      operator delete (D.97902);
    }
  D.99107 = D.97902;
  if (D.99107 != 0B) goto <D.99108>; else goto <D.99109>;
  <D.99108>:
  D.99110 = MEM[(struct DataOutputStream *)D.99107].D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99111 = D.99110 + 18446744073709551592;
  D.99112 = MEM[(long int *)D.99111];
  D.99113 = (sizetype) D.99112;
  iftmp.1 = D.99107 + D.99113;
  goto <D.99114>;
  <D.99109>:
  iftmp.1 = 0B;
  <D.99114>:
  D.99105 = iftmp.1;
  return D.99105;
}


GDataOutputStream* Gio::DataOutputStream::gobj_copy() (struct DataOutputStream * const this)
{
  int (*__vtbl_ptr_type) () * D.99119;
  int (*__vtbl_ptr_type) () * D.99120;
  long int D.99121;
  sizetype D.99122;
  struct ObjectBase * D.99123;
  int (*__vtbl_ptr_type) () * D.99124;
  int (*__vtbl_ptr_type) () * D.99125;
  int (*__vtbl_ptr_type) () D.99126;
  struct GDataOutputStream * D.99127;

  D.99119 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99120 = D.99119 + 18446744073709551592;
  D.99121 = MEM[(long int *)D.99120];
  D.99122 = (sizetype) D.99121;
  D.99123 = this + D.99122;
  D.99119 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99120 = D.99119 + 18446744073709551592;
  D.99121 = MEM[(long int *)D.99120];
  D.99122 = (sizetype) D.99121;
  D.99123 = this + D.99122;
  D.99124 = D.99123->_vptr.ObjectBase;
  D.99125 = D.99124 + 16;
  D.99126 = *D.99125;
  D.99119 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99120 = D.99119 + 18446744073709551592;
  D.99121 = MEM[(long int *)D.99120];
  D.99122 = (sizetype) D.99121;
  D.99123 = this + D.99122;
  OBJ_TYPE_REF(D.99126;(const struct ObjectBase)D.99123->2) (D.99123);
  D.99127 = Gio::DataOutputStream::gobj (this);
  return D.99127;
}


GDataOutputStream* Gio::DataOutputStream::gobj() (struct DataOutputStream * const this)
{
  struct GDataOutputStream * D.99129;
  int (*__vtbl_ptr_type) () * D.99130;
  int (*__vtbl_ptr_type) () * D.99131;
  long int D.99132;
  sizetype D.99133;
  struct ObjectBase * D.99134;

  D.99130 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99131 = D.99130 + 18446744073709551592;
  D.99132 = MEM[(long int *)D.99131];
  D.99133 = (sizetype) D.99132;
  D.99134 = this + D.99133;
  D.99129 = D.99134->gobject_;
  return D.99129;
}


Gio::DataOutputStream::DataOutputStream(const Glib::ConstructParams&) (struct DataOutputStream * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.99138;
  const void * * iftmp.2;
  struct ObjectBase * D.99146;
  const void * * iftmp.3;
  struct BufferedOutputStream * D.99152;
  int (*__vtbl_ptr_type) () * iftmp.4;
  sizetype iftmp.5;
  int (*__vtbl_ptr_type) () * D.99160;
  int (*__vtbl_ptr_type) () * D.99161;
  long int D.99162;
  struct ObjectBase * D.99164;
  int (*__vtbl_ptr_type) () * iftmp.6;
  const void * * iftmp.7;
  const void * * iftmp.8;

  if (0 != 0) goto <D.99136>; else goto <D.99137>;
  <D.99136>:
  D.99138 = &this->D.97660;
  sigc::trackable::trackable (D.99138);
  goto <D.99139>;
  <D.99137>:
  <D.99139>:
  try
    {
      if (0 != 0) goto <D.99140>; else goto <D.99141>;
      <D.99140>:
      if (0 == 0) goto <D.99143>; else goto <D.99144>;
      <D.99143>:
      iftmp.2 = __vtt_parm + 80;
      goto <D.99145>;
      <D.99144>:
      iftmp.2 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99145>:
      D.99146 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99146, iftmp.2);
      goto <D.99147>;
      <D.99141>:
      <D.99147>:
      try
        {
          if (0 == 0) goto <D.99149>; else goto <D.99150>;
          <D.99149>:
          iftmp.3 = __vtt_parm + 8;
          goto <D.99151>;
          <D.99150>:
          iftmp.3 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
          <D.99151>:
          D.99152 = &this->D.97657;
          Gio::BufferedOutputStream::BufferedOutputStream (D.99152, iftmp.3, construct_params);
          try
            {
              if (0 == 0) goto <D.99154>; else goto <D.99155>;
              <D.99154>:
              iftmp.4 = *__vtt_parm;
              goto <D.99156>;
              <D.99155>:
              iftmp.4 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99156>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.4;
              if (0 == 0) goto <D.99158>; else goto <D.99159>;
              <D.99158>:
              D.99160 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99161 = D.99160 + 18446744073709551592;
              D.99162 = MEM[(long int *)D.99161];
              iftmp.5 = (sizetype) D.99162;
              goto <D.99163>;
              <D.99159>:
              iftmp.5 = 8;
              <D.99163>:
              D.99164 = this + iftmp.5;
              if (0 == 0) goto <D.99166>; else goto <D.99167>;
              <D.99166>:
              iftmp.6 = MEM[(const void * *)__vtt_parm + 72B];
              goto <D.99168>;
              <D.99167>:
              iftmp.6 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99168>:
              D.99164->_vptr.ObjectBase = iftmp.6;
            }
          catch
            {
              if (0 == 0) goto <D.99170>; else goto <D.99171>;
              <D.99170>:
              iftmp.7 = __vtt_parm + 8;
              goto <D.99172>;
              <D.99171>:
              iftmp.7 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99172>:
              D.99152 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99152, iftmp.7);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99173>; else goto <D.99174>;
          <D.99173>:
          if (0 == 0) goto <D.99176>; else goto <D.99177>;
          <D.99176>:
          iftmp.8 = __vtt_parm + 80;
          goto <D.99178>;
          <D.99177>:
          iftmp.8 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99178>:
          D.99146 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99146, iftmp.8);
          goto <D.99179>;
          <D.99174>:
          <D.99179>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99180>; else goto <D.99181>;
      <D.99180>:
      D.99138 = &this->D.97660;
      sigc::trackable::~trackable (D.99138);
      goto <D.99182>;
      <D.99181>:
      <D.99182>:
    }
}


Gio::DataOutputStream::DataOutputStream(const Glib::ConstructParams&) (struct DataOutputStream * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.99187;
  const void * * iftmp.9;
  struct ObjectBase * D.99195;
  const void * * iftmp.10;
  struct BufferedOutputStream * D.99201;
  int (*__vtbl_ptr_type) () * iftmp.11;
  const void * * D.99205;
  sizetype iftmp.12;
  int (*__vtbl_ptr_type) () * D.99210;
  int (*__vtbl_ptr_type) () * D.99211;
  long int D.99212;
  struct ObjectBase * D.99214;
  int (*__vtbl_ptr_type) () * iftmp.13;
  const void * * iftmp.14;
  const void * * iftmp.15;

  if (1 != 0) goto <D.99185>; else goto <D.99186>;
  <D.99185>:
  D.99187 = &this->D.97660;
  sigc::trackable::trackable (D.99187);
  goto <D.99188>;
  <D.99186>:
  <D.99188>:
  try
    {
      if (1 != 0) goto <D.99189>; else goto <D.99190>;
      <D.99189>:
      if (1 == 0) goto <D.99192>; else goto <D.99193>;
      <D.99192>:
      iftmp.9 = 80B;
      goto <D.99194>;
      <D.99193>:
      iftmp.9 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99194>:
      D.99195 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99195, iftmp.9);
      goto <D.99196>;
      <D.99190>:
      <D.99196>:
      try
        {
          if (1 == 0) goto <D.99198>; else goto <D.99199>;
          <D.99198>:
          iftmp.10 = 8B;
          goto <D.99200>;
          <D.99199>:
          iftmp.10 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
          <D.99200>:
          D.99201 = &this->D.97657;
          Gio::BufferedOutputStream::BufferedOutputStream (D.99201, iftmp.10, construct_params);
          try
            {
              if (1 == 0) goto <D.99203>; else goto <D.99204>;
              <D.99203>:
              D.99205 = 0B;
              iftmp.11 = *D.99205;
              goto <D.99206>;
              <D.99204>:
              iftmp.11 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99206>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.11;
              if (1 == 0) goto <D.99208>; else goto <D.99209>;
              <D.99208>:
              D.99210 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99211 = D.99210 + 18446744073709551592;
              D.99212 = MEM[(long int *)D.99211];
              iftmp.12 = (sizetype) D.99212;
              goto <D.99213>;
              <D.99209>:
              iftmp.12 = 8;
              <D.99213>:
              D.99214 = this + iftmp.12;
              if (1 == 0) goto <D.99216>; else goto <D.99217>;
              <D.99216>:
              iftmp.13 = MEM[(const void * *)0B + 72B];
              goto <D.99218>;
              <D.99217>:
              iftmp.13 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99218>:
              D.99214->_vptr.ObjectBase = iftmp.13;
            }
          catch
            {
              if (1 == 0) goto <D.99220>; else goto <D.99221>;
              <D.99220>:
              iftmp.14 = 8B;
              goto <D.99222>;
              <D.99221>:
              iftmp.14 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99222>:
              D.99201 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99201, iftmp.14);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99223>; else goto <D.99224>;
          <D.99223>:
          if (1 == 0) goto <D.99226>; else goto <D.99227>;
          <D.99226>:
          iftmp.15 = 80B;
          goto <D.99228>;
          <D.99227>:
          iftmp.15 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99228>:
          D.99195 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99195, iftmp.15);
          goto <D.99229>;
          <D.99224>:
          <D.99229>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99230>; else goto <D.99231>;
      <D.99230>:
      D.99187 = &this->D.97660;
      sigc::trackable::~trackable (D.99187);
      goto <D.99232>;
      <D.99231>:
      <D.99232>:
    }
}


Gio::DataOutputStream::DataOutputStream(GDataOutputStream*) (struct DataOutputStream * const this, const void * * __vtt_parm, struct GDataOutputStream * castitem)
{
  struct trackable * D.99237;
  const void * * iftmp.16;
  struct ObjectBase * D.99245;
  const void * * iftmp.17;
  struct BufferedOutputStream * D.99251;
  int (*__vtbl_ptr_type) () * iftmp.18;
  sizetype iftmp.19;
  int (*__vtbl_ptr_type) () * D.99259;
  int (*__vtbl_ptr_type) () * D.99260;
  long int D.99261;
  struct ObjectBase * D.99263;
  int (*__vtbl_ptr_type) () * iftmp.20;
  const void * * iftmp.21;
  const void * * iftmp.22;

  if (0 != 0) goto <D.99235>; else goto <D.99236>;
  <D.99235>:
  D.99237 = &this->D.97660;
  sigc::trackable::trackable (D.99237);
  goto <D.99238>;
  <D.99236>:
  <D.99238>:
  try
    {
      if (0 != 0) goto <D.99239>; else goto <D.99240>;
      <D.99239>:
      if (0 == 0) goto <D.99242>; else goto <D.99243>;
      <D.99242>:
      iftmp.16 = __vtt_parm + 80;
      goto <D.99244>;
      <D.99243>:
      iftmp.16 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99244>:
      D.99245 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99245, iftmp.16);
      goto <D.99246>;
      <D.99240>:
      <D.99246>:
      try
        {
          if (0 == 0) goto <D.99248>; else goto <D.99249>;
          <D.99248>:
          iftmp.17 = __vtt_parm + 8;
          goto <D.99250>;
          <D.99249>:
          iftmp.17 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
          <D.99250>:
          D.99251 = &this->D.97657;
          Gio::BufferedOutputStream::BufferedOutputStream (D.99251, iftmp.17, castitem);
          try
            {
              if (0 == 0) goto <D.99253>; else goto <D.99254>;
              <D.99253>:
              iftmp.18 = *__vtt_parm;
              goto <D.99255>;
              <D.99254>:
              iftmp.18 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99255>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.18;
              if (0 == 0) goto <D.99257>; else goto <D.99258>;
              <D.99257>:
              D.99259 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99260 = D.99259 + 18446744073709551592;
              D.99261 = MEM[(long int *)D.99260];
              iftmp.19 = (sizetype) D.99261;
              goto <D.99262>;
              <D.99258>:
              iftmp.19 = 8;
              <D.99262>:
              D.99263 = this + iftmp.19;
              if (0 == 0) goto <D.99265>; else goto <D.99266>;
              <D.99265>:
              iftmp.20 = MEM[(const void * *)__vtt_parm + 72B];
              goto <D.99267>;
              <D.99266>:
              iftmp.20 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99267>:
              D.99263->_vptr.ObjectBase = iftmp.20;
            }
          catch
            {
              if (0 == 0) goto <D.99269>; else goto <D.99270>;
              <D.99269>:
              iftmp.21 = __vtt_parm + 8;
              goto <D.99271>;
              <D.99270>:
              iftmp.21 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99271>:
              D.99251 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99251, iftmp.21);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99272>; else goto <D.99273>;
          <D.99272>:
          if (0 == 0) goto <D.99275>; else goto <D.99276>;
          <D.99275>:
          iftmp.22 = __vtt_parm + 80;
          goto <D.99277>;
          <D.99276>:
          iftmp.22 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99277>:
          D.99245 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99245, iftmp.22);
          goto <D.99278>;
          <D.99273>:
          <D.99278>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99279>; else goto <D.99280>;
      <D.99279>:
      D.99237 = &this->D.97660;
      sigc::trackable::~trackable (D.99237);
      goto <D.99281>;
      <D.99280>:
      <D.99281>:
    }
}


Gio::DataOutputStream::DataOutputStream(GDataOutputStream*) (struct DataOutputStream * const this, struct GDataOutputStream * castitem)
{
  struct trackable * D.99286;
  const void * * iftmp.23;
  struct ObjectBase * D.99294;
  const void * * iftmp.24;
  struct BufferedOutputStream * D.99300;
  int (*__vtbl_ptr_type) () * iftmp.25;
  const void * * D.99304;
  sizetype iftmp.26;
  int (*__vtbl_ptr_type) () * D.99309;
  int (*__vtbl_ptr_type) () * D.99310;
  long int D.99311;
  struct ObjectBase * D.99313;
  int (*__vtbl_ptr_type) () * iftmp.27;
  const void * * iftmp.28;
  const void * * iftmp.29;

  if (1 != 0) goto <D.99284>; else goto <D.99285>;
  <D.99284>:
  D.99286 = &this->D.97660;
  sigc::trackable::trackable (D.99286);
  goto <D.99287>;
  <D.99285>:
  <D.99287>:
  try
    {
      if (1 != 0) goto <D.99288>; else goto <D.99289>;
      <D.99288>:
      if (1 == 0) goto <D.99291>; else goto <D.99292>;
      <D.99291>:
      iftmp.23 = 80B;
      goto <D.99293>;
      <D.99292>:
      iftmp.23 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99293>:
      D.99294 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99294, iftmp.23);
      goto <D.99295>;
      <D.99289>:
      <D.99295>:
      try
        {
          if (1 == 0) goto <D.99297>; else goto <D.99298>;
          <D.99297>:
          iftmp.24 = 8B;
          goto <D.99299>;
          <D.99298>:
          iftmp.24 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
          <D.99299>:
          D.99300 = &this->D.97657;
          Gio::BufferedOutputStream::BufferedOutputStream (D.99300, iftmp.24, castitem);
          try
            {
              if (1 == 0) goto <D.99302>; else goto <D.99303>;
              <D.99302>:
              D.99304 = 0B;
              iftmp.25 = *D.99304;
              goto <D.99305>;
              <D.99303>:
              iftmp.25 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99305>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.25;
              if (1 == 0) goto <D.99307>; else goto <D.99308>;
              <D.99307>:
              D.99309 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99310 = D.99309 + 18446744073709551592;
              D.99311 = MEM[(long int *)D.99310];
              iftmp.26 = (sizetype) D.99311;
              goto <D.99312>;
              <D.99308>:
              iftmp.26 = 8;
              <D.99312>:
              D.99313 = this + iftmp.26;
              if (1 == 0) goto <D.99315>; else goto <D.99316>;
              <D.99315>:
              iftmp.27 = MEM[(const void * *)0B + 72B];
              goto <D.99317>;
              <D.99316>:
              iftmp.27 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99317>:
              D.99313->_vptr.ObjectBase = iftmp.27;
            }
          catch
            {
              if (1 == 0) goto <D.99319>; else goto <D.99320>;
              <D.99319>:
              iftmp.28 = 8B;
              goto <D.99321>;
              <D.99320>:
              iftmp.28 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99321>:
              D.99300 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99300, iftmp.28);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99322>; else goto <D.99323>;
          <D.99322>:
          if (1 == 0) goto <D.99325>; else goto <D.99326>;
          <D.99325>:
          iftmp.29 = 80B;
          goto <D.99327>;
          <D.99326>:
          iftmp.29 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99327>:
          D.99294 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99294, iftmp.29);
          goto <D.99328>;
          <D.99323>:
          <D.99328>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99329>; else goto <D.99330>;
      <D.99329>:
      D.99286 = &this->D.97660;
      sigc::trackable::~trackable (D.99286);
      goto <D.99331>;
      <D.99330>:
      <D.99331>:
    }
}


Gio::DataOutputStream::~DataOutputStream() (struct DataOutputStream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.30;
  sizetype iftmp.31;
  int (*__vtbl_ptr_type) () * D.99341;
  int (*__vtbl_ptr_type) () * D.99342;
  long int D.99343;
  struct ObjectBase * D.99345;
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * iftmp.33;
  struct BufferedOutputStream * D.99354;
  int D.99355;
  const void * * iftmp.34;
  struct ObjectBase * D.99362;
  struct trackable * D.99366;
  int D.99368;

  {
    if (0 == 0) goto <D.99335>; else goto <D.99336>;
    <D.99335>:
    iftmp.30 = *__vtt_parm;
    goto <D.99337>;
    <D.99336>:
    iftmp.30 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
    <D.99337>:
    this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.30;
    if (0 == 0) goto <D.99339>; else goto <D.99340>;
    <D.99339>:
    D.99341 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
    D.99342 = D.99341 + 18446744073709551592;
    D.99343 = MEM[(long int *)D.99342];
    iftmp.31 = (sizetype) D.99343;
    goto <D.99344>;
    <D.99340>:
    iftmp.31 = 8;
    <D.99344>:
    D.99345 = this + iftmp.31;
    if (0 == 0) goto <D.99347>; else goto <D.99348>;
    <D.99347>:
    iftmp.32 = MEM[(const void * *)__vtt_parm + 72B];
    goto <D.99349>;
    <D.99348>:
    iftmp.32 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
    <D.99349>:
    D.99345->_vptr.ObjectBase = iftmp.32;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.99351>; else goto <D.99352>;
                    <D.99351>:
                    iftmp.33 = __vtt_parm + 8;
                    goto <D.99353>;
                    <D.99352>:
                    iftmp.33 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
                    <D.99353>:
                    D.99354 = &this->D.97657;
                    Gio::BufferedOutputStream::~BufferedOutputStream (D.99354, iftmp.33);
                  }
              }
            finally
              {
                D.99355 = 0;
                if (D.99355 != 0) goto <D.99356>; else goto <D.99357>;
                <D.99356>:
                if (0 == 0) goto <D.99359>; else goto <D.99360>;
                <D.99359>:
                iftmp.34 = __vtt_parm + 80;
                goto <D.99361>;
                <D.99360>:
                iftmp.34 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
                <D.99361>:
                D.99362 = &this->D.97659;
                Glib::ObjectBase::~ObjectBase (D.99362, iftmp.34);
                goto <D.99363>;
                <D.99357>:
                <D.99363>:
              }
          }
        finally
          {
            D.99355 = 0;
            if (D.99355 != 0) goto <D.99364>; else goto <D.99365>;
            <D.99364>:
            D.99366 = &this->D.97660;
            sigc::trackable::~trackable (D.99366);
            goto <D.99367>;
            <D.99365>:
            <D.99367>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98054>:
  D.99368 = 0;
  if (D.99368 != 0) goto <D.99369>; else goto <D.99370>;
  <D.99369>:
  operator delete (this);
  goto <D.99371>;
  <D.99370>:
  <D.99371>:
}


virtual Gio::DataOutputStream::~DataOutputStream() (struct DataOutputStream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * D.99387;
  sizetype iftmp.36;
  int (*__vtbl_ptr_type) () * D.99392;
  int (*__vtbl_ptr_type) () * D.99393;
  long int D.99394;
  struct ObjectBase * D.99396;
  int (*__vtbl_ptr_type) () * iftmp.37;
  const void * * iftmp.38;
  struct BufferedOutputStream * D.99405;
  int D.99406;
  const void * * iftmp.39;
  struct ObjectBase * D.99413;
  struct trackable * D.99417;
  int D.99419;

  {
    if (2 == 0) goto <D.99385>; else goto <D.99386>;
    <D.99385>:
    D.99387 = 0B;
    iftmp.35 = *D.99387;
    goto <D.99388>;
    <D.99386>:
    iftmp.35 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
    <D.99388>:
    this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.35;
    if (2 == 0) goto <D.99390>; else goto <D.99391>;
    <D.99390>:
    D.99392 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
    D.99393 = D.99392 + 18446744073709551592;
    D.99394 = MEM[(long int *)D.99393];
    iftmp.36 = (sizetype) D.99394;
    goto <D.99395>;
    <D.99391>:
    iftmp.36 = 8;
    <D.99395>:
    D.99396 = this + iftmp.36;
    if (2 == 0) goto <D.99398>; else goto <D.99399>;
    <D.99398>:
    iftmp.37 = MEM[(const void * *)0B + 72B];
    goto <D.99400>;
    <D.99399>:
    iftmp.37 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
    <D.99400>:
    D.99396->_vptr.ObjectBase = iftmp.37;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.99402>; else goto <D.99403>;
                    <D.99402>:
                    iftmp.38 = 8B;
                    goto <D.99404>;
                    <D.99403>:
                    iftmp.38 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
                    <D.99404>:
                    D.99405 = &this->D.97657;
                    Gio::BufferedOutputStream::~BufferedOutputStream (D.99405, iftmp.38);
                  }
              }
            finally
              {
                D.99406 = 2;
                if (D.99406 != 0) goto <D.99407>; else goto <D.99408>;
                <D.99407>:
                if (2 == 0) goto <D.99410>; else goto <D.99411>;
                <D.99410>:
                iftmp.39 = 80B;
                goto <D.99412>;
                <D.99411>:
                iftmp.39 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
                <D.99412>:
                D.99413 = &this->D.97659;
                Glib::ObjectBase::~ObjectBase (D.99413, iftmp.39);
                goto <D.99414>;
                <D.99408>:
                <D.99414>:
              }
          }
        finally
          {
            D.99406 = 2;
            if (D.99406 != 0) goto <D.99415>; else goto <D.99416>;
            <D.99415>:
            D.99417 = &this->D.97660;
            sigc::trackable::~trackable (D.99417);
            goto <D.99418>;
            <D.99416>:
            <D.99418>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98057>:
  D.99419 = 0;
  if (D.99419 != 0) goto <D.99420>; else goto <D.99421>;
  <D.99420>:
  operator delete (this);
  goto <D.99422>;
  <D.99421>:
  <D.99422>:
}


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


static GType Gio::DataOutputStream::get_type() ()
{
  GType D.99435;
  const struct Class & D.99436;

  D.99436 = Gio::DataOutputStream_Class::init (&dataoutputstream_class_);
  D.99435 = Glib::Class::get_type (D.99436);
  return D.99435;
}


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

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


static GType Gio::DataOutputStream::get_base_type() ()
{
  GType D.99441;

  D.99441 = g_data_output_stream_get_type ();
  return D.99441;
}


Gio::DataOutputStream::DataOutputStream(const Glib::RefPtr<Gio::OutputStream>&) (struct DataOutputStream * const this, const void * * __vtt_parm, const struct RefPtr & base_stream)
{
  struct trackable * D.99446;
  const void * * iftmp.40;
  struct ObjectBase * D.99454;
  struct ConstructParams D.98083;
  struct BaseObjectType * D.99456;
  const struct Class & D.99457;
  const void * * iftmp.41;
  struct BufferedOutputStream * D.99462;
  int (*__vtbl_ptr_type) () * iftmp.42;
  sizetype iftmp.43;
  int (*__vtbl_ptr_type) () * D.99470;
  int (*__vtbl_ptr_type) () * D.99471;
  long int D.99472;
  struct ObjectBase * D.99474;
  int (*__vtbl_ptr_type) () * iftmp.44;
  const void * * iftmp.45;
  const void * * iftmp.46;

  if (0 != 0) goto <D.99444>; else goto <D.99445>;
  <D.99444>:
  D.99446 = &this->D.97660;
  sigc::trackable::trackable (D.99446);
  goto <D.99447>;
  <D.99445>:
  <D.99447>:
  try
    {
      if (0 != 0) goto <D.99448>; else goto <D.99449>;
      <D.99448>:
      if (0 == 0) goto <D.99451>; else goto <D.99452>;
      <D.99451>:
      iftmp.40 = __vtt_parm + 80;
      goto <D.99453>;
      <D.99452>:
      iftmp.40 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99453>:
      D.99454 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99454, iftmp.40, 0B);
      goto <D.99455>;
      <D.99449>:
      <D.99455>:
      try
        {
          D.99456 = Glib::unwrap<Gio::OutputStream> (base_stream);
          D.99457 = Gio::DataOutputStream_Class::init (&dataoutputstream_class_);
          Glib::ConstructParams::ConstructParams (&D.98083, D.99457, "base_stream", D.99456, 0B);
          try
            {
              if (0 == 0) goto <D.99459>; else goto <D.99460>;
              <D.99459>:
              iftmp.41 = __vtt_parm + 8;
              goto <D.99461>;
              <D.99460>:
              iftmp.41 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99461>:
              D.99462 = &this->D.97657;
              Gio::BufferedOutputStream::BufferedOutputStream (D.99462, iftmp.41, &D.98083);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98083);
              D.98083 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.99464>; else goto <D.99465>;
              <D.99464>:
              iftmp.42 = *__vtt_parm;
              goto <D.99466>;
              <D.99465>:
              iftmp.42 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99466>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.42;
              if (0 == 0) goto <D.99468>; else goto <D.99469>;
              <D.99468>:
              D.99470 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99471 = D.99470 + 18446744073709551592;
              D.99472 = MEM[(long int *)D.99471];
              iftmp.43 = (sizetype) D.99472;
              goto <D.99473>;
              <D.99469>:
              iftmp.43 = 8;
              <D.99473>:
              D.99474 = this + iftmp.43;
              if (0 == 0) goto <D.99476>; else goto <D.99477>;
              <D.99476>:
              iftmp.44 = MEM[(const void * *)__vtt_parm + 72B];
              goto <D.99478>;
              <D.99477>:
              iftmp.44 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99478>:
              D.99474->_vptr.ObjectBase = iftmp.44;
            }
          catch
            {
              if (0 == 0) goto <D.99480>; else goto <D.99481>;
              <D.99480>:
              iftmp.45 = __vtt_parm + 8;
              goto <D.99482>;
              <D.99481>:
              iftmp.45 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99482>:
              D.99462 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99462, iftmp.45);
            }
        }
      catch
        {
          if (0 != 0) goto <D.99483>; else goto <D.99484>;
          <D.99483>:
          if (0 == 0) goto <D.99486>; else goto <D.99487>;
          <D.99486>:
          iftmp.46 = __vtt_parm + 80;
          goto <D.99488>;
          <D.99487>:
          iftmp.46 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99488>:
          D.99454 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99454, iftmp.46);
          goto <D.99489>;
          <D.99484>:
          <D.99489>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.99490>; else goto <D.99491>;
      <D.99490>:
      D.99446 = &this->D.97660;
      sigc::trackable::~trackable (D.99446);
      goto <D.99492>;
      <D.99491>:
      <D.99492>:
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::OutputStream; typename T::BaseObjectType = _GOutputStream] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.99498;
  struct BaseObjectType * iftmp.47;
  bool D.99500;
  struct OutputStream * D.99503;

  D.99500 = Glib::RefPtr<Gio::OutputStream>::operator bool (ptr);
  if (D.99500 != 0) goto <D.99501>; else goto <D.99502>;
  <D.99501>:
  D.99503 = Glib::RefPtr<Gio::OutputStream>::operator-> (ptr);
  iftmp.47 = Gio::OutputStream::gobj (D.99503);
  goto <D.99504>;
  <D.99502>:
  iftmp.47 = 0B;
  <D.99504>:
  D.99498 = iftmp.47;
  return D.99498;
}


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

  D.99507 = this->pCppObject_;
  D.99506 = D.99507 != 0B;
  return D.99506;
}


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

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


GOutputStream* Gio::OutputStream::gobj() (struct OutputStream * const this)
{
  struct GOutputStream * D.99511;
  int (*__vtbl_ptr_type) () * D.99512;
  int (*__vtbl_ptr_type) () * D.99513;
  long int D.99514;
  sizetype D.99515;
  struct ObjectBase * D.99516;

  D.99512 = this->D.86631._vptr.Object;
  D.99513 = D.99512 + 18446744073709551592;
  D.99514 = MEM[(long int *)D.99513];
  D.99515 = (sizetype) D.99514;
  D.99516 = this + D.99515;
  D.99511 = D.99516->gobject_;
  return D.99511;
}


Gio::DataOutputStream::DataOutputStream(const Glib::RefPtr<Gio::OutputStream>&) (struct DataOutputStream * const this, const struct RefPtr & base_stream)
{
  struct trackable * D.99520;
  const void * * iftmp.48;
  struct ObjectBase * D.99528;
  struct ConstructParams D.98085;
  struct BaseObjectType * D.99530;
  const struct Class & D.99531;
  const void * * iftmp.49;
  struct BufferedOutputStream * D.99536;
  int (*__vtbl_ptr_type) () * iftmp.50;
  const void * * D.99540;
  sizetype iftmp.51;
  int (*__vtbl_ptr_type) () * D.99545;
  int (*__vtbl_ptr_type) () * D.99546;
  long int D.99547;
  struct ObjectBase * D.99549;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * iftmp.53;
  const void * * iftmp.54;

  if (1 != 0) goto <D.99518>; else goto <D.99519>;
  <D.99518>:
  D.99520 = &this->D.97660;
  sigc::trackable::trackable (D.99520);
  goto <D.99521>;
  <D.99519>:
  <D.99521>:
  try
    {
      if (1 != 0) goto <D.99522>; else goto <D.99523>;
      <D.99522>:
      if (1 == 0) goto <D.99525>; else goto <D.99526>;
      <D.99525>:
      iftmp.48 = 80B;
      goto <D.99527>;
      <D.99526>:
      iftmp.48 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
      <D.99527>:
      D.99528 = &this->D.97659;
      Glib::ObjectBase::ObjectBase (D.99528, iftmp.48, 0B);
      goto <D.99529>;
      <D.99523>:
      <D.99529>:
      try
        {
          D.99530 = Glib::unwrap<Gio::OutputStream> (base_stream);
          D.99531 = Gio::DataOutputStream_Class::init (&dataoutputstream_class_);
          Glib::ConstructParams::ConstructParams (&D.98085, D.99531, "base_stream", D.99530, 0B);
          try
            {
              if (1 == 0) goto <D.99533>; else goto <D.99534>;
              <D.99533>:
              iftmp.49 = 8B;
              goto <D.99535>;
              <D.99534>:
              iftmp.49 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99535>:
              D.99536 = &this->D.97657;
              Gio::BufferedOutputStream::BufferedOutputStream (D.99536, iftmp.49, &D.98085);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98085);
              D.98085 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.99538>; else goto <D.99539>;
              <D.99538>:
              D.99540 = 0B;
              iftmp.50 = *D.99540;
              goto <D.99541>;
              <D.99539>:
              iftmp.50 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 32B];
              <D.99541>:
              this->D.97657.D.86910.D.86748.D.86631._vptr.Object = iftmp.50;
              if (1 == 0) goto <D.99543>; else goto <D.99544>;
              <D.99543>:
              D.99545 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
              D.99546 = D.99545 + 18446744073709551592;
              D.99547 = MEM[(long int *)D.99546];
              iftmp.51 = (sizetype) D.99547;
              goto <D.99548>;
              <D.99544>:
              iftmp.51 = 8;
              <D.99548>:
              D.99549 = this + iftmp.51;
              if (1 == 0) goto <D.99551>; else goto <D.99552>;
              <D.99551>:
              iftmp.52 = MEM[(const void * *)0B + 72B];
              goto <D.99553>;
              <D.99552>:
              iftmp.52 = &MEM[(void *)&_ZTVN3Gio16DataOutputStreamE + 112B];
              <D.99553>:
              D.99549->_vptr.ObjectBase = iftmp.52;
            }
          catch
            {
              if (1 == 0) goto <D.99555>; else goto <D.99556>;
              <D.99555>:
              iftmp.53 = 8B;
              goto <D.99557>;
              <D.99556>:
              iftmp.53 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 8B];
              <D.99557>:
              D.99536 = &this->D.97657;
              Gio::BufferedOutputStream::~BufferedOutputStream (D.99536, iftmp.53);
            }
        }
      catch
        {
          if (1 != 0) goto <D.99558>; else goto <D.99559>;
          <D.99558>:
          if (1 == 0) goto <D.99561>; else goto <D.99562>;
          <D.99561>:
          iftmp.54 = 80B;
          goto <D.99563>;
          <D.99562>:
          iftmp.54 = &MEM[(void *)&_ZTTN3Gio16DataOutputStreamE + 80B];
          <D.99563>:
          D.99528 = &this->D.97659;
          Glib::ObjectBase::~ObjectBase (D.99528, iftmp.54);
          goto <D.99564>;
          <D.99559>:
          <D.99564>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.99565>; else goto <D.99566>;
      <D.99565>:
      D.99520 = &this->D.97660;
      sigc::trackable::~trackable (D.99520);
      goto <D.99567>;
      <D.99566>:
      <D.99567>:
    }
}


static Glib::RefPtr<Gio::DataOutputStream> Gio::DataOutputStream::create(const Glib::RefPtr<Gio::OutputStream>&) (const struct RefPtr & base_stream)
{
  void * D.98090;

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


void Gio::DataOutputStream::set_byte_order(Gio::DataStreamByteOrder) (struct DataOutputStream * const this, DataStreamByteOrder order)
{
  struct GDataOutputStream * D.99577;

  D.99577 = Gio::DataOutputStream::gobj (this);
  g_data_output_stream_set_byte_order (D.99577, order);
}


Gio::DataStreamByteOrder Gio::DataOutputStream::get_byte_order() const (const struct DataOutputStream * const this)
{
  DataStreamByteOrder D.99578;
  const struct GDataOutputStream * D.99579;

  D.99579 = Gio::DataOutputStream::gobj (this);
  D.99578 = g_data_output_stream_get_byte_order (D.99579);
  return D.99578;
}


const GDataOutputStream* Gio::DataOutputStream::gobj() const (const struct DataOutputStream * const this)
{
  const struct GDataOutputStream * D.99582;
  int (*__vtbl_ptr_type) () * D.99583;
  int (*__vtbl_ptr_type) () * D.99584;
  long int D.99585;
  sizetype D.99586;
  const struct ObjectBase * D.99587;

  D.99583 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99584 = D.99583 + 18446744073709551592;
  D.99585 = MEM[(long int *)D.99584];
  D.99586 = (sizetype) D.99585;
  D.99587 = this + D.99586;
  D.99582 = D.99587->gobject_;
  return D.99582;
}


bool Gio::DataOutputStream::put_byte(guchar, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, guchar data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99589;
  int D.99590;
  struct GDataOutputStream * D.99591;
  int D.99592;
  struct GError * gerror.55;
  bool D.99596;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99589 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99590 = (int) data;
      D.99591 = Gio::DataOutputStream::gobj (this);
      D.99592 = g_data_output_stream_put_byte (D.99591, D.99590, D.99589, &gerror);
      retvalue = D.99592 != 0;
      gerror.55 = gerror;
      if (gerror.55 != 0B) goto <D.99594>; else goto <D.99595>;
      <D.99594>:
      gerror.55 = gerror;
      Glib::Error::throw_exception (gerror.55);
      <D.99595>:
      D.99596 = retvalue;
      return D.99596;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.99602;
  struct BaseObjectType * iftmp.56;
  bool D.99604;
  struct Cancellable * D.99607;

  D.99604 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.99604 != 0) goto <D.99605>; else goto <D.99606>;
  <D.99605>:
  D.99607 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.56 = Gio::Cancellable::gobj (D.99607);
  goto <D.99608>;
  <D.99606>:
  iftmp.56 = 0B;
  <D.99608>:
  D.99602 = iftmp.56;
  return D.99602;
}


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

  D.99611 = this->pCppObject_;
  D.99610 = D.99611 != 0B;
  return D.99610;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.99615;
  int (*__vtbl_ptr_type) () * D.99616;
  int (*__vtbl_ptr_type) () * D.99617;
  long int D.99618;
  sizetype D.99619;
  struct ObjectBase * D.99620;

  D.99616 = this->D.86174._vptr.Object;
  D.99617 = D.99616 + 18446744073709551592;
  D.99618 = MEM[(long int *)D.99617];
  D.99619 = (sizetype) D.99618;
  D.99620 = this + D.99619;
  D.99615 = D.99620->gobject_;
  return D.99615;
}


bool Gio::DataOutputStream::put_byte(guchar) (struct DataOutputStream * const this, guchar data)
{
  int D.99622;
  struct GDataOutputStream * D.99623;
  int D.99624;
  struct GError * gerror.57;
  bool D.99628;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99622 = (int) data;
      D.99623 = Gio::DataOutputStream::gobj (this);
      D.99624 = g_data_output_stream_put_byte (D.99623, D.99622, 0B, &gerror);
      retvalue = D.99624 != 0;
      gerror.57 = gerror;
      if (gerror.57 != 0B) goto <D.99626>; else goto <D.99627>;
      <D.99626>:
      gerror.57 = gerror;
      Glib::Error::throw_exception (gerror.57);
      <D.99627>:
      D.99628 = retvalue;
      return D.99628;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int16(gint16, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, gint16 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99633;
  int D.99634;
  struct GDataOutputStream * D.99635;
  int D.99636;
  struct GError * gerror.58;
  bool D.99640;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99633 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99634 = (int) data;
      D.99635 = Gio::DataOutputStream::gobj (this);
      D.99636 = g_data_output_stream_put_int16 (D.99635, D.99634, D.99633, &gerror);
      retvalue = D.99636 != 0;
      gerror.58 = gerror;
      if (gerror.58 != 0B) goto <D.99638>; else goto <D.99639>;
      <D.99638>:
      gerror.58 = gerror;
      Glib::Error::throw_exception (gerror.58);
      <D.99639>:
      D.99640 = retvalue;
      return D.99640;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int16(gint16) (struct DataOutputStream * const this, gint16 data)
{
  int D.99646;
  struct GDataOutputStream * D.99647;
  int D.99648;
  struct GError * gerror.59;
  bool D.99652;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99646 = (int) data;
      D.99647 = Gio::DataOutputStream::gobj (this);
      D.99648 = g_data_output_stream_put_int16 (D.99647, D.99646, 0B, &gerror);
      retvalue = D.99648 != 0;
      gerror.59 = gerror;
      if (gerror.59 != 0B) goto <D.99650>; else goto <D.99651>;
      <D.99650>:
      gerror.59 = gerror;
      Glib::Error::throw_exception (gerror.59);
      <D.99651>:
      D.99652 = retvalue;
      return D.99652;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint16(guint16, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, guint16 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99657;
  int D.99658;
  struct GDataOutputStream * D.99659;
  int D.99660;
  struct GError * gerror.60;
  bool D.99664;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99657 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99658 = (int) data;
      D.99659 = Gio::DataOutputStream::gobj (this);
      D.99660 = g_data_output_stream_put_uint16 (D.99659, D.99658, D.99657, &gerror);
      retvalue = D.99660 != 0;
      gerror.60 = gerror;
      if (gerror.60 != 0B) goto <D.99662>; else goto <D.99663>;
      <D.99662>:
      gerror.60 = gerror;
      Glib::Error::throw_exception (gerror.60);
      <D.99663>:
      D.99664 = retvalue;
      return D.99664;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint16(guint16) (struct DataOutputStream * const this, guint16 data)
{
  int D.99670;
  struct GDataOutputStream * D.99671;
  int D.99672;
  struct GError * gerror.61;
  bool D.99676;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99670 = (int) data;
      D.99671 = Gio::DataOutputStream::gobj (this);
      D.99672 = g_data_output_stream_put_uint16 (D.99671, D.99670, 0B, &gerror);
      retvalue = D.99672 != 0;
      gerror.61 = gerror;
      if (gerror.61 != 0B) goto <D.99674>; else goto <D.99675>;
      <D.99674>:
      gerror.61 = gerror;
      Glib::Error::throw_exception (gerror.61);
      <D.99675>:
      D.99676 = retvalue;
      return D.99676;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int32(gint32, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, gint32 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99681;
  struct GDataOutputStream * D.99682;
  int D.99683;
  struct GError * gerror.62;
  bool D.99687;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99681 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99682 = Gio::DataOutputStream::gobj (this);
      D.99683 = g_data_output_stream_put_int32 (D.99682, data, D.99681, &gerror);
      retvalue = D.99683 != 0;
      gerror.62 = gerror;
      if (gerror.62 != 0B) goto <D.99685>; else goto <D.99686>;
      <D.99685>:
      gerror.62 = gerror;
      Glib::Error::throw_exception (gerror.62);
      <D.99686>:
      D.99687 = retvalue;
      return D.99687;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int32(gint32) (struct DataOutputStream * const this, gint32 data)
{
  struct GDataOutputStream * D.99693;
  int D.99694;
  struct GError * gerror.63;
  bool D.99698;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99693 = Gio::DataOutputStream::gobj (this);
      D.99694 = g_data_output_stream_put_int32 (D.99693, data, 0B, &gerror);
      retvalue = D.99694 != 0;
      gerror.63 = gerror;
      if (gerror.63 != 0B) goto <D.99696>; else goto <D.99697>;
      <D.99696>:
      gerror.63 = gerror;
      Glib::Error::throw_exception (gerror.63);
      <D.99697>:
      D.99698 = retvalue;
      return D.99698;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint32(guint32, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, guint32 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99703;
  struct GDataOutputStream * D.99704;
  int D.99705;
  struct GError * gerror.64;
  bool D.99709;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99703 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99704 = Gio::DataOutputStream::gobj (this);
      D.99705 = g_data_output_stream_put_uint32 (D.99704, data, D.99703, &gerror);
      retvalue = D.99705 != 0;
      gerror.64 = gerror;
      if (gerror.64 != 0B) goto <D.99707>; else goto <D.99708>;
      <D.99707>:
      gerror.64 = gerror;
      Glib::Error::throw_exception (gerror.64);
      <D.99708>:
      D.99709 = retvalue;
      return D.99709;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint32(guint32) (struct DataOutputStream * const this, guint32 data)
{
  struct GDataOutputStream * D.99715;
  int D.99716;
  struct GError * gerror.65;
  bool D.99720;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99715 = Gio::DataOutputStream::gobj (this);
      D.99716 = g_data_output_stream_put_uint32 (D.99715, data, 0B, &gerror);
      retvalue = D.99716 != 0;
      gerror.65 = gerror;
      if (gerror.65 != 0B) goto <D.99718>; else goto <D.99719>;
      <D.99718>:
      gerror.65 = gerror;
      Glib::Error::throw_exception (gerror.65);
      <D.99719>:
      D.99720 = retvalue;
      return D.99720;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int64(gint64, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, gint64 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99725;
  struct GDataOutputStream * D.99726;
  int D.99727;
  struct GError * gerror.66;
  bool D.99731;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99725 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99726 = Gio::DataOutputStream::gobj (this);
      D.99727 = g_data_output_stream_put_int64 (D.99726, data, D.99725, &gerror);
      retvalue = D.99727 != 0;
      gerror.66 = gerror;
      if (gerror.66 != 0B) goto <D.99729>; else goto <D.99730>;
      <D.99729>:
      gerror.66 = gerror;
      Glib::Error::throw_exception (gerror.66);
      <D.99730>:
      D.99731 = retvalue;
      return D.99731;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_int64(gint64) (struct DataOutputStream * const this, gint64 data)
{
  struct GDataOutputStream * D.99737;
  int D.99738;
  struct GError * gerror.67;
  bool D.99742;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99737 = Gio::DataOutputStream::gobj (this);
      D.99738 = g_data_output_stream_put_int64 (D.99737, data, 0B, &gerror);
      retvalue = D.99738 != 0;
      gerror.67 = gerror;
      if (gerror.67 != 0B) goto <D.99740>; else goto <D.99741>;
      <D.99740>:
      gerror.67 = gerror;
      Glib::Error::throw_exception (gerror.67);
      <D.99741>:
      D.99742 = retvalue;
      return D.99742;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint64(guint64, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, guint64 data, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99747;
  struct GDataOutputStream * D.99748;
  int D.99749;
  struct GError * gerror.68;
  bool D.99753;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99747 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99748 = Gio::DataOutputStream::gobj (this);
      D.99749 = g_data_output_stream_put_uint64 (D.99748, data, D.99747, &gerror);
      retvalue = D.99749 != 0;
      gerror.68 = gerror;
      if (gerror.68 != 0B) goto <D.99751>; else goto <D.99752>;
      <D.99751>:
      gerror.68 = gerror;
      Glib::Error::throw_exception (gerror.68);
      <D.99752>:
      D.99753 = retvalue;
      return D.99753;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_uint64(guint64) (struct DataOutputStream * const this, guint64 data)
{
  struct GDataOutputStream * D.99759;
  int D.99760;
  struct GError * gerror.69;
  bool D.99764;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99759 = Gio::DataOutputStream::gobj (this);
      D.99760 = g_data_output_stream_put_uint64 (D.99759, data, 0B, &gerror);
      retvalue = D.99760 != 0;
      gerror.69 = gerror;
      if (gerror.69 != 0B) goto <D.99762>; else goto <D.99763>;
      <D.99762>:
      gerror.69 = gerror;
      Glib::Error::throw_exception (gerror.69);
      <D.99763>:
      D.99764 = retvalue;
      return D.99764;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Gio::DataOutputStream::put_string(std::string, const Glib::RefPtr<Gio::Cancellable>&) (struct DataOutputStream * const this, struct string & restrict str, const struct RefPtr & cancellable)
{
  struct BaseObjectType * D.99769;
  const char * D.99770;
  struct GDataOutputStream * D.99771;
  int D.99772;
  struct GError * gerror.70;
  bool D.99776;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99769 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.99770 = std::basic_string<char>::c_str (str);
      D.99771 = Gio::DataOutputStream::gobj (this);
      D.99772 = g_data_output_stream_put_string (D.99771, D.99770, D.99769, &gerror);
      retvalue = D.99772 != 0;
      gerror.70 = gerror;
      if (gerror.70 != 0B) goto <D.99774>; else goto <D.99775>;
      <D.99774>:
      gerror.70 = gerror;
      Glib::Error::throw_exception (gerror.70);
      <D.99775>:
      D.99776 = retvalue;
      return D.99776;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


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

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


_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.99786;

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


bool Gio::DataOutputStream::put_string(std::string) (struct DataOutputStream * const this, struct string & restrict str)
{
  const char * D.99788;
  struct GDataOutputStream * D.99789;
  int D.99790;
  struct GError * gerror.71;
  bool D.99794;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.99788 = std::basic_string<char>::c_str (str);
      D.99789 = Gio::DataOutputStream::gobj (this);
      D.99790 = g_data_output_stream_put_string (D.99789, D.99788, 0B, &gerror);
      retvalue = D.99790 != 0;
      gerror.71 = gerror;
      if (gerror.71 != 0B) goto <D.99792>; else goto <D.99793>;
      <D.99792>:
      gerror.71 = gerror;
      Glib::Error::throw_exception (gerror.71);
      <D.99793>:
      D.99794 = retvalue;
      return D.99794;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::PropertyProxy<Gio::DataStreamByteOrder> Gio::DataOutputStream::property_byte_order() (struct DataOutputStream * const this)
{
  int (*__vtbl_ptr_type) () * D.99801;
  int (*__vtbl_ptr_type) () * D.99802;
  long int D.99803;
  sizetype D.99804;
  struct ObjectBase * D.99805;

  D.99801 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99802 = D.99801 + 18446744073709551592;
  D.99803 = MEM[(long int *)D.99802];
  D.99804 = (sizetype) D.99803;
  D.99805 = this + D.99804;
  Glib::PropertyProxy<Gio::DataStreamByteOrder>::PropertyProxy (<retval>, D.99805, "byte-order");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Gio::DataStreamByteOrder] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.99807;

  D.99807 = &this->D.98357;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.99807, obj, name);
}


Glib::PropertyProxy_ReadOnly<Gio::DataStreamByteOrder> Gio::DataOutputStream::property_byte_order() const (const struct DataOutputStream * const this)
{
  int (*__vtbl_ptr_type) () * D.99809;
  int (*__vtbl_ptr_type) () * D.99810;
  long int D.99811;
  sizetype D.99812;
  const struct ObjectBase * D.99813;

  D.99809 = this->D.97657.D.86910.D.86748.D.86631._vptr.Object;
  D.99810 = D.99809 + 18446744073709551592;
  D.99811 = MEM[(long int *)D.99810];
  D.99812 = (sizetype) D.99811;
  D.99813 = this + D.99812;
  Glib::PropertyProxy_ReadOnly<Gio::DataStreamByteOrder>::PropertyProxy_ReadOnly (<retval>, D.99813, "byte-order");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Gio::DataStreamByteOrder] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.99815;

  D.99815 = &this->D.98402;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.99815, obj, name);
}