Glib::ustring Glib::Markup::escape_text(const Glib::ustring&) (const struct ustring & text)
{
  long unsigned int D.88704;
  long int D.88705;
  const char * D.88706;
  gchar * D.88707;
  char * D.88708;
  const struct ScopedPtr buf;

  try
    {
      D.88704 = Glib::ustring::bytes (text);
      D.88705 = (long int) D.88704;
      D.88706 = Glib::ustring::data (text);
      D.88707 = g_markup_escape_text (D.88706, D.88705);
      Glib::ScopedPtr<char>::ScopedPtr (&buf, D.88707);
      try
        {
          D.88708 = Glib::ScopedPtr<char>::get (&buf);
          Glib::ustring::ustring (<retval>, D.88708);
          return <retval>;
        }
      finally
        {
          Glib::ScopedPtr<char>::~ScopedPtr (&buf);
        }
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

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


bool Glib::Markup::AttributeKeyLess::operator()(const Glib::ustring&, const Glib::ustring&) const (const struct AttributeKeyLess * const this, const struct ustring & lhs, const struct ustring & rhs)
{
  bool D.88722;
  const struct string & D.88723;
  const struct string & D.88724;

  D.88723 = Glib::ustring::raw (rhs);
  D.88724 = Glib::ustring::raw (lhs);
  D.88722 = std::operator< <char, std::char_traits<char>, std::allocator<char> > (D.88724, D.88723);
  return D.88722;
}


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

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


bool std::operator<(const std::basic_string<_CharT, _Traits, _Alloc>&, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string & __lhs, const struct basic_string & __rhs)
{
  bool D.88729;
  int D.88730;

  D.88730 = std::basic_string<char>::compare (__lhs, __rhs);
  D.88729 = D.88730 < 0;
  return D.88729;
}


int std::basic_string<_CharT, _Traits, _Alloc>::compare(const std::basic_string<_CharT, _Traits, _Alloc>&) const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this, const struct basic_string & __str)
{
  long unsigned int __size.0;
  long unsigned int __osize.1;
  const long unsigned int & D.88735;
  const char * D.88736;
  char * D.88737;
  long unsigned int __osize.2;
  long unsigned int __size.3;
  int D.88743;
  const size_type __size;
  const size_type __osize;
  const size_type __len;
  int __r;

  try
    {
      __size.0 = std::basic_string<char>::size (this);
      __size = __size.0;
      __osize.1 = std::basic_string<char>::size (__str);
      __osize = __osize.1;
      D.88735 = std::min<long unsigned int> (&__size, &__osize);
      __len = *D.88735;
      D.88736 = std::basic_string<char>::data (__str);
      D.88737 = std::basic_string<char>::_M_data (this);
      __r = std::char_traits<char>::compare (D.88737, D.88736, __len);
      if (__r == 0) goto <D.88738>; else goto <D.88739>;
      <D.88738>:
      __osize.2 = __osize;
      __size.3 = __size;
      __r = std::basic_string<char>::_S_compare (__size.3, __osize.2);
      goto <D.88742>;
      <D.88739>:
      <D.88742>:
      D.88743 = __r;
      return D.88743;
    }
  finally
    {
      __size = {CLOBBER};
      __osize = {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.88752;
  struct _Rep * D.88753;

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


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.88756;
  char * D.88757;

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


const _Tp& std::min(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.88760;
  long unsigned int D.88761;
  const long unsigned int & D.88764;

  D.88760 = *__b;
  D.88761 = *__a;
  if (D.88760 < D.88761) goto <D.88762>; else goto <D.88763>;
  <D.88762>:
  D.88764 = __b;
  return D.88764;
  <D.88763>:
  D.88764 = __a;
  return D.88764;
}


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

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


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

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


static int std::char_traits<char>::compare(const char_type*, const char_type*, std::size_t) (const char_type * __s1, const char_type * __s2, size_t __n)
{
  int D.88771;

  D.88771 = __builtin_memcmp (__s1, __s2, __n);
  return D.88771;
}


static int std::basic_string<_CharT, _Traits, _Alloc>::_S_compare(std::basic_string<_CharT, _Traits, _Alloc>::size_type, std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (size_type __n1, size_type __n2)
{
  long unsigned int D.88773;
  int D.88776;
  const difference_type __d;

  D.88773 = __n1 - __n2;
  __d = (const difference_type) D.88773;
  if (__d > 2147483647) goto <D.88774>; else goto <D.88775>;
  <D.88774>:
  D.88776 = 2147483647;
  return D.88776;
  <D.88775>:
  if (__d < -2147483648) goto <D.88777>; else goto <D.88778>;
  <D.88777>:
  D.88776 = -2147483648;
  return D.88776;
  <D.88778>:
  D.88776 = (int) __d;
  return D.88776;
}


static void Glib::Markup::ParserCallbacks::start_element(GMarkupParseContext*, const char*, const char**, const char**, void*, GError**) (struct GMarkupParseContext * context, const char * element_name, const char * * attribute_names, const char * * attribute_values, void * user_data, struct GError * * error)
{
  bool retval.4;
  int retval.5;
  bool retval.6;
  struct GMarkupParseContext * D.88783;
  long int D.88787;
  long int D.88788;
  bool D.88792;
  bool D.88793;
  bool D.88794;
  struct pair D.87174;
  struct value_type D.87058;
  const struct ustring D.87057;
  const char * D.88797;
  const struct ustring D.87056;
  const char * D.88798;
  bool retval.7;
  int retval.8;
  long int D.88806;
  long int D.88807;
  struct Parser * D.88812;
  int (*__vtbl_ptr_type) () * D.88813;
  int (*__vtbl_ptr_type) () * D.88814;
  int (*__vtbl_ptr_type) () D.88815;
  const struct ustring D.87176;
  register struct MarkupError * err.9;
  void * D.88816;
  struct Error * D.88817;
  void * D.88818;
  struct ParseContext & cpp_context;
  static const char __PRETTY_FUNCTION__[137] = "static void Glib::Markup::ParserCallbacks::start_element(GMarkupParseContext*, const char*, const char**, const char**, void*, GError**)";

  cpp_context = user_data;
  {
    {
      {
        int _g_boolean_var_;

        D.88783 = Glib::Markup::ParseContext::gobj (cpp_context);
        retval.6 = D.88783 == context;
        if (retval.6 != 0) goto <D.88784>; else goto <D.88785>;
        <D.88784>:
        _g_boolean_var_ = 1;
        goto <D.88786>;
        <D.88785>:
        _g_boolean_var_ = 0;
        <D.88786>:
        retval.5 = _g_boolean_var_;
      }
      D.88787 = (long int) retval.5;
      D.88788 = __builtin_expect (D.88787, 1);
      retval.4 = D.88788 != 0;
      if (retval.4 != 0) goto <D.88789>; else goto <D.88790>;
      <D.88789>:
      goto <D.88791>;
      <D.88790>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "context == cpp_context.gobj()");
      return;
      <D.88791>:
    }
  }
  try
    {
      {
        struct AttributeMap attributes;

        try
          {
            std::map<Glib::ustring, Glib::ustring, Glib::Markup::AttributeKeyLess>::map (&attributes);
            try
              {
                {
                  D.88792 = attribute_names != 0B;
                  D.88793 = attribute_values != 0B;
                  D.88794 = D.88792 & D.88793;
                  if (D.88794 != 0) goto <D.88795>; else goto <D.88796>;
                  <D.88795>:
                  {
                    const char * const * pname;
                    const char * const * pvalue;

                    pname = attribute_names;
                    pvalue = attribute_values;
                    goto <D.87184>;
                    <D.87183>:
                    D.88797 = *pvalue;
                    Glib::ustring::ustring (&D.87057, D.88797);
                    try
                      {
                        D.88798 = *pname;
                        Glib::ustring::ustring (&D.87056, D.88798);
                        try
                          {
                            std::pair<const Glib::ustring, Glib::ustring>::pair (&D.87058, &D.87056, &D.87057);
                            try
                              {
                                D.87174 = std::map<Glib::ustring, Glib::ustring, Glib::Markup::AttributeKeyLess>::insert (&attributes, &D.87058);
                              }
                            finally
                              {
                                std::pair<const Glib::ustring, Glib::ustring>::~pair (&D.87058);
                                D.87058 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            Glib::ustring::~ustring (&D.87056);
                            D.87056 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        Glib::ustring::~ustring (&D.87057);
                        D.87057 = {CLOBBER};
                      }
                    pname = pname + 8;
                    pvalue = pvalue + 8;
                    <D.87184>:
                    D.88798 = *pname;
                    if (D.88798 != 0B) goto <D.88799>; else goto <D.87181>;
                    <D.88799>:
                    D.88797 = *pvalue;
                    if (D.88797 != 0B) goto <D.87183>; else goto <D.87181>;
                    <D.87181>:
                    {
                      {
                        {
                          int _g_boolean_var_;

                          D.88798 = *pname;
                          if (D.88798 == 0B) goto <D.88804>; else goto <D.88802>;
                          <D.88804>:
                          D.88797 = *pvalue;
                          if (D.88797 == 0B) goto <D.88805>; else goto <D.88802>;
                          <D.88805>:
                          _g_boolean_var_ = 1;
                          goto <D.88803>;
                          <D.88802>:
                          _g_boolean_var_ = 0;
                          <D.88803>:
                          retval.8 = _g_boolean_var_;
                        }
                        D.88806 = (long int) retval.8;
                        D.88807 = __builtin_expect (D.88806, 1);
                        retval.7 = D.88807 != 0;
                        if (retval.7 != 0) goto <D.88808>; else goto <D.88809>;
                        <D.88808>:
                        goto <D.88810>;
                        <D.88809>:
                        g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "*pname == 0 && *pvalue == 0");
                        return;
                        <D.88810>:
                      }
                    }
                  }
                  goto <D.88811>;
                  <D.88796>:
                  <D.88811>:
                }
                D.88812 = Glib::Markup::ParseContext::get_parser (cpp_context);
                D.88813 = D.88812->_vptr.Parser;
                D.88814 = D.88813 + 16;
                D.88815 = *D.88814;
                Glib::ustring::ustring (&D.87176, element_name);
                try
                  {
                    OBJ_TYPE_REF(D.88815;(struct Parser)D.88812->2) (D.88812, cpp_context, &D.87176, &attributes);
                  }
                finally
                  {
                    Glib::ustring::~ustring (&D.87176);
                    D.87176 = {CLOBBER};
                  }
              }
            finally
              {
                std::map<Glib::ustring, Glib::ustring, Glib::Markup::AttributeKeyLess>::~map (&attributes);
              }
          }
        finally
          {
            attributes = {CLOBBER};
          }
      }
    }
  catch
    {
      catch (struct MarkupError)
        {
          {
            struct MarkupError & err;

            try
              {
                D.88816 = __builtin_eh_pointer (0);
                err.9 = __cxa_begin_catch (D.88816);
                err = err.9;
                D.88817 = &err->D.80065;
                Glib::Error::propagate (D.88817, error);
              }
            finally
              {
                __cxa_end_catch ();
              }
          }
        }
      catch (NULL)
        {
          try
            {
              D.88818 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.88818);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


GMarkupParseContext* Glib::Markup::ParseContext::gobj() (struct ParseContext * const this)
{
  struct GMarkupParseContext * D.88835;

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


std::map<_Key, _Tp, _Compare, _Alloc>::map() [with _Key = Glib::ustring; _Tp = Glib::ustring; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct map * const this)
{
  struct _Rep_type * D.88837;

  D.88837 = &this->_M_t;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree (D.88837);
  try
    {

    }
  catch
    {
      D.88837 = &this->_M_t;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::~_Rb_tree (D.88837);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_impl * D.88838;

  D.88838 = &this->_M_impl;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree_impl<Glib::Markup::AttributeKeyLess, true>::_Rb_tree_impl (D.88838);
  try
    {

    }
  catch
    {
      D.88838 = &this->_M_impl;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree_impl<Glib::Markup::AttributeKeyLess, true>::~_Rb_tree_impl (D.88838);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_Rb_tree_impl() [with _Key_compare = Glib::Markup::AttributeKeyLess; bool _Is_pod_comparator = true; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree_impl * const this)
{
  std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::allocator (this);
  try
    {
      this->_M_header._M_color = 0;
      this->_M_header._M_parent = 0B;
      this->_M_header._M_left = 0B;
      this->_M_header._M_right = 0B;
      this->_M_node_count = 0;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree_impl<Glib::Markup::AttributeKeyLess, true>::_M_initialize (this);
    }
  catch
    {
      std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >] (struct allocator * const this)
{
  void * D.88839;

  try
    {
      {
        __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.88839 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.88839);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >] (struct new_allocator * const this)
{
  void * D.88840;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.88840 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.88840);
          
        }
    }
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_M_initialize() [with _Key_compare = Glib::Markup::AttributeKeyLess; bool _Is_pod_comparator = true; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree_impl * const this)
{
  struct _Rb_tree_node_base * D.88841;

  this->_M_header._M_color = 0;
  this->_M_header._M_parent = 0B;
  D.88841 = &this->_M_header;
  this->_M_header._M_left = D.88841;
  D.88841 = &this->_M_header;
  this->_M_header._M_right = D.88841;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = const Glib::ustring; _T2 = Glib::ustring] (struct pair * const this, const struct ustring & __a, const struct ustring & __b)
{
  const struct ustring * D.88842;
  struct ustring * D.88843;

  D.88842 = &this->first;
  Glib::ustring::ustring (D.88842, __a);
  try
    {
      D.88843 = &this->second;
      Glib::ustring::ustring (D.88843, __b);
      try
        {

        }
      catch
        {
          D.88843 = &this->second;
          Glib::ustring::~ustring (D.88843);
        }
    }
  catch
    {
      D.88842 = &this->first;
      Glib::ustring::~ustring (D.88842);
    }
}


std::pair<typename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, typename __gnu_cxx::__alloc_traits<_Allocator>::rebind<std::pair<const _Key, _Tp> >::other>::iterator, bool> std::map<_Key, _Tp, _Compare, _Alloc>::insert(const value_type&) [with _Key = Glib::ustring; _Tp = Glib::ustring; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; typename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, typename __gnu_cxx::__alloc_traits<_Allocator>::rebind<std::pair<const _Key, _Tp> >::other>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >; std::map<_Key, _Tp, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::ustring>] (struct map * const this, const struct value_type & __x)
{
  struct pair D.88845;
  struct _Rep_type * D.88846;

  D.88846 = &this->_M_t;
  D.88845 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_insert_unique (D.88846, __x);
  return D.88845;
}


std::pair<std::_Rb_tree_iterator<_Val>, bool> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_unique(const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree * const this, const struct pair & __v)
{
  struct _Select1st D.88040;
  const struct first_type & D.88848;
  struct _Rb_tree_node_base * D.88849;
  struct pair D.88852;
  struct _Res D.88062;
  const bool D.88061;
  struct iterator D.88060;
  struct _Rb_tree_node_base * D.88853;
  struct _Res D.88074;
  const bool D.88073;
  struct iterator D.88072;
  typedef struct _Res _Res;
  struct pair __res;

  try
    {
      try
        {
          D.88848 = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >::operator() (&D.88040, __v);
          __res = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_get_insert_unique_pos (this, D.88848);
        }
      finally
        {
          D.88040 = {CLOBBER};
        }
      D.88849 = __res.second;
      if (D.88849 != 0B) goto <D.88850>; else goto <D.88851>;
      <D.88850>:
      D.88061 = 1;
      try
        {
          D.88849 = __res.second;
          D.88853 = __res.first;
          D.88060 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_insert_ (this, D.88853, D.88849, __v);
          try
            {
              std::pair<std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >, bool>::pair (&D.88062, &D.88060, &D.88061);
              try
                {
                  D.88852 = D.88062;
                  return D.88852;
                }
              finally
                {
                  D.88062 = {CLOBBER};
                }
            }
          finally
            {
              D.88060 = {CLOBBER};
            }
        }
      finally
        {
          D.88061 = {CLOBBER};
        }
      <D.88851>:
      D.88073 = 0;
      try
        {
          D.88853 = __res.first;
          std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::_Rb_tree_iterator (&D.88072, D.88853);
          try
            {
              std::pair<std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >, bool>::pair (&D.88074, &D.88072, &D.88073);
              try
                {
                  D.88852 = D.88074;
                  return D.88852;
                }
              finally
                {
                  D.88074 = {CLOBBER};
                }
            }
          finally
            {
              D.88072 = {CLOBBER};
            }
        }
      finally
        {
          D.88073 = {CLOBBER};
        }
    }
  finally
    {
      __res = {CLOBBER};
    }
}


const typename _Pair::first_type& std::_Select1st<_Pair>::operator()(const _Pair&) const [with _Pair = std::pair<const Glib::ustring, Glib::ustring>; typename _Pair::first_type = const Glib::ustring] (const struct _Select1st * const this, const struct pair & __x)
{
  const struct first_type & D.88865;

  D.88865 = &__x->first;
  return D.88865;
}


std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_unique_pos(const key_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = Glib::ustring] (struct _Rb_tree * const this, const struct key_type & __k)
{
  const struct ustring & D.88867;
  struct AttributeKeyLess * D.88868;
  struct _Rb_tree_node * iftmp.10;
  bool retval.11;
  struct iterator D.88247;
  struct pair D.88878;
  struct _Res D.88250;
  struct _Rb_tree_node_base * const D.88249;
  struct _Rb_tree_node_base * const D.88248;
  bool retval.12;
  struct _Rb_tree_node_base * D.88881;
  const struct ustring & D.88882;
  struct _Res D.88253;
  struct _Rb_tree_node_base * const D.88252;
  struct _Rb_tree_node_base * const D.88251;
  struct _Res D.88255;
  struct _Rb_tree_node_base * const D.88254;
  typedef struct _Res _Res;
  struct _Rb_tree_node * __x;
  struct _Rb_tree_node * __y;
  bool __comp;
  struct iterator __j;

  try
    {
      __x = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_begin (this);
      __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_end (this);
      __comp = 1;
      goto <D.88257>;
      <D.88258>:
      __y = __x;
      D.88867 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_key (__x);
      D.88868 = &this->_M_impl._M_key_compare;
      __comp = Glib::Markup::AttributeKeyLess::operator() (D.88868, __k, D.88867);
      if (__comp != 0) goto <D.88870>; else goto <D.88871>;
      <D.88870>:
      iftmp.10 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_left (__x);
      goto <D.88872>;
      <D.88871>:
      iftmp.10 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_right (__x);
      <D.88872>:
      __x = iftmp.10;
      <D.88257>:
      if (__x != 0B) goto <D.88258>; else goto <D.88256>;
      <D.88256>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::_Rb_tree_iterator (&__j, __y);
      if (__comp != 0) goto <D.88873>; else goto <D.88874>;
      <D.88873>:
      D.88247 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::begin (this);
      try
        {
          retval.11 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::operator== (&__j, &D.88247);
        }
      finally
        {
          D.88247 = {CLOBBER};
        }
      if (retval.11 != 0) goto <D.88876>; else goto <D.88877>;
      <D.88876>:
      D.88249 = __y;
      try
        {
          D.88248 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.88250, &D.88248, &D.88249);
              try
                {
                  D.88878 = D.88250;
                  return D.88878;
                }
              finally
                {
                  D.88250 = {CLOBBER};
                }
            }
          finally
            {
              D.88248 = {CLOBBER};
            }
        }
      finally
        {
          D.88249 = {CLOBBER};
        }
      <D.88877>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::operator-- (&__j);
      goto <D.88879>;
      <D.88874>:
      <D.88879>:
      D.88881 = __j._M_node;
      D.88882 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_key (D.88881);
      D.88868 = &this->_M_impl._M_key_compare;
      retval.12 = Glib::Markup::AttributeKeyLess::operator() (D.88868, D.88882, __k);
      if (retval.12 != 0) goto <D.88883>; else goto <D.88884>;
      <D.88883>:
      D.88252 = __y;
      try
        {
          D.88251 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.88253, &D.88251, &D.88252);
              try
                {
                  D.88878 = D.88253;
                  return D.88878;
                }
              finally
                {
                  D.88253 = {CLOBBER};
                }
            }
          finally
            {
              D.88251 = {CLOBBER};
            }
        }
      finally
        {
          D.88252 = {CLOBBER};
        }
      <D.88884>:
      D.88254 = 0B;
      try
        {
          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.88255, &__j._M_node, &D.88254);
          try
            {
              D.88878 = D.88255;
              return D.88878;
            }
          finally
            {
              D.88255 = {CLOBBER};
            }
        }
      finally
        {
          D.88254 = {CLOBBER};
        }
    }
  finally
    {
      __j = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.88900;

  D.88900 = this->_M_impl._M_header._M_parent;
  return D.88900;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_end() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.88902;

  D.88902 = &this->_M_impl._M_header;
  return D.88902;
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (const struct _Rb_tree_node * __x)
{
  const struct ustring & D.88904;
  const struct value_type & D.88905;
  struct _Select1st D.88437;

  D.88905 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_value (__x);
  try
    {
      D.88904 = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >::operator() (&D.88437, D.88905);
      return D.88904;
    }
  finally
    {
      D.88437 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, Glib::ustring>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::ustring>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (const struct _Rb_tree_node * __x)
{
  const struct value_type & D.88909;

  D.88909 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >::_M_valptr (__x);
  return D.88909;
}


const _Val* std::_Rb_tree_node<_Val>::_M_valptr() const [with _Val = std::pair<const Glib::ustring, Glib::ustring>] (const struct _Rb_tree_node * const this)
{
  const struct pair * D.88912;
  const struct pair * D.88913;

  D.88913 = &this->_M_value_field;
  D.88912 = std::__addressof<const std::pair<const Glib::ustring, Glib::ustring> > (D.88913);
  return D.88912;
}


_Tp* std::__addressof(_Tp&) [with _Tp = const std::pair<const Glib::ustring, Glib::ustring>] (const struct pair & __r)
{
  const struct pair * D.88915;

  D.88915 = __r;
  return D.88915;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_left(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.88917;

  D.88917 = __x->_M_left;
  return D.88917;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_right(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.88919;

  D.88919 = __x->_M_right;
  return D.88919;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree * const this)
{
  struct iterator D.88921;
  struct iterator D.88439;
  struct _Rb_tree_node_base * D.88922;

  D.88922 = this->_M_impl._M_header._M_left;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::_Rb_tree_iterator (&D.88439, D.88922);
  try
    {
      D.88921 = D.88439;
      return D.88921;
    }
  finally
    {
      D.88439 = {CLOBBER};
    }
}


bool std::_Rb_tree_iterator<_Tp>::operator==(const _Self&) const [with _Tp = std::pair<const Glib::ustring, Glib::ustring>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >] (const struct _Rb_tree_iterator * const this, const struct _Self & __x)
{
  bool D.88925;
  struct _Rb_tree_node_base * D.88926;
  struct _Rb_tree_node_base * D.88927;

  D.88926 = this->_M_node;
  D.88927 = __x->_M_node;
  D.88925 = D.88926 == D.88927;
  return D.88925;
}


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator--() [with _Tp = std::pair<const Glib::ustring, Glib::ustring>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.88929;
  struct _Rb_tree_node_base * D.88930;
  struct _Self & D.88931;

  D.88929 = this->_M_node;
  D.88930 = std::_Rb_tree_decrement (D.88929);
  this->_M_node = D.88930;
  D.88931 = this;
  return D.88931;
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct ustring & D.88933;
  const struct value_type & D.88934;
  struct _Select1st D.88446;

  D.88934 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_value (__x);
  try
    {
      D.88933 = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >::operator() (&D.88446, D.88934);
      return D.88933;
    }
  finally
    {
      D.88446 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, Glib::ustring>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::ustring>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct value_type & D.88938;

  D.88938 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >::_M_valptr (__x);
  return D.88938;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = std::_Rb_tree_node_base*; _T2 = std::_Rb_tree_node_base*] (struct pair * const this, struct _Rb_tree_node_base * const & __a, struct _Rb_tree_node_base * const & __b)
{
  struct _Rb_tree_node_base * D.88941;
  struct _Rb_tree_node_base * D.88942;

  D.88941 = *__a;
  this->first = D.88941;
  D.88942 = *__b;
  this->second = D.88942;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree * const this, struct _Rb_tree_node_base * __x, struct _Rb_tree_node_base * __p, const struct pair & __v)
{
  bool iftmp.13;
  struct _Rb_tree_node * D.88948;
  const struct ustring & D.88950;
  struct _Select1st D.88262;
  bool cleanup.14;
  const struct first_type & D.88954;
  struct AttributeKeyLess * D.88955;
  bool D.88956;
  struct _Rb_tree_node_base * D.88957;
  int D.88958;
  long unsigned int D.88959;
  long unsigned int D.88960;
  struct iterator D.88961;
  struct iterator D.88264;
  bool __insert_left;
  struct _Rb_tree_node * __z;

  cleanup.14 = 0;
  try
    {
      if (__x != 0B) goto <D.88944>; else goto <D.88947>;
      <D.88947>:
      D.88948 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_end (this);
      if (D.88948 == __p) goto <D.88944>; else goto <D.88949>;
      <D.88949>:
      D.88950 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_key (__p);
      cleanup.14 = 1;
      D.88954 = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >::operator() (&D.88262, __v);
      D.88955 = &this->_M_impl._M_key_compare;
      D.88956 = Glib::Markup::AttributeKeyLess::operator() (D.88955, D.88954, D.88950);
      if (D.88956 != 0) goto <D.88944>; else goto <D.88945>;
      <D.88944>:
      iftmp.13 = 1;
      goto <D.88946>;
      <D.88945>:
      iftmp.13 = 0;
      <D.88946>:
      __insert_left = iftmp.13;
    }
  finally
    {
      if (cleanup.14 != 0) goto <D.88952>; else goto <D.88953>;
      <D.88952>:
      D.88262 = {CLOBBER};
      <D.88953>:
    }
  __z = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_create_node (this, __v);
  D.88957 = &this->_M_impl._M_header;
  D.88958 = (int) __insert_left;
  std::_Rb_tree_insert_and_rebalance (D.88958, __z, __p, D.88957);
  D.88959 = this->_M_impl._M_node_count;
  D.88960 = D.88959 + 1;
  this->_M_impl._M_node_count = D.88960;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >::_Rb_tree_iterator (&D.88264, __z);
  try
    {
      D.88961 = D.88264;
      return D.88961;
    }
  finally
    {
      D.88264 = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_create_node(const value_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::ustring>] (struct _Rb_tree * const this, const struct value_type & __x)
{
  struct pair * D.88970;
  struct allocator_type D.88449;
  void * D.88971;
  struct _Rb_tree_node * D.88972;
  struct _Rb_tree_node * __tmp;

  __tmp = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_get_node (this);
  try
    {
      D.88970 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >::_M_valptr (__tmp);
      D.88449 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::get_allocator (this); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::ustring> >::construct (&D.88449, D.88970, __x);
        }
      finally
        {
          std::allocator<std::pair<const Glib::ustring, Glib::ustring> >::~allocator (&D.88449);
          D.88449 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.88971 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.88971);
              std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_put_node (this, __tmp);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.88972 = __tmp;
  return D.88972;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_node() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.88980;
  struct _Node_allocator & D.88981;

  D.88981 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_get_Node_allocator (this);
  D.88980 = __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > > >::allocate (D.88981, 1);
  return D.88980;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >] (struct _Rb_tree * const this)
{
  struct _Node_allocator & D.88984;

  D.88984 = &this->_M_impl;
  return D.88984;
}


static __gnu_cxx::__alloc_traits<_Alloc>::pointer __gnu_cxx::__alloc_traits<_Alloc>::allocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct _Rb_tree_node * D.88986;

  D.88986 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::allocate (__a, __n, 0B);
  return D.88986;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.86302)
{
  bool retval.15;
  long unsigned int D.88990;
  struct _Rb_tree_node * D.88993;
  long unsigned int D.88994;

  D.88990 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::max_size (this);
  retval.15 = D.88990 < __n;
  if (retval.15 != 0) goto <D.88991>; else goto <D.88992>;
  <D.88991>:
  std::__throw_bad_alloc ();
  <D.88992>:
  D.88994 = __n * 48;
  D.88993 = operator new (D.88994);
  return D.88993;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.88997;
  void * D.88998;

  try
    {
      D.88997 = 384307168202282325;
      return D.88997;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.88998 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.88998);
          
        }
    }
}


_Val* std::_Rb_tree_node<_Val>::_M_valptr() [with _Val = std::pair<const Glib::ustring, Glib::ustring>] (struct _Rb_tree_node * const this)
{
  struct pair * D.89000;
  struct pair * D.89001;

  D.89001 = &this->_M_value_field;
  D.89000 = std::__addressof<std::pair<const Glib::ustring, Glib::ustring> > (D.89001);
  return D.89000;
}


_Tp* std::__addressof(_Tp&) [with _Tp = std::pair<const Glib::ustring, Glib::ustring>] (struct pair & __r)
{
  struct pair * D.89003;

  D.89003 = __r;
  return D.89003;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::get_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.89006;

  D.89006 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_get_Node_allocator (this);
  std::allocator<std::pair<const Glib::ustring, Glib::ustring> >::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > > (<retval>, D.89006);
  return <retval>;
}


const _Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.89008;

  D.89008 = &this->_M_impl;
  return D.89008;
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator<_Tp1>&) [with _Tp1 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >; _Tp = std::pair<const Glib::ustring, Glib::ustring>] (struct allocator * const this, const struct allocator & D.88368)
{
  void * D.89010;

  try
    {
      {
        __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::ustring> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::ustring> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89010 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89010);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::pair<const Glib::ustring, Glib::ustring>] (struct new_allocator * const this)
{
  void * D.89011;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89011 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89011);
          
        }
    }
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = std::pair<const Glib::ustring, Glib::ustring>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ustring, Glib::ustring>*] (struct new_allocator * const this, struct pair * __p, const struct pair & __val)
{
  void * D.88552;
  void * D.88553;
  struct pair * iftmp.16;

  D.88552 = __p;
  D.88553 = operator new (16, D.88552);
  if (D.88553 != 0B) goto <D.89013>; else goto <D.89014>;
  <D.89013>:
  try
    {
      std::pair<const Glib::ustring, Glib::ustring>::pair (D.88553, __val);
    }
  catch
    {
      operator delete (D.88553, D.88552);
    }
  iftmp.16 = D.88553;
  goto <D.89015>;
  <D.89014>:
  iftmp.16 = D.88553;
  <D.89015>:
}


void* operator new(std::size_t, void*) (size_t D.14707, void * __p)
{
  void * D.89017;
  void * D.89018;

  try
    {
      D.89017 = __p;
      return D.89017;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89018 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89018);
          
        }
    }
}


std::pair<const Glib::ustring, Glib::ustring>::pair(const std::pair<const Glib::ustring, Glib::ustring>&) (struct pair * const this, const struct pair & D.87055)
{
  const struct ustring * D.89020;
  const struct ustring * D.89021;
  const struct ustring * D.89022;
  struct ustring * D.89023;

  D.89020 = &D.87055->first;
  D.89021 = &this->first;
  Glib::ustring::ustring (D.89021, D.89020);
  try
    {
      D.89022 = &D.87055->second;
      D.89023 = &this->second;
      Glib::ustring::ustring (D.89023, D.89022);
      try
        {

        }
      catch
        {
          D.89023 = &this->second;
          Glib::ustring::~ustring (D.89023);
        }
    }
  catch
    {
      D.89021 = &this->first;
      Glib::ustring::~ustring (D.89021);
    }
}


void operator delete(void*, void*) (void * D.14715, void * D.14716)
{
  void * D.89025;

  try
    {

    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89025 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89025);
          
        }
    }
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = std::pair<const Glib::ustring, Glib::ustring>] (struct allocator * const this)
{
  void * D.89026;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::ustring> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.88383>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89026 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89026);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::pair<const Glib::ustring, Glib::ustring>] (struct new_allocator * const this)
{
  void * D.89027;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.88542>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89027 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89027);
          
        }
    }
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_put_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct _Node_allocator & D.89028;

  D.89028 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_get_Node_allocator (this);
  __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > > >::deallocate (D.89028, __p, 1);
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct _Rb_tree_node * __p, size_type __n)
{
  __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::deallocate (__a, __p, __n);
}


void __gnu_cxx::new_allocator<_Tp>::deallocate(__gnu_cxx::new_allocator<_Tp>::pointer, __gnu_cxx::new_allocator<_Tp>::size_type) [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _Rb_tree_node * __p, size_type D.86306)
{
  operator delete (__p);
}


std::_Rb_tree_iterator<_Tp>::_Rb_tree_iterator(std::_Rb_tree_iterator<_Tp>::_Link_type) [with _Tp = std::pair<const Glib::ustring, Glib::ustring>; std::_Rb_tree_iterator<_Tp>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree_iterator * const this, struct _Rb_tree_node * __x)
{
  this->_M_node = __x;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::ustring> >; _T2 = bool] (struct pair * const this, const struct _Rb_tree_iterator & __a, const bool & __b)
{
  bool D.89029;

  this->first = *__a;
  D.89029 = *__b;
  this->second = D.89029;
}


Glib::Markup::Parser* Glib::Markup::ParseContext::get_parser() (struct ParseContext * const this)
{
  struct Parser * D.89030;

  D.89030 = this->parser_;
  return D.89030;
}


std::pair<const Glib::ustring, Glib::ustring>::~pair() (struct pair * const this)
{
  struct ustring * D.89032;
  const struct ustring * D.89033;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.89032 = &this->second;
                Glib::ustring::~ustring (D.89032);
              }
          }
        finally
          {
            D.89033 = &this->first;
            Glib::ustring::~ustring (D.89033);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87072>:
}


std::map<Glib::ustring, Glib::ustring, Glib::Markup::AttributeKeyLess>::~map() (struct map * const this)
{
  struct _Rep_type * D.89036;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.89036 = &this->_M_t;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::~_Rb_tree (D.89036);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86989>:
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::~_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.89038;
  struct _Rb_tree_impl * D.89039;

  {
    try
      {
        try
          {
            D.89038 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_begin (this);
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_erase (this, D.89038);
          }
        finally
          {
            D.89039 = &this->_M_impl;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree_impl<Glib::Markup::AttributeKeyLess, true>::~_Rb_tree_impl (D.89039);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87777>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __x)
{
  struct _Rb_tree_node * D.89042;

  goto <D.88022>;
  <D.88023>:
  {
    struct _Rb_tree_node * __y;

    D.89042 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_right (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_erase (this, D.89042);
    __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_S_left (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_destroy_node (this, __x);
    __x = __y;
  }
  <D.88022>:
  if (__x != 0B) goto <D.88023>; else goto <D.88021>;
  <D.88021>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_destroy_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::ustring>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >; _Compare = Glib::Markup::AttributeKeyLess; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::ustring> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct pair * D.89043;
  struct allocator_type D.88239;

  D.89043 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >::_M_valptr (__p);
  D.88239 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::get_allocator (this); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::ustring> >::destroy (&D.88239, D.89043);
    }
  finally
    {
      std::allocator<std::pair<const Glib::ustring, Glib::ustring> >::~allocator (&D.88239);
      D.88239 = {CLOBBER};
    }
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_M_put_node (this, __p);
}


void __gnu_cxx::new_allocator<_Tp>::destroy(__gnu_cxx::new_allocator<_Tp>::pointer) [with _Tp = std::pair<const Glib::ustring, Glib::ustring>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ustring, Glib::ustring>*] (struct new_allocator * const this, struct pair * __p)
{
  std::pair<const Glib::ustring, Glib::ustring>::~pair (__p);
}


std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::ustring>, std::_Select1st<std::pair<const Glib::ustring, Glib::ustring> >, Glib::Markup::AttributeKeyLess, std::allocator<std::pair<const Glib::ustring, Glib::ustring> > >::_Rb_tree_impl<Glib::Markup::AttributeKeyLess, true>::~_Rb_tree_impl() (struct _Rb_tree_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87772>:
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >] (struct allocator * const this)
{
  void * D.89046;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> > >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.88006>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89046 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89046);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::ustring> >] (struct new_allocator * const this)
{
  void * D.89047;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.88233>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89047 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89047);
          
        }
    }
}


static void Glib::Markup::ParserCallbacks::end_element(GMarkupParseContext*, const char*, void*, GError**) (struct GMarkupParseContext * context, const char * element_name, void * user_data, struct GError * * error)
{
  bool retval.17;
  int retval.18;
  bool retval.19;
  struct GMarkupParseContext * D.89051;
  long int D.89055;
  long int D.89056;
  struct Parser * D.89060;
  int (*__vtbl_ptr_type) () * D.89061;
  int (*__vtbl_ptr_type) () * D.89062;
  int (*__vtbl_ptr_type) () D.89063;
  const struct ustring D.87197;
  register struct MarkupError * err.20;
  void * D.89064;
  struct Error * D.89065;
  void * D.89066;
  struct ParseContext & cpp_context;
  static const char __PRETTY_FUNCTION__[107] = "static void Glib::Markup::ParserCallbacks::end_element(GMarkupParseContext*, const char*, void*, GError**)";

  cpp_context = user_data;
  {
    {
      {
        int _g_boolean_var_;

        D.89051 = Glib::Markup::ParseContext::gobj (cpp_context);
        retval.19 = D.89051 == context;
        if (retval.19 != 0) goto <D.89052>; else goto <D.89053>;
        <D.89052>:
        _g_boolean_var_ = 1;
        goto <D.89054>;
        <D.89053>:
        _g_boolean_var_ = 0;
        <D.89054>:
        retval.18 = _g_boolean_var_;
      }
      D.89055 = (long int) retval.18;
      D.89056 = __builtin_expect (D.89055, 1);
      retval.17 = D.89056 != 0;
      if (retval.17 != 0) goto <D.89057>; else goto <D.89058>;
      <D.89057>:
      goto <D.89059>;
      <D.89058>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "context == cpp_context.gobj()");
      return;
      <D.89059>:
    }
  }
  try
    {
      D.89060 = Glib::Markup::ParseContext::get_parser (cpp_context);
      D.89061 = D.89060->_vptr.Parser;
      D.89062 = D.89061 + 24;
      D.89063 = *D.89062;
      Glib::ustring::ustring (&D.87197, element_name);
      try
        {
          OBJ_TYPE_REF(D.89063;(struct Parser)D.89060->3) (D.89060, cpp_context, &D.87197);
        }
      finally
        {
          Glib::ustring::~ustring (&D.87197);
          D.87197 = {CLOBBER};
        }
    }
  catch
    {
      catch (struct MarkupError)
        {
          {
            struct MarkupError & err;

            try
              {
                D.89064 = __builtin_eh_pointer (0);
                err.20 = __cxa_begin_catch (D.89064);
                err = err.20;
                D.89065 = &err->D.80065;
                Glib::Error::propagate (D.89065, error);
              }
            finally
              {
                __cxa_end_catch ();
              }
          }
        }
      catch (NULL)
        {
          try
            {
              D.89066 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.89066);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


static void Glib::Markup::ParserCallbacks::text(GMarkupParseContext*, const char*, gsize, void*, GError**) (struct GMarkupParseContext * context, const char * text, gsize text_len, void * user_data, struct GError * * error)
{
  bool retval.21;
  int retval.22;
  bool retval.23;
  struct GMarkupParseContext * D.89077;
  long int D.89081;
  long int D.89082;
  struct Parser * D.89086;
  int (*__vtbl_ptr_type) () * D.89087;
  int (*__vtbl_ptr_type) () * D.89088;
  int (*__vtbl_ptr_type) () D.89089;
  struct ustring D.87225;
  const char * D.89090;
  register struct MarkupError * err.24;
  void * D.89091;
  struct Error * D.89092;
  void * D.89093;
  struct ParseContext & cpp_context;
  static const char __PRETTY_FUNCTION__[107] = "static void Glib::Markup::ParserCallbacks::text(GMarkupParseContext*, const char*, gsize, void*, GError**)";

  cpp_context = user_data;
  {
    {
      {
        int _g_boolean_var_;

        D.89077 = Glib::Markup::ParseContext::gobj (cpp_context);
        retval.23 = D.89077 == context;
        if (retval.23 != 0) goto <D.89078>; else goto <D.89079>;
        <D.89078>:
        _g_boolean_var_ = 1;
        goto <D.89080>;
        <D.89079>:
        _g_boolean_var_ = 0;
        <D.89080>:
        retval.22 = _g_boolean_var_;
      }
      D.89081 = (long int) retval.22;
      D.89082 = __builtin_expect (D.89081, 1);
      retval.21 = D.89082 != 0;
      if (retval.21 != 0) goto <D.89083>; else goto <D.89084>;
      <D.89083>:
      goto <D.89085>;
      <D.89084>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "context == cpp_context.gobj()");
      return;
      <D.89085>:
    }
  }
  try
    {
      D.89086 = Glib::Markup::ParseContext::get_parser (cpp_context);
      D.89087 = D.89086->_vptr.Parser;
      D.89088 = D.89087 + 32;
      D.89089 = *D.89088;
      D.89090 = text + text_len;
      Glib::ustring::ustring<const char*> (&D.87225, text, D.89090);
      try
        {
          OBJ_TYPE_REF(D.89089;(struct Parser)D.89086->4) (D.89086, cpp_context, &D.87225);
        }
      finally
        {
          Glib::ustring::~ustring (&D.87225);
          D.87225 = {CLOBBER};
        }
    }
  catch
    {
      catch (struct MarkupError)
        {
          {
            struct MarkupError & err;

            try
              {
                D.89091 = __builtin_eh_pointer (0);
                err.24 = __cxa_begin_catch (D.89091);
                err = err.24;
                D.89092 = &err->D.80065;
                Glib::Error::propagate (D.89092, error);
              }
            finally
              {
                __cxa_end_catch ();
              }
          }
        }
      catch (NULL)
        {
          try
            {
              D.89093 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.89093);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::ustring::ustring(In, In) [with In = const char*] (struct ustring * const this, const char * pbegin, const char * pend)
{
  struct SequenceToString D.87847;
  struct string * D.89101;

  Glib::ustring::SequenceToString<const char*, char>::SequenceToString (&D.87847, pbegin, pend);
  try
    {
      D.89101 = &this->string_;
      std::basic_string<char>::basic_string (D.89101, &D.87847.D.87818);
    }
  finally
    {
      Glib::ustring::SequenceToString<const char*, char>::~SequenceToString (&D.87847);
      D.87847 = {CLOBBER};
    }
  try
    {

    }
  catch
    {
      D.89101 = &this->string_;
      std::basic_string<char>::~basic_string (D.89101);
    }
}


Glib::ustring::SequenceToString<In, char>::SequenceToString(In, In) [with In = const char*] (struct SequenceToString * const this, const char * pbegin, const char * pend)
{
  struct allocator D.88094;
  struct basic_string * D.89103;

  std::allocator<char>::allocator (&D.88094);
  try
    {
      D.89103 = &this->D.87818;
      std::basic_string<char>::basic_string<const char*> (D.89103, pbegin, pend, &D.88094);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.88094);
      D.88094 = {CLOBBER};
    }
  try
    {

    }
  catch
    {
      D.89103 = &this->D.87818;
      std::basic_string<char>::~basic_string (D.89103);
    }
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = char] (struct allocator * const this)
{
  void * D.89105;

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89105 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89105);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.89106;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89106 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89106);
          
        }
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::basic_string(_InputIterator, _InputIterator, const _Alloc&) [with _InputIterator = const char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, const char * __beg, const char * __end, const struct allocator & __a)
{
  char * D.89107;
  struct _Alloc_hider * D.89108;

  D.89107 = std::basic_string<char>::_S_construct<const char*> (__beg, __end, __a);
  D.89108 = &this->_M_dataplus;
  std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.89108, D.89107, __a);
  try
    {

    }
  catch
    {
      D.89108 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.89108);
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&) [with _InIterator = const char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const char * __beg, const char * __end, const struct allocator & __a)
{
  char * D.89110;
  struct _Integral D.88458;
  struct __false_type D.89111;
  typedef struct _Integral _Integral;

  try
    {
      D.89110 = std::basic_string<char>::_S_construct_aux<const char*> (__beg, __end, __a, D.89111);
      return D.89110;
    }
  finally
    {
      D.88458 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct_aux(_InIterator, _InIterator, const _Alloc&, std::__false_type) [with _InIterator = const char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const char * __beg, const char * __end, const struct allocator & __a, struct __false_type D.88478)
{
  char * D.89116;
  struct forward_iterator_tag D.88594;
  struct _Tag D.88568;
  struct _Tag * D.89117;
  struct forward_iterator_tag D.89118;
  typedef struct _Tag _Tag;

  try
    {
      D.89117 = &D.88568;
      D.89116 = std::basic_string<char>::_S_construct<const char*> (__beg, __end, __a, D.89118);
      return D.89116;
    }
  finally
    {
      D.88568 = {CLOBBER};
    }
}


static _CharT* std::basic_string<_CharT, _Traits, _Alloc>::_S_construct(_InIterator, _InIterator, const _Alloc&, std::forward_iterator_tag) [with _FwdIterator = const char*; _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const char * __beg, const char * __end, const struct allocator & __a, struct forward_iterator_tag D.88573)
{
  bool retval.25;
  bool iftmp.26;
  struct allocator D.88610;
  bool cleanup.27;
  bool D.89131;
  char * D.89135;
  struct _Rep & D.89136;
  bool retval.28;
  bool iftmp.29;
  bool D.89141;
  long int D.89146;
  char * D.89147;
  void * D.89148;
  const size_type __dnew;
  struct _Rep * __r;

  cleanup.27 = 0;
  try
    {
      if (__beg == __end) goto <D.89127>; else goto <D.89125>;
      <D.89127>:
      std::allocator<char>::allocator (&D.88610);
      cleanup.27 = 1;
      D.89131 = std::operator==<char> (__a, &D.88610);
      if (D.89131 != 0) goto <D.89132>; else goto <D.89125>;
      <D.89132>:
      iftmp.26 = 1;
      goto <D.89126>;
      <D.89125>:
      iftmp.26 = 0;
      <D.89126>:
      retval.25 = iftmp.26;
    }
  finally
    {
      if (cleanup.27 != 0) goto <D.89129>; else goto <D.89130>;
      <D.89129>:
      std::allocator<char>::~allocator (&D.88610);
      D.88610 = {CLOBBER};
      <D.89130>:
    }
  if (retval.25 != 0) goto <D.89133>; else goto <D.89134>;
  <D.89133>:
  D.89136 = std::basic_string<char>::_S_empty_rep ();
  D.89135 = std::basic_string<char>::_Rep::_M_refdata (D.89136);
  return D.89135;
  <D.89134>:
  D.89141 = __gnu_cxx::__is_null_pointer<const char> (__beg);
  if (D.89141 != 0) goto <D.89142>; else goto <D.89139>;
  <D.89142>:
  if (__beg != __end) goto <D.89143>; else goto <D.89139>;
  <D.89143>:
  iftmp.29 = 1;
  goto <D.89140>;
  <D.89139>:
  iftmp.29 = 0;
  <D.89140>:
  retval.28 = iftmp.29;
  if (retval.28 != 0) goto <D.89144>; else goto <D.89145>;
  <D.89144>:
  std::__throw_logic_error ("basic_string::_S_construct null not valid");
  <D.89145>:
  D.89146 = std::distance<const char*> (__beg, __end);
  __dnew = (const size_type) D.89146;
  __r = std::basic_string<char>::_Rep::_S_create (__dnew, 0, __a);
  try
    {
      D.89147 = std::basic_string<char>::_Rep::_M_refdata (__r);
      std::basic_string<char>::_S_copy_chars (D.89147, __beg, __end);
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.89148 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.89148);
              std::basic_string<char>::_Rep::_M_destroy (__r, __a);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  std::basic_string<char>::_Rep::_M_set_length_and_sharable (__r, __dnew);
  D.89135 = std::basic_string<char>::_Rep::_M_refdata (__r);
  return D.89135;
}


bool std::operator==(const std::allocator<_CharT>&, const std::allocator<_CharT>&) [with _Tp = char] (const struct allocator & D.88615, const struct allocator & D.88616)
{
  bool D.89156;

  D.89156 = 1;
  return D.89156;
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.89158;

  D.89158 = std::basic_string<char>::_Rep::_S_empty_rep ();
  return D.89158;
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.89161;
  void * __p;

  __p = &_S_empty_rep_storage;
  D.89161 = __p;
  return D.89161;
}


bool __gnu_cxx::__is_null_pointer(_Type*) [with _Type = const char] (const char * __ptr)
{
  bool D.89163;

  D.89163 = __ptr == 0B;
  return D.89163;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = const char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (const char * __first, const char * __last)
{
  difference_type D.89165;
  struct iterator_category D.88652;
  struct random_access_iterator_tag D.89166;
  const char * __first.30;

  std::__iterator_category<const char*> (&__first);
  try
    {
      __first.30 = __first;
      D.89165 = std::__distance<const char*> (__first.30, __last, D.89166);
      return D.89165;
    }
  finally
    {
      D.88652 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = const char*; typename std::iterator_traits<_Iterator>::iterator_category = std::random_access_iterator_tag] (const char * const & D.88651)
{
  struct iterator_category D.89170;

  return D.89170;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_RandomAccessIterator, _RandomAccessIterator, std::random_access_iterator_tag) [with _RandomAccessIterator = const char*; typename std::iterator_traits<_Iterator>::difference_type = long int] (const char * __first, const char * __last, struct random_access_iterator_tag D.88656)
{
  difference_type D.89172;
  long int __last.31;
  long int __first.32;

  __last.31 = (long int) __last;
  __first.32 = (long int) __first;
  D.89172 = __last.31 - __first.32;
  return D.89172;
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_S_copy_chars(_CharT*, const _CharT*, const _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (char * __p, const char * __k1, const char * __k2)
{
  long int __k2.33;
  long int __k1.34;
  long int D.89178;
  long unsigned int D.89179;

  __k2.33 = (long int) __k2;
  __k1.34 = (long int) __k1;
  D.89178 = __k2.33 - __k1.34;
  D.89179 = (long unsigned int) D.89178;
  std::basic_string<char>::_M_copy (__p, __k1, D.89179);
}


static void std::basic_string<_CharT, _Traits, _Alloc>::_M_copy(_CharT*, const _CharT*, std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (char * __d, const char * __s, size_type __n)
{
  if (__n == 1) goto <D.89180>; else goto <D.89181>;
  <D.89180>:
  std::char_traits<char>::assign (__d, __s);
  goto <D.89182>;
  <D.89181>:
  std::char_traits<char>::copy (__d, __s, __n);
  <D.89182>:
}


static void std::char_traits<char>::assign(std::char_traits<char>::char_type&, const char_type&) (char_type & __c1, const char_type & __c2)
{
  char D.89183;

  D.89183 = *__c2;
  *__c1 = D.89183;
}


static std::char_traits<char>::char_type* std::char_traits<char>::copy(std::char_traits<char>::char_type*, const char_type*, std::size_t) (char_type * __s1, const char_type * __s2, size_t __n)
{
  char_type * D.89184;

  D.89184 = __builtin_memcpy (__s1, __s2, __n);
  return D.89184;
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_length_and_sharable(std::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (struct _Rep * const this, size_type __n)
{
  bool retval.35;
  struct _Rep & D.89187;
  bool D.89188;
  long int D.89189;
  long int D.89190;
  char * D.89193;
  char * D.89194;

  D.89187 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.89188 = D.89187 != this;
  D.89189 = (long int) D.89188;
  D.89190 = __builtin_expect (D.89189, 0);
  retval.35 = D.89190 != 0;
  if (retval.35 != 0) goto <D.89191>; else goto <D.89192>;
  <D.89191>:
  std::basic_string<char>::_Rep::_M_set_sharable (this);
  this->D.18966._M_length = __n;
  D.89193 = std::basic_string<char>::_Rep::_M_refdata (this);
  D.89194 = D.89193 + __n;
  std::char_traits<char>::assign (D.89194, &_S_terminal);
  goto <D.89195>;
  <D.89192>:
  <D.89195>:
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_set_sharable() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  this->D.18966._M_refcount = 0;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_refdata() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this)
{
  char * D.89197;
  void * D.89198;

  try
    {
      D.89197 = this + 24;
      return D.89197;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89198 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89198);
          
        }
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::_Alloc_hider::_Alloc_hider(_CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Alloc_hider * const this, char * __dat, const struct allocator & __a)
{
  std::allocator<char>::allocator (this, __a);
  try
    {
      this->_M_p = __dat;
    }
  catch
    {
      std::allocator<char>::~allocator (this);
    }
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator< <template-parameter-1-1> >&) [with _Tp = char] (struct allocator * const this, const struct allocator & __a)
{
  void * D.89200;

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89200 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89200);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = char] (struct new_allocator * const this, const struct new_allocator & D.14983)
{
  void * D.89201;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89201 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89201);
          
        }
    }
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = char] (struct allocator * const this)
{
  void * D.89202;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<char>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.87670>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89202 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89202);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.89203;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.87932>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.89203 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.89203);
          
        }
    }
}


Glib::ustring::SequenceToString<const char*, char>::~SequenceToString() (struct SequenceToString * const this)
{
  struct basic_string * D.89204;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.89204 = &this->D.87818;
            std::basic_string<char>::~basic_string (D.89204);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87843>:
}


std::basic_string<_CharT, _Traits, _Alloc>::~basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator_type D.87446;
  struct _Rep * D.89206;
  struct _Alloc_hider * D.89207;

  {
    try
      {
        try
          {
            D.87446 = std::basic_string<char>::get_allocator (this); [return slot optimization]
            try
              {
                D.89206 = std::basic_string<char>::_M_rep (this);
                std::basic_string<char>::_Rep::_M_dispose (D.89206, &D.87446);
              }
            finally
              {
                std::allocator<char>::~allocator (&D.87446);
                D.87446 = {CLOBBER};
              }
          }
        finally
          {
            D.89207 = &this->_M_dataplus;
            std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.89207);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87447>:
}


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

  D.89213 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.89213);
  return <retval>;
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.36;
  struct _Rep & D.89216;
  bool D.89217;
  long int D.89218;
  long int D.89219;
  bool retval.37;
  _Atomic_word * D.89223;
  int D.89224;

  D.89216 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.89217 = D.89216 != this;
  D.89218 = (long int) D.89217;
  D.89219 = __builtin_expect (D.89218, 0);
  retval.36 = D.89219 != 0;
  if (retval.36 != 0) goto <D.89220>; else goto <D.89221>;
  <D.89220>:
  D.89223 = &this->D.18966._M_refcount;
  D.89224 = __gnu_cxx::__exchange_and_add_dispatch (D.89223, -1);
  retval.37 = D.89224 <= 0;
  if (retval.37 != 0) goto <D.89225>; else goto <D.89226>;
  <D.89225>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.89227>;
  <D.89226>:
  <D.89227>:
  goto <D.89228>;
  <D.89221>:
  <D.89228>:
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.38;
  int D.89231;
  _Atomic_word D.89234;

  D.89231 = __gthread_active_p ();
  retval.38 = D.89231 != 0;
  if (retval.38 != 0) goto <D.89232>; else goto <D.89233>;
  <D.89232>:
  D.89234 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.89234;
  <D.89233>:
  D.89234 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.89234;
}


int __gthread_active_p() ()
{
  int D.89236;
  bool D.89237;
  static void * const __gthread_active_ptr = (void *) __gthrw___pthread_key_create;

  D.89237 = __gthrw___pthread_key_create != 0B;
  D.89236 = (int) D.89237;
  return D.89236;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.89239;
  unsigned int __val.39;
  unsigned int D.89241;

  __val.39 = (unsigned int) __val;
  D.89241 = __atomic_fetch_add_4 (__mem, __val.39, 4);
  D.89239 = (_Atomic_word) D.89241;
  return D.89239;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.89243;
  int D.89244;
  _Atomic_word D.89245;
  _Atomic_word __result;

  __result = *__mem;
  D.89243 = *__mem;
  D.89244 = D.89243 + __val;
  *__mem = D.89244;
  D.89245 = __result;
  return D.89245;
}


std::basic_string<char>::_Alloc_hider::~_Alloc_hider() (struct _Alloc_hider * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<char>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87440>:
}


static void Glib::Markup::ParserCallbacks::passthrough(GMarkupParseContext*, const char*, gsize, void*, GError**) (struct GMarkupParseContext * context, const char * passthrough_text, gsize text_len, void * user_data, struct GError * * error)
{
  bool retval.40;
  int retval.41;
  bool retval.42;
  struct GMarkupParseContext * D.89250;
  long int D.89254;
  long int D.89255;
  struct Parser * D.89259;
  int (*__vtbl_ptr_type) () * D.89260;
  int (*__vtbl_ptr_type) () * D.89261;
  int (*__vtbl_ptr_type) () D.89262;
  struct ustring D.87241;
  const char * D.89263;
  register struct MarkupError * err.43;
  void * D.89264;
  struct Error * D.89265;
  void * D.89266;
  struct ParseContext & cpp_context;
  static const char __PRETTY_FUNCTION__[114] = "static void Glib::Markup::ParserCallbacks::passthrough(GMarkupParseContext*, const char*, gsize, void*, GError**)";

  cpp_context = user_data;
  {
    {
      {
        int _g_boolean_var_;

        D.89250 = Glib::Markup::ParseContext::gobj (cpp_context);
        retval.42 = D.89250 == context;
        if (retval.42 != 0) goto <D.89251>; else goto <D.89252>;
        <D.89251>:
        _g_boolean_var_ = 1;
        goto <D.89253>;
        <D.89252>:
        _g_boolean_var_ = 0;
        <D.89253>:
        retval.41 = _g_boolean_var_;
      }
      D.89254 = (long int) retval.41;
      D.89255 = __builtin_expect (D.89254, 1);
      retval.40 = D.89255 != 0;
      if (retval.40 != 0) goto <D.89256>; else goto <D.89257>;
      <D.89256>:
      goto <D.89258>;
      <D.89257>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "context == cpp_context.gobj()");
      return;
      <D.89258>:
    }
  }
  try
    {
      D.89259 = Glib::Markup::ParseContext::get_parser (cpp_context);
      D.89260 = D.89259->_vptr.Parser;
      D.89261 = D.89260 + 40;
      D.89262 = *D.89261;
      D.89263 = passthrough_text + text_len;
      Glib::ustring::ustring<const char*> (&D.87241, passthrough_text, D.89263);
      try
        {
          OBJ_TYPE_REF(D.89262;(struct Parser)D.89259->5) (D.89259, cpp_context, &D.87241);
        }
      finally
        {
          Glib::ustring::~ustring (&D.87241);
          D.87241 = {CLOBBER};
        }
    }
  catch
    {
      catch (struct MarkupError)
        {
          {
            struct MarkupError & err;

            try
              {
                D.89264 = __builtin_eh_pointer (0);
                err.43 = __cxa_begin_catch (D.89264);
                err = err.43;
                D.89265 = &err->D.80065;
                Glib::Error::propagate (D.89265, error);
              }
            finally
              {
                __cxa_end_catch ();
              }
          }
        }
      catch (NULL)
        {
          try
            {
              D.89266 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.89266);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


static void Glib::Markup::ParserCallbacks::error(GMarkupParseContext*, GError*, void*) (struct GMarkupParseContext * context, struct GError * error, void * user_data)
{
  bool retval.44;
  int retval.45;
  bool retval.46;
  struct GMarkupParseContext * D.89277;
  long int D.89281;
  long int D.89282;
  bool retval.47;
  int retval.48;
  bool retval.49;
  unsigned int D.89289;
  unsigned int D.89290;
  long int D.89294;
  long int D.89295;
  struct Parser * D.89299;
  int (*__vtbl_ptr_type) () * D.89300;
  int (*__vtbl_ptr_type) () * D.89301;
  int (*__vtbl_ptr_type) () D.89302;
  struct MarkupError D.87265;
  struct GError * D.89303;
  void * D.89304;
  struct ParseContext & cpp_context;
  static const char __PRETTY_FUNCTION__[87] = "static void Glib::Markup::ParserCallbacks::error(GMarkupParseContext*, GError*, void*)";

  cpp_context = user_data;
  {
    {
      {
        int _g_boolean_var_;

        D.89277 = Glib::Markup::ParseContext::gobj (cpp_context);
        retval.46 = D.89277 == context;
        if (retval.46 != 0) goto <D.89278>; else goto <D.89279>;
        <D.89278>:
        _g_boolean_var_ = 1;
        goto <D.89280>;
        <D.89279>:
        _g_boolean_var_ = 0;
        <D.89280>:
        retval.45 = _g_boolean_var_;
      }
      D.89281 = (long int) retval.45;
      D.89282 = __builtin_expect (D.89281, 1);
      retval.44 = D.89282 != 0;
      if (retval.44 != 0) goto <D.89283>; else goto <D.89284>;
      <D.89283>:
      goto <D.89285>;
      <D.89284>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "context == cpp_context.gobj()");
      return;
      <D.89285>:
    }
  }
  {
    {
      {
        int _g_boolean_var_;

        D.89289 = error->domain;
        D.89290 = g_markup_error_quark ();
        retval.49 = D.89289 == D.89290;
        if (retval.49 != 0) goto <D.89291>; else goto <D.89292>;
        <D.89291>:
        _g_boolean_var_ = 1;
        goto <D.89293>;
        <D.89292>:
        _g_boolean_var_ = 0;
        <D.89293>:
        retval.48 = _g_boolean_var_;
      }
      D.89294 = (long int) retval.48;
      D.89295 = __builtin_expect (D.89294, 1);
      retval.47 = D.89295 != 0;
      if (retval.47 != 0) goto <D.89296>; else goto <D.89297>;
      <D.89296>:
      goto <D.89298>;
      <D.89297>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "error->domain == G_MARKUP_ERROR");
      return;
      <D.89298>:
    }
  }
  try
    {
      D.89299 = Glib::Markup::ParseContext::get_parser (cpp_context);
      D.89300 = D.89299->_vptr.Parser;
      D.89301 = D.89300 + 48;
      D.89302 = *D.89301;
      D.89303 = g_error_copy (error);
      Glib::MarkupError::MarkupError (&D.87265, D.89303);
      try
        {
          OBJ_TYPE_REF(D.89302;(struct Parser)D.89299->6) (D.89299, cpp_context, &D.87265);
        }
      finally
        {
          Glib::MarkupError::~MarkupError (&D.87265);
          D.87265 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.89304 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.89304);
              Glib::exception_handlers_invoke ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::MarkupError::~MarkupError() (struct MarkupError * const this)
{
  struct Error * D.89312;
  int D.89313;

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

          }
        finally
          {
            D.89312 = &this->D.80065;
            Glib::Error::~Error (D.89312);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.88688>:
  D.89313 = 0;
  if (D.89313 != 0) goto <D.89314>; else goto <D.89315>;
  <D.89314>:
  operator delete (this);
  goto <D.89316>;
  <D.89315>:
  <D.89316>:
}


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


Glib::Markup::Parser::Parser() (struct Parser * const this)
{
  struct trackable * D.89317;

  D.89317 = &this->D.80175;
  sigc::trackable::trackable (D.89317);
  try
    {
      this->_vptr.Parser = &MEM[(void *)&_ZTVN4Glib6Markup6ParserE + 16B];
    }
  catch
    {
      D.89317 = &this->D.80175;
      sigc::trackable::~trackable (D.89317);
    }
}


Glib::Markup::Parser::~Parser() (struct Parser * const this)
{
  struct trackable * D.89318;
  int D.89319;

  {
    this->_vptr.Parser = &MEM[(void *)&_ZTVN4Glib6Markup6ParserE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.89318 = &this->D.80175;
            sigc::trackable::~trackable (D.89318);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87282>:
  D.89319 = 0;
  if (D.89319 != 0) goto <D.89320>; else goto <D.89321>;
  <D.89320>:
  operator delete (this);
  goto <D.89322>;
  <D.89321>:
  <D.89322>:
}


virtual Glib::Markup::Parser::~Parser() (struct Parser * const this)
{
  Glib::Markup::Parser::~Parser (this);
  <D.87286>:
  operator delete (this);
}


virtual void Glib::Markup::Parser::on_start_element(Glib::Markup::ParseContext&, const Glib::ustring&, const AttributeMap&) (struct Parser * const this, struct ParseContext & D.87287, const struct ustring & D.87288, const struct AttributeMap & D.87289)
{
  GIMPLE_NOP
}


virtual void Glib::Markup::Parser::on_end_element(Glib::Markup::ParseContext&, const Glib::ustring&) (struct Parser * const this, struct ParseContext & D.87293, const struct ustring & D.87294)
{
  GIMPLE_NOP
}


virtual void Glib::Markup::Parser::on_text(Glib::Markup::ParseContext&, const Glib::ustring&) (struct Parser * const this, struct ParseContext & D.87298, const struct ustring & D.87299)
{
  GIMPLE_NOP
}


virtual void Glib::Markup::Parser::on_passthrough(Glib::Markup::ParseContext&, const Glib::ustring&) (struct Parser * const this, struct ParseContext & D.87303, const struct ustring & D.87304)
{
  GIMPLE_NOP
}


virtual void Glib::Markup::Parser::on_error(Glib::Markup::ParseContext&, const Glib::MarkupError&) (struct Parser * const this, struct ParseContext & D.87308, const struct MarkupError & D.87309)
{
  GIMPLE_NOP
}


Glib::Markup::ParseContext::ParseContext(Glib::Markup::Parser&, Glib::Markup::ParseFlags) (struct ParseContext * const this, struct Parser & parser, ParseFlags flags)
{
  struct trackable * D.89324;
  struct GMarkupParseContext * D.89325;

  D.89324 = &this->D.80245;
  sigc::trackable::trackable (D.89324);
  try
    {
      this->_vptr.ParseContext = &MEM[(void *)&_ZTVN4Glib6Markup12ParseContextE + 16B];
      this->parser_ = parser;
      D.89325 = g_markup_parse_context_new (&vfunc_table, flags, this, destroy_notify_callback);
      this->gobject_ = D.89325;
    }
  catch
    {
      D.89324 = &this->D.80245;
      sigc::trackable::~trackable (D.89324);
    }
}


Glib::Markup::ParseContext::~ParseContext() (struct ParseContext * const this)
{
  struct GMarkupParseContext * D.89328;
  struct trackable * D.89329;
  int D.89330;

  {
    this->_vptr.ParseContext = &MEM[(void *)&_ZTVN4Glib6Markup12ParseContextE + 16B];
    try
      {
        try
          {
            this->parser_ = 0B;
            D.89328 = this->gobject_;
            g_markup_parse_context_free (D.89328);
          }
        finally
          {
            D.89329 = &this->D.80245;
            sigc::trackable::~trackable (D.89329);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87327>:
  D.89330 = 0;
  if (D.89330 != 0) goto <D.89331>; else goto <D.89332>;
  <D.89331>:
  operator delete (this);
  goto <D.89333>;
  <D.89332>:
  <D.89333>:
}


virtual Glib::Markup::ParseContext::~ParseContext() (struct ParseContext * const this)
{
  Glib::Markup::ParseContext::~ParseContext (this);
  <D.87331>:
  operator delete (this);
}


void Glib::Markup::ParseContext::parse(const Glib::ustring&) (struct ParseContext * const this, const struct ustring & text)
{
  long unsigned int D.89336;
  long int D.89337;
  const char * D.89338;
  struct GMarkupParseContext * D.89339;
  struct GError * error.50;
  struct GError * error;

  try
    {
      error = 0B;
      D.89336 = Glib::ustring::bytes (text);
      D.89337 = (long int) D.89336;
      D.89338 = Glib::ustring::data (text);
      D.89339 = this->gobject_;
      g_markup_parse_context_parse (D.89339, D.89338, D.89337, &error);
      error.50 = error;
      if (error.50 != 0B) goto <D.89341>; else goto <D.89342>;
      <D.89341>:
      error.50 = error;
      Glib::Error::throw_exception (error.50);
      <D.89342>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


void Glib::Markup::ParseContext::parse(const char*, const char*) (struct ParseContext * const this, const char * text_begin, const char * text_end)
{
  long int text_end.51;
  long int text_begin.52;
  long int D.89348;
  struct GMarkupParseContext * D.89349;
  struct GError * error.53;
  struct GError * error;

  try
    {
      error = 0B;
      text_end.51 = (long int) text_end;
      text_begin.52 = (long int) text_begin;
      D.89348 = text_end.51 - text_begin.52;
      D.89349 = this->gobject_;
      g_markup_parse_context_parse (D.89349, text_begin, D.89348, &error);
      error.53 = error;
      if (error.53 != 0B) goto <D.89351>; else goto <D.89352>;
      <D.89351>:
      error.53 = error;
      Glib::Error::throw_exception (error.53);
      <D.89352>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


void Glib::Markup::ParseContext::end_parse() (struct ParseContext * const this)
{
  struct GMarkupParseContext * D.89354;
  struct GError * error.54;
  struct GError * error;

  try
    {
      error = 0B;
      D.89354 = this->gobject_;
      g_markup_parse_context_end_parse (D.89354, &error);
      error.54 = error;
      if (error.54 != 0B) goto <D.89356>; else goto <D.89357>;
      <D.89356>:
      error.54 = error;
      Glib::Error::throw_exception (error.54);
      <D.89357>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


Glib::ustring Glib::Markup::ParseContext::get_element() const (const struct ParseContext * const this)
{
  struct GMarkupParseContext * D.89360;
  const char * const element_name;

  D.89360 = this->gobject_;
  element_name = g_markup_parse_context_get_element (D.89360);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (element_name); [return slot optimization]
  return <retval>;
}


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

  if (str != 0B) goto <D.89364>; else goto <D.89365>;
  <D.89364>:
  D.89366 = <retval>;
  Glib::ustring::ustring (D.89366, str);
  goto <D.89367>;
  <D.89365>:
  D.89366 = <retval>;
  Glib::ustring::ustring (D.89366);
  <D.89367>:
  return <retval>;
}


int Glib::Markup::ParseContext::get_line_number() const (const struct ParseContext * const this)
{
  struct GMarkupParseContext * D.89369;
  int D.89370;
  int line_number;

  try
    {
      line_number = 0;
      D.89369 = this->gobject_;
      g_markup_parse_context_get_position (D.89369, &line_number, 0B);
      D.89370 = line_number;
      return D.89370;
    }
  finally
    {
      line_number = {CLOBBER};
    }
}


int Glib::Markup::ParseContext::get_char_number() const (const struct ParseContext * const this)
{
  struct GMarkupParseContext * D.89374;
  int D.89375;
  int char_number;

  try
    {
      char_number = 0;
      D.89374 = this->gobject_;
      g_markup_parse_context_get_position (D.89374, 0B, &char_number);
      D.89375 = char_number;
      return D.89375;
    }
  finally
    {
      char_number = {CLOBBER};
    }
}


static void Glib::Markup::ParseContext::destroy_notify_callback(void*) (void * data)
{
  bool retval.55;
  int retval.56;
  struct Parser * D.89381;
  long int D.89385;
  long int D.89386;
  struct ParseContext * const self;
  static const char __PRETTY_FUNCTION__[71] = "static void Glib::Markup::ParseContext::destroy_notify_callback(void*)";

  self = data;
  {
    {
      {
        int _g_boolean_var_;

        D.89381 = self->parser_;
        if (D.89381 == 0B) goto <D.89382>; else goto <D.89383>;
        <D.89382>:
        _g_boolean_var_ = 1;
        goto <D.89384>;
        <D.89383>:
        _g_boolean_var_ = 0;
        <D.89384>:
        retval.56 = _g_boolean_var_;
      }
      D.89385 = (long int) retval.56;
      D.89386 = __builtin_expect (D.89385, 1);
      retval.55 = D.89386 != 0;
      if (retval.55 != 0) goto <D.89387>; else goto <D.89388>;
      <D.89387>:
      goto <D.89389>;
      <D.89388>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "self->parser_ == 0");
      return;
      <D.89389>:
    }
  }
}


Glib::MarkupError::MarkupError(Glib::MarkupError::Code, const Glib::ustring&) (struct MarkupError * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.57;
  unsigned int D.89392;
  struct Error * D.89393;

  error_code.57 = (int) error_code;
  D.89392 = g_markup_error_quark ();
  D.89393 = &this->D.80065;
  Glib::Error::Error (D.89393, D.89392, error_code.57, error_message);
  try
    {
      this->D.80065.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN4Glib11MarkupErrorE + 16B];
    }
  catch
    {
      D.89393 = &this->D.80065;
      Glib::Error::~Error (D.89393);
    }
}


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

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


Glib::MarkupError::Code Glib::MarkupError::code() const (const struct MarkupError * const this)
{
  Code D.89396;
  const struct Error * D.89397;
  int D.89398;

  D.89397 = &this->D.80065;
  D.89398 = Glib::Error::code (D.89397);
  D.89396 = (Code) D.89398;
  return D.89396;
}


static void Glib::MarkupError::throw_func(GError*) (struct GError * gobject)
{
  void * D.87393;

  D.87393 = __cxa_allocate_exception (16);
  try
    {
      Glib::MarkupError::MarkupError (D.87393, gobject);
    }
  catch
    {
      __cxa_free_exception (D.87393);
    }
  __cxa_throw (D.87393, &_ZTIN4Glib11MarkupErrorE, __comp_dtor );
}