int {anonymous}::ByteArray_Compare_Data_Func(gconstpointer, gconstpointer, gpointer) (const void * a, const void * b, void * user_data)
{
  int D.86754;
  const unsigned char * const D.86024;
  const unsigned char * const D.86023;
  struct slot2 * D.86755;
  struct SlotCompare * slot;

  slot = user_data;
  D.86024 = b;
  try
    {
      D.86023 = a;
      try
        {
          D.86755 = &slot->D.86021;
          D.86754 = sigc::slot2<int, const unsigned char*, const unsigned char*>::operator() (D.86755, &D.86023, &D.86024);
          return D.86754;
        }
      finally
        {
          D.86023 = {CLOBBER};
        }
    }
  finally
    {
      D.86024 = {CLOBBER};
    }
}


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = int; T_arg1 = const unsigned char*; T_arg2 = const unsigned char*; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const unsigned char* const&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const unsigned char* const&] (const struct slot2 * const this, const unsigned char * const & _A_a1, const unsigned char * const & _A_a2)
{
  bool retval.0;
  bool iftmp.1;
  const struct slot_base * D.86767;
  bool D.86768;
  bool D.86769;
  bool D.86771;
  bool D.86772;
  int D.86776;
  struct rep_type * D.86777;
  void * (*<T609>) (void *) D.86778;

  D.86767 = &this->D.85979;
  D.86768 = sigc::slot_base::empty (D.86767);
  D.86769 = ~D.86768;
  if (D.86769 != 0) goto <D.86770>; else goto <D.86765>;
  <D.86770>:
  D.86767 = &this->D.85979;
  D.86771 = sigc::slot_base::blocked (D.86767);
  D.86772 = ~D.86771;
  if (D.86772 != 0) goto <D.86773>; else goto <D.86765>;
  <D.86773>:
  iftmp.1 = 1;
  goto <D.86766>;
  <D.86765>:
  iftmp.1 = 0;
  <D.86766>:
  retval.0 = iftmp.1;
  if (retval.0 != 0) goto <D.86774>; else goto <D.86775>;
  <D.86774>:
  D.86777 = this->D.85979.rep_;
  D.86778 = D.86777->call_;
  D.86777 = this->D.85979.rep_;
  D.86776 = D.86778 (D.86777, _A_a1, _A_a2);
  return D.86776;
  <D.86775>:
  D.86776 = 0;
  return D.86776;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.86781;
  bool iftmp.2;
  struct rep_type * D.86786;
  void * (*<T609>) (void *) D.86788;

  D.86786 = this->rep_;
  if (D.86786 == 0B) goto <D.86783>; else goto <D.86787>;
  <D.86787>:
  D.86786 = this->rep_;
  D.86788 = D.86786->call_;
  if (D.86788 == 0B) goto <D.86783>; else goto <D.86784>;
  <D.86783>:
  iftmp.2 = 1;
  goto <D.86785>;
  <D.86784>:
  iftmp.2 = 0;
  <D.86785>:
  D.86781 = iftmp.2;
  return D.86781;
}


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

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


guint Glib::ByteArray::size() const (const struct ByteArray * const this)
{
  guint D.86792;
  const struct GByteArray * D.86793;

  D.86793 = Glib::ByteArray::gobj (this);
  D.86792 = D.86793->len;
  return D.86792;
}


guint8* Glib::ByteArray::get_data() (struct ByteArray * const this)
{
  guint8 * D.86795;
  struct GByteArray * D.86796;

  D.86796 = Glib::ByteArray::gobj (this);
  D.86795 = D.86796->data;
  return D.86795;
}


const guint8* Glib::ByteArray::get_data() const (const struct ByteArray * const this)
{
  const guint8 * D.86798;
  const struct GByteArray * D.86799;

  D.86799 = Glib::ByteArray::gobj (this);
  D.86798 = D.86799->data;
  return D.86798;
}


static GType Glib::ByteArray::get_type() ()
{
  GType D.86801;

  D.86801 = g_byte_array_get_type ();
  return D.86801;
}


Glib::RefPtr<Glib::ByteArray> Glib::wrap(GByteArray*, bool) (struct GByteArray * object, bool take_copy)
{
  bool D.86805;
  bool D.86806;

  D.86805 = object != 0B;
  D.86806 = D.86805 & take_copy;
  if (D.86806 != 0) goto <D.86807>; else goto <D.86808>;
  <D.86807>:
  g_byte_array_ref (object);
  goto <D.86809>;
  <D.86808>:
  <D.86809>:
  Glib::RefPtr<Glib::ByteArray>::RefPtr (<retval>, object);
  return <retval>;
}


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


void Glib::ByteArray::reference() const (const struct ByteArray * const this)
{
  g_byte_array_ref (this);
}


void Glib::ByteArray::unreference() const (const struct ByteArray * const this)
{
  g_byte_array_unref (this);
}


GByteArray* Glib::ByteArray::gobj() (struct ByteArray * const this)
{
  struct GByteArray * D.86811;

  D.86811 = this;
  return D.86811;
}


const GByteArray* Glib::ByteArray::gobj() const (const struct ByteArray * const this)
{
  const struct GByteArray * D.86813;

  D.86813 = this;
  return D.86813;
}


GByteArray* Glib::ByteArray::gobj_copy() const (const struct ByteArray * const this)
{
  struct GByteArray * D.86815;
  struct GByteArray * const gobject;

  gobject = this;
  g_byte_array_ref (gobject);
  D.86815 = gobject;
  return D.86815;
}


static Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::create() ()
{
  struct GByteArray * D.86818;

  D.86818 = g_byte_array_new ();
  *<retval> = Glib::wrap (D.86818, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::append(const guint8*, guint) (struct ByteArray * const this, const guint8 * data, guint len)
{
  struct GByteArray * D.86822;
  struct GByteArray * D.86823;
  bool retval.3;
  struct ByteArray * D.86827;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86822 = Glib::ByteArray::gobj (this);
  D.86823 = g_byte_array_append (D.86822, data, len);
  *<retval> = Glib::wrap (D.86823, 0); [return slot optimization]
  try
    {
      retval.3 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.3 != 0) goto <D.86825>; else goto <D.86826>;
      <D.86825>:
      D.86827 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86827);
      goto <D.86828>;
      <D.86826>:
      <D.86828>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Glib::ByteArray] (const struct RefPtr * const this)
{
  bool D.86832;
  struct ByteArray * D.86833;

  D.86833 = this->pCppObject_;
  D.86832 = D.86833 != 0B;
  return D.86832;
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Glib::ByteArray] (struct RefPtr * const this)
{
  struct ByteArray * D.86837;

  {
    try
      {
        D.86837 = this->pCppObject_;
        if (D.86837 != 0B) goto <D.86838>; else goto <D.86839>;
        <D.86838>:
        D.86837 = this->pCppObject_;
        Glib::ByteArray::unreference (D.86837);
        goto <D.86840>;
        <D.86839>:
        <D.86840>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86427>:
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::prepend(const guint8*, guint) (struct ByteArray * const this, const guint8 * data, guint len)
{
  struct GByteArray * D.86843;
  struct GByteArray * D.86844;
  bool retval.4;
  struct ByteArray * D.86848;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86843 = Glib::ByteArray::gobj (this);
  D.86844 = g_byte_array_prepend (D.86843, data, len);
  *<retval> = Glib::wrap (D.86844, 0); [return slot optimization]
  try
    {
      retval.4 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.4 != 0) goto <D.86846>; else goto <D.86847>;
      <D.86846>:
      D.86848 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86848);
      goto <D.86849>;
      <D.86847>:
      <D.86849>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::remove_index(guint) (struct ByteArray * const this, guint index_)
{
  struct GByteArray * D.86854;
  struct GByteArray * D.86855;
  bool retval.5;
  struct ByteArray * D.86859;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86854 = Glib::ByteArray::gobj (this);
  D.86855 = g_byte_array_remove_index (D.86854, index_);
  *<retval> = Glib::wrap (D.86855, 0); [return slot optimization]
  try
    {
      retval.5 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.5 != 0) goto <D.86857>; else goto <D.86858>;
      <D.86857>:
      D.86859 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86859);
      goto <D.86860>;
      <D.86858>:
      <D.86860>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::remove_index_fast(guint) (struct ByteArray * const this, guint index_)
{
  struct GByteArray * D.86865;
  struct GByteArray * D.86866;
  bool retval.6;
  struct ByteArray * D.86870;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86865 = Glib::ByteArray::gobj (this);
  D.86866 = g_byte_array_remove_index_fast (D.86865, index_);
  *<retval> = Glib::wrap (D.86866, 0); [return slot optimization]
  try
    {
      retval.6 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.6 != 0) goto <D.86868>; else goto <D.86869>;
      <D.86868>:
      D.86870 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86870);
      goto <D.86871>;
      <D.86869>:
      <D.86871>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::remove_range(guint, guint) (struct ByteArray * const this, guint index_, guint length)
{
  struct GByteArray * D.86876;
  struct GByteArray * D.86877;
  bool retval.7;
  struct ByteArray * D.86881;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86876 = Glib::ByteArray::gobj (this);
  D.86877 = g_byte_array_remove_range (D.86876, index_, length);
  *<retval> = Glib::wrap (D.86877, 0); [return slot optimization]
  try
    {
      retval.7 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.7 != 0) goto <D.86879>; else goto <D.86880>;
      <D.86879>:
      D.86881 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86881);
      goto <D.86882>;
      <D.86880>:
      <D.86882>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}


void Glib::ByteArray::sort(const SlotCompare&) (struct ByteArray * const this, const struct SlotCompare & slot)
{
  struct GByteArray * D.86886;
  struct SlotCompare * slot_copy;

  slot_copy = slot;
  D.86886 = Glib::ByteArray::gobj (this);
  g_byte_array_sort_with_data (D.86886, ByteArray_Compare_Data_Func, slot_copy);
}


Glib::RefPtr<Glib::ByteArray> Glib::ByteArray::set_size(guint) (struct ByteArray * const this, guint length)
{
  struct GByteArray * D.86888;
  struct GByteArray * D.86889;
  bool retval.8;
  struct ByteArray * D.86893;
  struct RefPtr retvalue [value-expr: *<retval>];

  D.86888 = Glib::ByteArray::gobj (this);
  D.86889 = g_byte_array_set_size (D.86888, length);
  *<retval> = Glib::wrap (D.86889, 0); [return slot optimization]
  try
    {
      retval.8 = Glib::RefPtr<Glib::ByteArray>::operator bool (<retval>);
      if (retval.8 != 0) goto <D.86891>; else goto <D.86892>;
      <D.86891>:
      D.86893 = Glib::RefPtr<Glib::ByteArray>::operator-> (<retval>);
      Glib::ByteArray::reference (D.86893);
      goto <D.86894>;
      <D.86892>:
      <D.86894>:
      return <retval>;
    }
  catch
    {
      Glib::RefPtr<Glib::ByteArray>::~RefPtr (<retval>);
    }
}