static Glib::RefPtr<Glib::Regex> Glib::Regex::create(const Glib::ustring&, Glib::RegexCompileFlags, Glib::RegexMatchFlags) (const struct ustring & pattern, RegexCompileFlags compile_options, RegexMatchFlags match_options)
{
  const char * D.87459;
  struct GError * gerror.0;
  struct GError * gerror;
  struct GRegex * regex;

  try
    {
      gerror = 0B;
      D.87459 = Glib::ustring::c_str (pattern);
      regex = g_regex_new (D.87459, compile_options, match_options, &gerror);
      gerror.0 = gerror;
      if (gerror.0 != 0B) goto <D.87461>; else goto <D.87462>;
      <D.87461>:
      gerror.0 = gerror;
      Glib::Error::throw_exception (gerror.0);
      <D.87462>:
      *<retval> = Glib::wrap (regex, 0); [return slot optimization]
      return <retval>;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


static Glib::ustring Glib::Regex::escape_string(const Glib::ustring&) (const struct ustring & string)
{
  const struct string & D.87470;
  long unsigned int D.87471;
  int D.87472;
  const struct string & D.87473;
  const char * D.87474;
  gchar * D.87475;
  char * D.87476;
  const struct ScopedPtr buf;

  try
    {
      D.87470 = Glib::ustring::raw (string);
      D.87471 = std::basic_string<char>::size (D.87470);
      D.87472 = (int) D.87471;
      D.87473 = Glib::ustring::raw (string);
      D.87474 = std::basic_string<char>::c_str (D.87473);
      D.87475 = g_regex_escape_string (D.87474, D.87472);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.87475);
      try
        {
          D.87476 = Glib::ScopedPtr<char>::get (&buf);
          Glib::ustring::ustring (<retval>, D.87476);
          return <retval>;
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {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.87485;
  struct _Rep * D.87486;

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


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.87489;
  char * D.87490;

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


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

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


const string& Glib::ustring::raw() const (const struct ustring * const this)
{
  const struct string & D.87495;

  D.87495 = &this->string_;
  return D.87495;
}


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.87497;

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


Glib::ScopedPtr<T>::ScopedPtr(T*) [with T = char] (struct ScopedPtr * const this, char * ptr)
{
  this->ptr_ = ptr;
}


T* Glib::ScopedPtr<T>::get() const [with T = char] (const struct ScopedPtr * const this)
{
  char * D.87500;

  D.87500 = this->ptr_;
  return D.87500;
}


Glib::ScopedPtr<T>::~ScopedPtr() [with T = char] (struct ScopedPtr * const this)
{
  char * D.87502;

  {
    try
      {
        D.87502 = this->ptr_;
        g_free (D.87502);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87065>:
}


bool Glib::Regex::match(const Glib::ustring&, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87504;
  struct GRegex * D.87505;
  int D.87506;
  struct GMatchInfo * ginfo.1;
  bool D.87508;
  struct GMatchInfo * ginfo;
  const bool result;

  try
    {
      ginfo = 0B;
      D.87504 = Glib::ustring::c_str (string);
      D.87505 = Glib::Regex::gobj (this);
      D.87506 = g_regex_match (D.87505, D.87504, match_options, &ginfo);
      result = D.87506 != 0;
      ginfo.1 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.1, 1);
      D.87508 = result;
      return D.87508;
    }
  finally
    {
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match(const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, RegexMatchFlags match_options)
{
  bool D.87514;
  const char * D.87515;
  struct GRegex * D.87516;
  int D.87517;

  D.87515 = Glib::ustring::c_str (string);
  D.87516 = Glib::Regex::gobj (this);
  D.87517 = g_regex_match (D.87516, D.87515, match_options, 0B);
  D.87514 = D.87517 != 0;
  return D.87514;
}


bool Glib::Regex::match(const Glib::ustring&, int, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87521;
  struct GRegex * D.87522;
  int D.87523;
  struct GError * gerror.2;
  struct GMatchInfo * ginfo.3;
  bool D.87528;
  struct GError * gerror;
  struct GMatchInfo * ginfo;
  const bool result;

  try
    {
      gerror = 0B;
      ginfo = 0B;
      D.87521 = Glib::ustring::c_str (string);
      D.87522 = Glib::Regex::gobj (this);
      D.87523 = g_regex_match_full (D.87522, D.87521, -1, start_position, match_options, &ginfo, &gerror);
      result = D.87523 != 0;
      gerror.2 = gerror;
      if (gerror.2 != 0B) goto <D.87525>; else goto <D.87526>;
      <D.87525>:
      gerror.2 = gerror;
      Glib::Error::throw_exception (gerror.2);
      <D.87526>:
      ginfo.3 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.3, 1);
      D.87528 = result;
      return D.87528;
    }
  finally
    {
      gerror = {CLOBBER};
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match(const Glib::ustring&, gssize, int, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, gssize string_len, int start_position, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87534;
  struct GRegex * D.87535;
  int D.87536;
  struct GError * gerror.4;
  struct GMatchInfo * ginfo.5;
  bool D.87541;
  struct GError * gerror;
  struct GMatchInfo * ginfo;
  const bool result;

  try
    {
      gerror = 0B;
      ginfo = 0B;
      D.87534 = Glib::ustring::c_str (string);
      D.87535 = Glib::Regex::gobj (this);
      D.87536 = g_regex_match_full (D.87535, D.87534, string_len, start_position, match_options, &ginfo, &gerror);
      result = D.87536 != 0;
      gerror.4 = gerror;
      if (gerror.4 != 0B) goto <D.87538>; else goto <D.87539>;
      <D.87538>:
      gerror.4 = gerror;
      Glib::Error::throw_exception (gerror.4);
      <D.87539>:
      ginfo.5 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.5, 1);
      D.87541 = result;
      return D.87541;
    }
  finally
    {
      gerror = {CLOBBER};
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match(const Glib::ustring&, int, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, RegexMatchFlags match_options)
{
  const char * D.87547;
  struct GRegex * D.87548;
  int D.87549;
  struct GError * gerror.6;
  bool D.87553;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87547 = Glib::ustring::c_str (string);
      D.87548 = Glib::Regex::gobj (this);
      D.87549 = g_regex_match_full (D.87548, D.87547, -1, start_position, match_options, 0B, &gerror);
      retvalue = D.87549 != 0;
      gerror.6 = gerror;
      if (gerror.6 != 0B) goto <D.87551>; else goto <D.87552>;
      <D.87551>:
      gerror.6 = gerror;
      Glib::Error::throw_exception (gerror.6);
      <D.87552>:
      D.87553 = retvalue;
      return D.87553;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Glib::Regex::match(const Glib::ustring&, gssize, int, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, gssize string_len, int start_position, RegexMatchFlags match_options)
{
  const char * D.87559;
  struct GRegex * D.87560;
  int D.87561;
  struct GError * gerror.7;
  bool D.87565;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87559 = Glib::ustring::c_str (string);
      D.87560 = Glib::Regex::gobj (this);
      D.87561 = g_regex_match_full (D.87560, D.87559, string_len, start_position, match_options, 0B, &gerror);
      retvalue = D.87561 != 0;
      gerror.7 = gerror;
      if (gerror.7 != 0B) goto <D.87563>; else goto <D.87564>;
      <D.87563>:
      gerror.7 = gerror;
      Glib::Error::throw_exception (gerror.7);
      <D.87564>:
      D.87565 = retvalue;
      return D.87565;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Glib::Regex::match_all(const Glib::ustring&, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87571;
  struct GRegex * D.87572;
  int D.87573;
  struct GMatchInfo * ginfo.8;
  bool D.87575;
  struct GMatchInfo * ginfo;
  const bool result;

  try
    {
      ginfo = 0B;
      D.87571 = Glib::ustring::c_str (string);
      D.87572 = Glib::Regex::gobj (this);
      D.87573 = g_regex_match_all (D.87572, D.87571, match_options, &ginfo);
      result = D.87573 != 0;
      ginfo.8 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.8, 1);
      D.87575 = result;
      return D.87575;
    }
  finally
    {
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match_all(const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, RegexMatchFlags match_options)
{
  bool D.87581;
  const char * D.87582;
  struct GRegex * D.87583;
  int D.87584;

  D.87582 = Glib::ustring::c_str (string);
  D.87583 = Glib::Regex::gobj (this);
  D.87584 = g_regex_match_all (D.87583, D.87582, match_options, 0B);
  D.87581 = D.87584 != 0;
  return D.87581;
}


bool Glib::Regex::match_all(const Glib::ustring&, int, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87588;
  struct GRegex * D.87589;
  int D.87590;
  struct GError * gerror.9;
  struct GMatchInfo * ginfo.10;
  bool D.87595;
  struct GError * gerror;
  struct GMatchInfo * ginfo;
  const bool retvalue;

  try
    {
      gerror = 0B;
      ginfo = 0B;
      D.87588 = Glib::ustring::c_str (string);
      D.87589 = Glib::Regex::gobj (this);
      D.87590 = g_regex_match_all_full (D.87589, D.87588, -1, start_position, match_options, &ginfo, &gerror);
      retvalue = D.87590 != 0;
      gerror.9 = gerror;
      if (gerror.9 != 0B) goto <D.87592>; else goto <D.87593>;
      <D.87592>:
      gerror.9 = gerror;
      Glib::Error::throw_exception (gerror.9);
      <D.87593>:
      ginfo.10 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.10, 1);
      D.87595 = retvalue;
      return D.87595;
    }
  finally
    {
      gerror = {CLOBBER};
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match_all(const Glib::ustring&, gssize, int, Glib::MatchInfo&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, gssize string_len, int start_position, struct MatchInfo & match_info, RegexMatchFlags match_options)
{
  const char * D.87601;
  struct GRegex * D.87602;
  int D.87603;
  struct GError * gerror.11;
  struct GMatchInfo * ginfo.12;
  bool D.87608;
  struct GError * gerror;
  struct GMatchInfo * ginfo;
  const bool retvalue;

  try
    {
      gerror = 0B;
      ginfo = 0B;
      D.87601 = Glib::ustring::c_str (string);
      D.87602 = Glib::Regex::gobj (this);
      D.87603 = g_regex_match_all_full (D.87602, D.87601, string_len, start_position, match_options, &ginfo, &gerror);
      retvalue = D.87603 != 0;
      gerror.11 = gerror;
      if (gerror.11 != 0B) goto <D.87605>; else goto <D.87606>;
      <D.87605>:
      gerror.11 = gerror;
      Glib::Error::throw_exception (gerror.11);
      <D.87606>:
      ginfo.12 = ginfo;
      Glib::MatchInfo::set_gobject (match_info, ginfo.12, 1);
      D.87608 = retvalue;
      return D.87608;
    }
  finally
    {
      gerror = {CLOBBER};
      ginfo = {CLOBBER};
    }
}


bool Glib::Regex::match_all(const Glib::ustring&, int, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, RegexMatchFlags match_options)
{
  const char * D.87614;
  struct GRegex * D.87615;
  int D.87616;
  struct GError * gerror.13;
  bool D.87620;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87614 = Glib::ustring::c_str (string);
      D.87615 = Glib::Regex::gobj (this);
      D.87616 = g_regex_match_all_full (D.87615, D.87614, -1, start_position, match_options, 0B, &gerror);
      retvalue = D.87616 != 0;
      gerror.13 = gerror;
      if (gerror.13 != 0B) goto <D.87618>; else goto <D.87619>;
      <D.87618>:
      gerror.13 = gerror;
      Glib::Error::throw_exception (gerror.13);
      <D.87619>:
      D.87620 = retvalue;
      return D.87620;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


bool Glib::Regex::match_all(const Glib::ustring&, gssize, int, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, gssize string_len, int start_position, RegexMatchFlags match_options)
{
  const char * D.87626;
  struct GRegex * D.87627;
  int D.87628;
  struct GError * gerror.14;
  bool D.87632;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87626 = Glib::ustring::c_str (string);
      D.87627 = Glib::Regex::gobj (this);
      D.87628 = g_regex_match_all_full (D.87627, D.87626, string_len, start_position, match_options, 0B, &gerror);
      retvalue = D.87628 != 0;
      gerror.14 = gerror;
      if (gerror.14 != 0B) goto <D.87630>; else goto <D.87631>;
      <D.87630>:
      gerror.14 = gerror;
      Glib::Error::throw_exception (gerror.14);
      <D.87631>:
      D.87632 = retvalue;
      return D.87632;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::Regex::replace(const Glib::ustring&, int, const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, const struct ustring & replacement, RegexMatchFlags match_options)
{
  const char * D.87639;
  const char * D.87640;
  struct GRegex * D.87641;
  gchar * D.87642;
  struct GError * gerror.15;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87639 = Glib::ustring::c_str (replacement);
      D.87640 = Glib::ustring::c_str (string);
      D.87641 = Glib::Regex::gobj (this);
      D.87642 = g_regex_replace (D.87641, D.87640, -1, start_position, D.87639, match_options, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87642); [return slot optimization]
      try
        {
          gerror.15 = gerror;
          if (gerror.15 != 0B) goto <D.87644>; else goto <D.87645>;
          <D.87644>:
          gerror.15 = gerror;
          Glib::Error::throw_exception (gerror.15);
          <D.87645>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.16;
  char * D.87659;
  struct ustring * D.87660;

  cleanup.16 = 0;
  try
    {
      if (str != 0B) goto <D.87654>; else goto <D.87655>;
      <D.87654>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.16 = 1;
      D.87659 = Glib::ScopedPtr<char>::get (&D.78974);
      D.87660 = <retval>;
      Glib::ustring::ustring (D.87660, D.87659);
      goto <D.87661>;
      <D.87655>:
      D.87660 = <retval>;
      Glib::ustring::ustring (D.87660);
      <D.87661>:
      return <retval>;
    }
  finally
    {
      if (cleanup.16 != 0) goto <D.87657>; else goto <D.87658>;
      <D.87657>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.87658>:
    }
}


Glib::ustring Glib::Regex::replace_literal(const Glib::ustring&, int, const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, int start_position, const struct ustring & replacement, RegexMatchFlags match_options)
{
  const char * D.87668;
  const char * D.87669;
  struct GRegex * D.87670;
  gchar * D.87671;
  struct GError * gerror.17;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87668 = Glib::ustring::c_str (replacement);
      D.87669 = Glib::ustring::c_str (string);
      D.87670 = Glib::Regex::gobj (this);
      D.87671 = g_regex_replace_literal (D.87670, D.87669, -1, start_position, D.87668, match_options, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87671); [return slot optimization]
      try
        {
          gerror.17 = gerror;
          if (gerror.17 != 0B) goto <D.87673>; else goto <D.87674>;
          <D.87673>:
          gerror.17 = gerror;
          Glib::Error::throw_exception (gerror.17);
          <D.87674>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::StringArrayHandle Glib::Regex::split(const Glib::ustring&, int, Glib::RegexMatchFlags, int) const (const struct Regex * const this, const struct ustring & string, int start_position, RegexMatchFlags match_options, int max_tokens)
{
  const char * D.87683;
  const struct GRegex * D.87684;
  gchar * * D.87685;
  struct GError * gerror.18;
  struct GError * gerror;
  struct StringArrayHandle retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87683 = Glib::ustring::c_str (string);
      D.87684 = Glib::Regex::gobj (this);
      D.87685 = g_regex_split_full (D.87684, D.87683, -1, start_position, match_options, max_tokens, &gerror);
      Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.87685, 2);
      try
        {
          gerror.18 = gerror;
          if (gerror.18 != 0B) goto <D.87687>; else goto <D.87688>;
          <D.87687>:
          gerror.18 = gerror;
          Glib::Error::throw_exception (gerror.18);
          <D.87688>:
          return <retval>;
        }
      catch
        {
          Glib::ArrayHandle<Glib::ustring>::~ArrayHandle (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ArrayHandle<T, Tr>::ArrayHandle(const CType*, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandle<T, Tr>::CType = const char*] (struct ArrayHandle * const this, const char * const * array, OwnershipType ownership)
{
  long unsigned int iftmp.19;

  if (array != 0B) goto <D.87696>; else goto <D.87697>;
  <D.87696>:
  iftmp.19 = Glib::Container_Helpers::compute_array_size<const char*> (array);
  goto <D.87698>;
  <D.87697>:
  iftmp.19 = 0;
  <D.87698>:
  this->size_ = iftmp.19;
  this->parray_ = array;
  this->ownership_ = ownership;
}


std::size_t Glib::Container_Helpers::compute_array_size(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.87699;
  size_t D.87700;
  long int pend.20;
  long int array.21;
  long int D.87703;
  long int D.87704;
  const char * const * pend;

  pend = array;
  goto <D.87232>;
  <D.87233>:
  pend = pend + 8;
  <D.87232>:
  D.87699 = *pend;
  if (D.87699 != 0B) goto <D.87233>; else goto <D.87231>;
  <D.87231>:
  pend.20 = (long int) pend;
  array.21 = (long int) array;
  D.87703 = pend.20 - array.21;
  D.87704 = D.87703 /[ex] 8;
  D.87700 = (size_t) D.87704;
  return D.87700;
}


Glib::ArrayHandle<T, Tr>::~ArrayHandle() [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayHandle * const this)
{
  const char * const * D.87706;
  OwnershipType D.87709;
  long unsigned int D.87714;
  long unsigned int D.87715;
  const char * D.87716;

  {
    try
      {
        {
          {
            D.87706 = this->parray_;
            if (D.87706 != 0B) goto <D.87707>; else goto <D.87708>;
            <D.87707>:
            D.87709 = this->ownership_;
            if (D.87709 != 0) goto <D.87710>; else goto <D.87711>;
            <D.87710>:
            {
              {
                D.87709 = this->ownership_;
                if (D.87709 != 1) goto <D.87712>; else goto <D.87713>;
                <D.87712>:
                {
                  const char * const * const pend;

                  D.87706 = this->parray_;
                  D.87714 = this->size_;
                  D.87715 = D.87714 * 8;
                  pend = D.87706 + D.87715;
                  {
                    const char * const * p;

                    p = this->parray_;
                    goto <D.87100>;
                    <D.87101>:
                    D.87716 = *p;
                    Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type (D.87716);
                    p = p + 8;
                    <D.87100>:
                    if (p != pend) goto <D.87101>; else goto <D.87102>;
                    <D.87102>:
                  }
                }
                goto <D.87717>;
                <D.87713>:
                <D.87717>:
              }
              D.87706 = this->parray_;
              g_free (D.87706);
            }
            goto <D.87718>;
            <D.87711>:
            <D.87718>:
            <D.87708>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87103>:
}


static void Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type(Glib::Container_Helpers::TypeTraits<Glib::ustring>::CType) (const char * str)
{
  g_free (str);
}


Glib::MatchInfo::MatchInfo() (struct MatchInfo * const this)
{
  this->_vptr.MatchInfo = &MEM[(void *)&_ZTVN4Glib9MatchInfoE + 16B];
  this->gobject_ = 0B;
  this->take_ownership = 0;
}


Glib::MatchInfo::MatchInfo(GMatchInfo*, bool) (struct MatchInfo * const this, struct GMatchInfo * castitem, bool take_ownership)
{
  this->_vptr.MatchInfo = &MEM[(void *)&_ZTVN4Glib9MatchInfoE + 16B];
  this->gobject_ = castitem;
  this->take_ownership = take_ownership;
}


void Glib::MatchInfo::set_gobject(GMatchInfo*, bool) (struct MatchInfo * const this, struct GMatchInfo * castitem, bool take_ownership)
{
  struct GMatchInfo * D.87720;

  D.87720 = this->gobject_;
  if (D.87720 != 0B) goto <D.87721>; else goto <D.87722>;
  <D.87721>:
  if (take_ownership != 0) goto <D.87723>; else goto <D.87724>;
  <D.87723>:
  D.87720 = this->gobject_;
  g_match_info_free (D.87720);
  goto <D.87725>;
  <D.87724>:
  <D.87725>:
  <D.87722>:
  this->gobject_ = castitem;
  this->take_ownership = take_ownership;
}


Glib::MatchInfo::~MatchInfo() (struct MatchInfo * const this)
{
  bool D.87726;
  struct GMatchInfo * D.87729;
  int D.87733;

  {
    this->_vptr.MatchInfo = &MEM[(void *)&_ZTVN4Glib9MatchInfoE + 16B];
    try
      {
        D.87726 = this->take_ownership;
        if (D.87726 != 0) goto <D.87727>; else goto <D.87728>;
        <D.87727>:
        D.87729 = this->gobject_;
        if (D.87729 != 0B) goto <D.87730>; else goto <D.87731>;
        <D.87730>:
        D.87729 = this->gobject_;
        g_match_info_free (D.87729);
        goto <D.87732>;
        <D.87731>:
        <D.87732>:
        <D.87728>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86367>:
  D.87733 = 0;
  if (D.87733 != 0) goto <D.87734>; else goto <D.87735>;
  <D.87734>:
  operator delete (this);
  goto <D.87736>;
  <D.87735>:
  <D.87736>:
}


virtual Glib::MatchInfo::~MatchInfo() (struct MatchInfo * const this)
{
  Glib::MatchInfo::~MatchInfo (this);
  <D.86371>:
  operator delete (this);
}


Glib::RegexError::RegexError(Glib::RegexError::Code, const Glib::ustring&) (struct RegexError * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.22;
  unsigned int D.87739;
  struct Error * D.87740;

  error_code.22 = (int) error_code;
  D.87739 = g_regex_error_quark ();
  D.87740 = &this->D.83003;
  Glib::Error::Error (D.87740, D.87739, error_code.22, error_message);
  try
    {
      this->D.83003.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN4Glib10RegexErrorE + 16B];
    }
  catch
    {
      D.87740 = &this->D.83003;
      Glib::Error::~Error (D.87740);
    }
}


virtual Glib::RegexError::~RegexError() (struct RegexError * const this)
{
  Glib::RegexError::~RegexError (this);
  <D.87452>:
  operator delete (this);
}


Glib::RegexError::~RegexError() (struct RegexError * const this)
{
  struct Error * D.87742;
  int D.87743;

  {
    this->D.83003.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN4Glib10RegexErrorE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.87742 = &this->D.83003;
            Glib::Error::~Error (D.87742);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87448>:
  D.87743 = 0;
  if (D.87743 != 0) goto <D.87744>; else goto <D.87745>;
  <D.87744>:
  operator delete (this);
  goto <D.87746>;
  <D.87745>:
  <D.87746>:
}


Glib::RegexError::RegexError(GError*) (struct RegexError * const this, struct GError * gobject)
{
  struct Error * D.87747;

  D.87747 = &this->D.83003;
  Glib::Error::Error (D.87747, gobject, 0);
  try
    {
      this->D.83003.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN4Glib10RegexErrorE + 16B];
    }
  catch
    {
      D.87747 = &this->D.83003;
      Glib::Error::~Error (D.87747);
    }
}


Glib::RegexError::Code Glib::RegexError::code() const (const struct RegexError * const this)
{
  Code D.87748;
  const struct Error * D.87749;
  int D.87750;

  D.87749 = &this->D.83003;
  D.87750 = Glib::Error::code (D.87749);
  D.87748 = (Code) D.87750;
  return D.87748;
}


static void Glib::RegexError::throw_func(GError*) (struct GError * gobject)
{
  void * D.86405;

  D.86405 = __cxa_allocate_exception (16);
  try
    {
      Glib::RegexError::RegexError (D.86405, gobject);
    }
  catch
    {
      __cxa_free_exception (D.86405);
    }
  __cxa_throw (D.86405, &_ZTIN4Glib10RegexErrorE, __comp_dtor );
}


Glib::RefPtr<Glib::Regex> Glib::wrap(GRegex*, bool) (struct GRegex * object, bool take_copy)
{
  bool D.87755;
  bool D.87756;

  D.87755 = object != 0B;
  D.87756 = D.87755 & take_copy;
  if (D.87756 != 0) goto <D.87757>; else goto <D.87758>;
  <D.87757>:
  g_regex_ref (object);
  goto <D.87759>;
  <D.87758>:
  <D.87759>:
  Glib::RefPtr<Glib::Regex>::RefPtr (<retval>, object);
  return <retval>;
}


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


void Glib::Regex::reference() const (const struct Regex * const this)
{
  g_regex_ref (this);
}


void Glib::Regex::unreference() const (const struct Regex * const this)
{
  g_regex_unref (this);
}


GRegex* Glib::Regex::gobj() (struct Regex * const this)
{
  struct GRegex * D.87761;

  D.87761 = this;
  return D.87761;
}


const GRegex* Glib::Regex::gobj() const (const struct Regex * const this)
{
  const struct GRegex * D.87763;

  D.87763 = this;
  return D.87763;
}


GRegex* Glib::Regex::gobj_copy() const (const struct Regex * const this)
{
  struct GRegex * D.87765;
  struct GRegex * const gobject;

  gobject = this;
  g_regex_ref (gobject);
  D.87765 = gobject;
  return D.87765;
}


Glib::ustring Glib::Regex::get_pattern() const (const struct Regex * const this)
{
  const struct GRegex * D.87768;
  const gchar * D.87769;

  D.87768 = Glib::Regex::gobj (this);
  D.87769 = g_regex_get_pattern (D.87768);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.87769); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_const_gchar_ptr_to_ustring(const char*) (const char * str)
{
  struct ustring * D.87775;

  if (str != 0B) goto <D.87773>; else goto <D.87774>;
  <D.87773>:
  D.87775 = <retval>;
  Glib::ustring::ustring (D.87775, str);
  goto <D.87776>;
  <D.87774>:
  D.87775 = <retval>;
  Glib::ustring::ustring (D.87775);
  <D.87776>:
  return <retval>;
}


int Glib::Regex::get_max_backref() const (const struct Regex * const this)
{
  int D.87778;
  const struct GRegex * D.87779;

  D.87779 = Glib::Regex::gobj (this);
  D.87778 = g_regex_get_max_backref (D.87779);
  return D.87778;
}


int Glib::Regex::get_capture_count() const (const struct Regex * const this)
{
  int D.87782;
  const struct GRegex * D.87783;

  D.87783 = Glib::Regex::gobj (this);
  D.87782 = g_regex_get_capture_count (D.87783);
  return D.87782;
}


bool Glib::Regex::get_has_cr_or_lf() const (const struct Regex * const this)
{
  bool D.87786;
  const struct GRegex * D.87787;
  int D.87788;

  D.87787 = Glib::Regex::gobj (this);
  D.87788 = g_regex_get_has_cr_or_lf (D.87787);
  D.87786 = D.87788 != 0;
  return D.87786;
}


int Glib::Regex::get_max_lookbehind() const (const struct Regex * const this)
{
  int D.87791;
  const struct GRegex * D.87792;

  D.87792 = Glib::Regex::gobj (this);
  D.87791 = g_regex_get_max_lookbehind (D.87792);
  return D.87791;
}


int Glib::Regex::get_string_number(const Glib::ustring&) const (const struct Regex * const this, const struct ustring & name)
{
  int D.87795;
  const char * D.87796;
  const struct GRegex * D.87797;

  D.87796 = Glib::ustring::c_str (name);
  D.87797 = Glib::Regex::gobj (this);
  D.87795 = g_regex_get_string_number (D.87797, D.87796);
  return D.87795;
}


Glib::RegexCompileFlags Glib::Regex::get_compile_flags() const (const struct Regex * const this)
{
  RegexCompileFlags D.87801;
  const struct GRegex * D.87802;

  D.87802 = Glib::Regex::gobj (this);
  D.87801 = g_regex_get_compile_flags (D.87802);
  return D.87801;
}


Glib::RegexMatchFlags Glib::Regex::get_match_flags() const (const struct Regex * const this)
{
  RegexMatchFlags D.87805;
  const struct GRegex * D.87806;

  D.87806 = Glib::Regex::gobj (this);
  D.87805 = g_regex_get_match_flags (D.87806);
  return D.87805;
}


static bool Glib::Regex::match_simple(const Glib::ustring&, const Glib::ustring&, Glib::RegexCompileFlags, Glib::RegexMatchFlags) (const struct ustring & pattern, const struct ustring & string, RegexCompileFlags compile_options, RegexMatchFlags match_options)
{
  bool D.87809;
  const char * D.87810;
  const char * D.87811;
  int D.87812;

  D.87810 = Glib::ustring::c_str (string);
  D.87811 = Glib::ustring::c_str (pattern);
  D.87812 = g_regex_match_simple (D.87811, D.87810, compile_options, match_options);
  D.87809 = D.87812 != 0;
  return D.87809;
}


static Glib::StringArrayHandle Glib::Regex::split_simple(const Glib::ustring&, const Glib::ustring&, Glib::RegexCompileFlags, Glib::RegexMatchFlags) (const struct ustring & pattern, const struct ustring & string, RegexCompileFlags compile_options, RegexMatchFlags match_options)
{
  const char * D.87818;
  const char * D.87819;
  gchar * * D.87820;

  D.87818 = Glib::ustring::c_str (string);
  D.87819 = Glib::ustring::c_str (pattern);
  D.87820 = g_regex_split_simple (D.87819, D.87818, compile_options, match_options);
  Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.87820, 2);
  return <retval>;
}


Glib::StringArrayHandle Glib::Regex::split(const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const struct ustring & string, RegexMatchFlags match_options)
{
  const char * D.87826;
  struct GRegex * D.87827;
  gchar * * D.87828;

  D.87826 = Glib::ustring::c_str (string);
  D.87827 = Glib::Regex::gobj (this);
  D.87828 = g_regex_split (D.87827, D.87826, match_options);
  Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.87828, 2);
  return <retval>;
}


Glib::StringArrayHandle Glib::Regex::split(const gchar*, gssize, int, Glib::RegexMatchFlags, int) const (const struct Regex * const this, const gchar * string, gssize string_len, int start_position, RegexMatchFlags match_options, int max_tokens)
{
  const struct GRegex * D.87833;
  gchar * * D.87834;
  struct GError * gerror.23;
  struct GError * gerror;
  struct StringArrayHandle retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87833 = Glib::Regex::gobj (this);
      D.87834 = g_regex_split_full (D.87833, string, string_len, start_position, match_options, max_tokens, &gerror);
      Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.87834, 2);
      try
        {
          gerror.23 = gerror;
          if (gerror.23 != 0B) goto <D.87836>; else goto <D.87837>;
          <D.87836>:
          gerror.23 = gerror;
          Glib::Error::throw_exception (gerror.23);
          <D.87837>:
          return <retval>;
        }
      catch
        {
          Glib::ArrayHandle<Glib::ustring>::~ArrayHandle (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::Regex::replace(const gchar*, gssize, int, const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const gchar * string, gssize string_len, int start_position, const struct ustring & replacement, RegexMatchFlags match_options)
{
  const char * D.87844;
  struct GRegex * D.87845;
  gchar * D.87846;
  struct GError * gerror.24;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87844 = Glib::ustring::c_str (replacement);
      D.87845 = Glib::Regex::gobj (this);
      D.87846 = g_regex_replace (D.87845, string, string_len, start_position, D.87844, match_options, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87846); [return slot optimization]
      try
        {
          gerror.24 = gerror;
          if (gerror.24 != 0B) goto <D.87848>; else goto <D.87849>;
          <D.87848>:
          gerror.24 = gerror;
          Glib::Error::throw_exception (gerror.24);
          <D.87849>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::Regex::replace_literal(const gchar*, gssize, int, const Glib::ustring&, Glib::RegexMatchFlags) (struct Regex * const this, const gchar * string, gssize string_len, int start_position, const struct ustring & replacement, RegexMatchFlags match_options)
{
  const char * D.87857;
  struct GRegex * D.87858;
  gchar * D.87859;
  struct GError * gerror.25;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87857 = Glib::ustring::c_str (replacement);
      D.87858 = Glib::Regex::gobj (this);
      D.87859 = g_regex_replace_literal (D.87858, string, string_len, start_position, D.87857, match_options, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87859); [return slot optimization]
      try
        {
          gerror.25 = gerror;
          if (gerror.25 != 0B) goto <D.87861>; else goto <D.87862>;
          <D.87861>:
          gerror.25 = gerror;
          Glib::Error::throw_exception (gerror.25);
          <D.87862>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::Regex::replace_eval(const Glib::ustring&, gssize, int, Glib::RegexMatchFlags, GRegexEvalCallback, gpointer) (struct Regex * const this, const struct ustring & string, gssize string_len, int start_position, RegexMatchFlags match_options, gboolean (*GRegexEvalCallback) (const struct GMatchInfo *, struct GString *, void *) eval, void * user_data)
{
  const char * D.87870;
  struct GRegex * D.87871;
  gchar * D.87872;
  struct GError * gerror.26;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87870 = Glib::ustring::c_str (string);
      D.87871 = Glib::Regex::gobj (this);
      D.87872 = g_regex_replace_eval (D.87871, D.87870, string_len, start_position, match_options, eval, user_data, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87872); [return slot optimization]
      try
        {
          gerror.26 = gerror;
          if (gerror.26 != 0B) goto <D.87874>; else goto <D.87875>;
          <D.87874>:
          gerror.26 = gerror;
          Glib::Error::throw_exception (gerror.26);
          <D.87875>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


static bool Glib::Regex::check_replacement(const Glib::ustring&, gboolean*) (const struct ustring & replacement, gboolean * has_references)
{
  const char * D.87882;
  int D.87883;
  struct GError * gerror.27;
  bool D.87887;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87882 = Glib::ustring::c_str (replacement);
      D.87883 = g_regex_check_replacement (D.87882, has_references, &gerror);
      retvalue = D.87883 != 0;
      gerror.27 = gerror;
      if (gerror.27 != 0B) goto <D.87885>; else goto <D.87886>;
      <D.87885>:
      gerror.27 = gerror;
      Glib::Error::throw_exception (gerror.27);
      <D.87886>:
      D.87887 = retvalue;
      return D.87887;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::RefPtr<Glib::Regex> Glib::MatchInfo::get_regex() (struct MatchInfo * const this)
{
  struct GMatchInfo * D.87894;
  struct GRegex * D.87895;

  D.87894 = Glib::MatchInfo::gobj (this);
  D.87895 = g_match_info_get_regex (D.87894);
  *<retval> = Glib::wrap (D.87895, 0); [return slot optimization]
  return <retval>;
}


GMatchInfo* Glib::MatchInfo::gobj() (struct MatchInfo * const this)
{
  struct GMatchInfo * D.87898;

  D.87898 = this->gobject_;
  return D.87898;
}


Glib::RefPtr<const Glib::Regex> Glib::MatchInfo::get_regex() const (const struct MatchInfo * const this)
{
  struct RefPtr D.86665;

  D.86665 = Glib::MatchInfo::get_regex (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Glib::Regex>::RefPtr<Glib::Regex> (<retval>, &D.86665);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Glib::Regex>::~RefPtr (&D.86665);
      D.86665 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Glib::Regex; T_CppObject = const Glib::Regex] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Regex * D.87904;
  const struct Regex * D.87905;

  D.87904 = Glib::RefPtr<Glib::Regex>::operator-> (src);
  this->pCppObject_ = D.87904;
  D.87905 = this->pCppObject_;
  if (D.87905 != 0B) goto <D.87906>; else goto <D.87907>;
  <D.87906>:
  D.87905 = this->pCppObject_;
  Glib::Regex::reference (D.87905);
  goto <D.87908>;
  <D.87907>:
  <D.87908>:
}


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

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


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

  {
    try
      {
        D.87911 = this->pCppObject_;
        if (D.87911 != 0B) goto <D.87912>; else goto <D.87913>;
        <D.87912>:
        D.87911 = this->pCppObject_;
        Glib::Regex::unreference (D.87911);
        goto <D.87914>;
        <D.87913>:
        <D.87914>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87076>:
}


Glib::ustring Glib::MatchInfo::get_string() const (const struct MatchInfo * const this)
{
  const struct GMatchInfo * D.87917;
  const gchar * D.87918;

  D.87917 = Glib::MatchInfo::gobj (this);
  D.87918 = g_match_info_get_string (D.87917);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.87918); [return slot optimization]
  return <retval>;
}


const GMatchInfo* Glib::MatchInfo::gobj() const (const struct MatchInfo * const this)
{
  const struct GMatchInfo * D.87921;

  D.87921 = this->gobject_;
  return D.87921;
}


bool Glib::MatchInfo::matches() const (const struct MatchInfo * const this)
{
  bool D.87923;
  const struct GMatchInfo * D.87924;
  int D.87925;

  D.87924 = Glib::MatchInfo::gobj (this);
  D.87925 = g_match_info_matches (D.87924);
  D.87923 = D.87925 != 0;
  return D.87923;
}


bool Glib::MatchInfo::next() (struct MatchInfo * const this)
{
  struct GMatchInfo * D.87928;
  int D.87929;
  struct GError * gerror.28;
  bool D.87933;
  struct GError * gerror;
  bool retvalue;

  try
    {
      gerror = 0B;
      D.87928 = Glib::MatchInfo::gobj (this);
      D.87929 = g_match_info_next (D.87928, &gerror);
      retvalue = D.87929 != 0;
      gerror.28 = gerror;
      if (gerror.28 != 0B) goto <D.87931>; else goto <D.87932>;
      <D.87931>:
      gerror.28 = gerror;
      Glib::Error::throw_exception (gerror.28);
      <D.87932>:
      D.87933 = retvalue;
      return D.87933;
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


int Glib::MatchInfo::get_match_count() const (const struct MatchInfo * const this)
{
  int D.87938;
  const struct GMatchInfo * D.87939;

  D.87939 = Glib::MatchInfo::gobj (this);
  D.87938 = g_match_info_get_match_count (D.87939);
  return D.87938;
}


bool Glib::MatchInfo::is_partial_match() const (const struct MatchInfo * const this)
{
  bool D.87942;
  const struct GMatchInfo * D.87943;
  int D.87944;

  D.87943 = Glib::MatchInfo::gobj (this);
  D.87944 = g_match_info_is_partial_match (D.87943);
  D.87942 = D.87944 != 0;
  return D.87942;
}


Glib::ustring Glib::MatchInfo::expand_references(const Glib::ustring&) (struct MatchInfo * const this, const struct ustring & string_to_expand)
{
  const char * D.87948;
  struct GMatchInfo * D.87949;
  gchar * D.87950;
  struct GError * gerror.29;
  struct GError * gerror;
  struct ustring retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.87948 = Glib::ustring::c_str (string_to_expand);
      D.87949 = Glib::MatchInfo::gobj (this);
      D.87950 = g_match_info_expand_references (D.87949, D.87948, &gerror);
      *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87950); [return slot optimization]
      try
        {
          gerror.29 = gerror;
          if (gerror.29 != 0B) goto <D.87952>; else goto <D.87953>;
          <D.87952>:
          gerror.29 = gerror;
          Glib::Error::throw_exception (gerror.29);
          <D.87953>:
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::ustring Glib::MatchInfo::fetch(int) (struct MatchInfo * const this, int match_num)
{
  struct GMatchInfo * D.87961;
  gchar * D.87962;

  D.87961 = Glib::MatchInfo::gobj (this);
  D.87962 = g_match_info_fetch (D.87961, match_num);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87962); [return slot optimization]
  return <retval>;
}


bool Glib::MatchInfo::fetch_pos(int, int&, int&) (struct MatchInfo * const this, int match_num, int & start_pos, int & end_pos)
{
  bool D.87965;
  struct GMatchInfo * D.87966;
  int D.87967;

  D.87966 = Glib::MatchInfo::gobj (this);
  D.87967 = g_match_info_fetch_pos (D.87966, match_num, start_pos, end_pos);
  D.87965 = D.87967 != 0;
  return D.87965;
}


Glib::ustring Glib::MatchInfo::fetch_named(const Glib::ustring&) (struct MatchInfo * const this, const struct ustring & name)
{
  const char * D.87971;
  struct GMatchInfo * D.87972;
  gchar * D.87973;

  D.87971 = Glib::ustring::c_str (name);
  D.87972 = Glib::MatchInfo::gobj (this);
  D.87973 = g_match_info_fetch_named (D.87972, D.87971);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.87973); [return slot optimization]
  return <retval>;
}


bool Glib::MatchInfo::fetch_named_pos(const Glib::ustring&, int&, int&) (struct MatchInfo * const this, const struct ustring & name, int & start_pos, int & end_pos)
{
  bool D.87977;
  const char * D.87978;
  struct GMatchInfo * D.87979;
  int D.87980;

  D.87978 = Glib::ustring::c_str (name);
  D.87979 = Glib::MatchInfo::gobj (this);
  D.87980 = g_match_info_fetch_named_pos (D.87979, D.87978, start_pos, end_pos);
  D.87977 = D.87980 != 0;
  return D.87977;
}


Glib::StringArrayHandle Glib::MatchInfo::fetch_all() (struct MatchInfo * const this)
{
  struct GMatchInfo * D.87985;
  gchar * * D.87986;

  D.87985 = Glib::MatchInfo::gobj (this);
  D.87986 = g_match_info_fetch_all (D.87985);
  Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.87986, 2);
  return <retval>;
}