void Glib::Interface_Class::add_interface(GType) const (const struct Interface_Class * const this, GType instance_type)
{
  void (*<T4eb>) (void *, void *) D.78829;
  long unsigned int D.78830;
  const struct GInterfaceInfo interface_info;

  try
    {
      interface_info = {};
      D.78829 = this->D.74398.class_init_func_;
      interface_info.interface_init = D.78829;
      D.78830 = this->D.74398.gtype_;
      g_type_add_interface_static (instance_type, D.78830, &interface_info);
    }
  finally
    {
      interface_info = {CLOBBER};
    }
}


Glib::Interface::Interface(const Glib::Interface_Class&) (struct Interface * const this, const void * * __vtt_parm, const struct Interface_Class & interface_class)
{
  struct trackable * D.78835;
  const void * * iftmp.0;
  struct ObjectBase * D.78843;
  int (*__vtbl_ptr_type) () * iftmp.1;
  sizetype iftmp.2;
  int (*__vtbl_ptr_type) () * D.78852;
  int (*__vtbl_ptr_type) () * D.78853;
  long int D.78854;
  struct ObjectBase * D.78856;
  int (*__vtbl_ptr_type) () * iftmp.3;
  bool retval.4;
  bool iftmp.5;
  sizetype iftmp.6;
  struct ObjectBase * D.78869;
  const char * D.78870;
  sizetype iftmp.7;
  struct ObjectBase * D.78876;
  bool D.78877;
  bool D.78878;
  sizetype iftmp.8;
  struct ObjectBase * D.78886;
  struct GObject * D.78887;
  sizetype iftmp.9;
  struct ObjectBase * D.78894;
  struct GObject * D.78895;
  const struct Class * D.78896;
  bool retval.10;
  void * D.78898;
  unsigned int iface_properties_quark.11;
  void * props.12;
  long unsigned int D.78905;
  int D.78912;
  long unsigned int D.78915;
  long unsigned int D.78916;
  long unsigned int D.78917;
  long unsigned int D.78918;
  struct GParamSpec * * D.78919;
  struct GParamSpec * D.78920;
  long unsigned int D.78921;
  struct GValue * g_value.13;
  unsigned int D.78923;
  unsigned int D.78924;
  unsigned int n_iface_props.14;
  struct element_type & D.78928;
  const struct Interface_Class * const D.76377;
  const struct ObjectBase * const D.76376;
  sizetype iftmp.15;
  const struct ObjectBase * D.78933;
  struct mapped_type & D.78934;
  struct interface_class_vector_type * D.78935;
  const void * * iftmp.16;

  if (0 != 0) goto <D.78833>; else goto <D.78834>;
  <D.78833>:
  D.78835 = &this->D.74380;
  sigc::trackable::trackable (D.78835);
  goto <D.78836>;
  <D.78834>:
  <D.78836>:
  try
    {
      if (0 != 0) goto <D.78837>; else goto <D.78838>;
      <D.78837>:
      if (0 == 0) goto <D.78840>; else goto <D.78841>;
      <D.78840>:
      iftmp.0 = __vtt_parm + 16;
      goto <D.78842>;
      <D.78841>:
      iftmp.0 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.78842>:
      D.78843 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.78843, iftmp.0);
      goto <D.78844>;
      <D.78838>:
      <D.78844>:
      try
        {
          if (0 == 0) goto <D.78846>; else goto <D.78847>;
          <D.78846>:
          iftmp.1 = *__vtt_parm;
          goto <D.78848>;
          <D.78847>:
          iftmp.1 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.78848>:
          this->_vptr.Interface = iftmp.1;
          if (0 == 0) goto <D.78850>; else goto <D.78851>;
          <D.78850>:
          D.78852 = this->_vptr.Interface;
          D.78853 = D.78852 + 18446744073709551592;
          D.78854 = MEM[(long int *)D.78853];
          iftmp.2 = (sizetype) D.78854;
          goto <D.78855>;
          <D.78851>:
          iftmp.2 = 8;
          <D.78855>:
          D.78856 = this + iftmp.2;
          if (0 == 0) goto <D.78858>; else goto <D.78859>;
          <D.78858>:
          iftmp.3 = MEM[(const void * *)__vtt_parm + 8B];
          goto <D.78860>;
          <D.78859>:
          iftmp.3 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.78860>:
          D.78856->_vptr.ObjectBase = iftmp.3;
          {
            {
              if (0 == 0) goto <D.78866>; else goto <D.78867>;
              <D.78866>:
              D.78852 = this->_vptr.Interface;
              D.78853 = D.78852 + 18446744073709551592;
              D.78854 = MEM[(long int *)D.78853];
              iftmp.6 = (sizetype) D.78854;
              goto <D.78868>;
              <D.78867>:
              iftmp.6 = 8;
              <D.78868>:
              D.78869 = this + iftmp.6;
              D.78870 = D.78869->custom_type_name_;
              if (D.78870 != 0B) goto <D.78871>; else goto <D.78863>;
              <D.78871>:
              if (0 == 0) goto <D.78873>; else goto <D.78874>;
              <D.78873>:
              D.78852 = this->_vptr.Interface;
              D.78853 = D.78852 + 18446744073709551592;
              D.78854 = MEM[(long int *)D.78853];
              iftmp.7 = (sizetype) D.78854;
              goto <D.78875>;
              <D.78874>:
              iftmp.7 = 8;
              <D.78875>:
              D.78876 = this + iftmp.7;
              D.78877 = Glib::ObjectBase::is_anonymous_custom_ (D.78876);
              D.78878 = ~D.78877;
              if (D.78878 != 0) goto <D.78879>; else goto <D.78863>;
              <D.78879>:
              iftmp.5 = 1;
              goto <D.78864>;
              <D.78863>:
              iftmp.5 = 0;
              <D.78864>:
              retval.4 = iftmp.5;
              if (retval.4 != 0) goto <D.78880>; else goto <D.78881>;
              <D.78880>:
              {
                {
                  if (0 == 0) goto <D.78883>; else goto <D.78884>;
                  <D.78883>:
                  D.78852 = this->_vptr.Interface;
                  D.78853 = D.78852 + 18446744073709551592;
                  D.78854 = MEM[(long int *)D.78853];
                  iftmp.8 = (sizetype) D.78854;
                  goto <D.78885>;
                  <D.78884>:
                  iftmp.8 = 8;
                  <D.78885>:
                  D.78886 = this + iftmp.8;
                  D.78887 = D.78886->gobject_;
                  if (D.78887 != 0B) goto <D.78888>; else goto <D.78889>;
                  <D.78888>:
                  {
                    struct GObjectClass * const instance_class;
                    const GType iface_type;

                    if (0 == 0) goto <D.78891>; else goto <D.78892>;
                    <D.78891>:
                    D.78852 = this->_vptr.Interface;
                    D.78853 = D.78852 + 18446744073709551592;
                    D.78854 = MEM[(long int *)D.78853];
                    iftmp.9 = (sizetype) D.78854;
                    goto <D.78893>;
                    <D.78892>:
                    iftmp.9 = 8;
                    <D.78893>:
                    D.78894 = this + iftmp.9;
                    D.78895 = D.78894->gobject_;
                    instance_class = MEM[(struct GTypeInstance *)D.78895].g_class;
                    D.78896 = &interface_class->D.74398;
                    iface_type = Glib::Class::get_type (D.78896);
                    {
                      D.78898 = g_type_interface_peek (instance_class, iface_type);
                      retval.10 = D.78898 == 0B;
                      if (retval.10 != 0) goto <D.78899>; else goto <D.78900>;
                      <D.78899>:
                      {
                        void * const g_iface;
                        const GType custom_type;
                        struct iface_properties_type * props;
                        const guint n_existing_props;
                        guint n_iface_props;
                        struct GParamSpec * * iface_props;

                        try
                          {
                            g_iface = g_type_default_interface_ref (iface_type);
                            custom_type = MEM[(struct GTypeClass *)instance_class].g_type;
                            iface_properties_quark.11 = iface_properties_quark;
                            props = g_type_get_qdata (custom_type, iface_properties_quark.11);
                            if (props == 0B) goto <D.78902>; else goto <D.78903>;
                            <D.78902>:
                            props.12 = operator new (24);
                            try
                              {
                                std::vector<_GValue*>::vector (props.12);
                              }
                            catch
                              {
                                operator delete (props.12);
                              }
                            props = props.12;
                            iface_properties_quark.11 = iface_properties_quark;
                            g_type_set_qdata (custom_type, iface_properties_quark.11, props);
                            goto <D.78904>;
                            <D.78903>:
                            <D.78904>:
                            D.78905 = std::vector<_GValue*>::size (props);
                            n_existing_props = (const guint) D.78905;
                            n_iface_props = 0;
                            iface_props = g_object_interface_list_properties (g_iface, &n_iface_props);
                            {
                              guint p;

                              p = 0;
                              goto <D.76366>;
                              <D.76367>:
                              {
                                struct GValue * g_value;
                                const gchar * prop_name;
                                struct GParamSpec * new_spec;

                                try
                                  {
                                    {
                                      gsize __n;
                                      gsize __s;
                                      void * __p;

                                      __n = 1;
                                      __s = 24;
                                      if (__s == 1) goto <D.78906>; else goto <D.78907>;
                                      <D.78906>:
                                      __p = g_malloc0 (__n);
                                      goto <D.78908>;
                                      <D.78907>:
                                      D.78912 = __builtin_constant_p (__n);
                                      if (D.78912 != 0) goto <D.78913>; else goto <D.78909>;
                                      <D.78913>:
                                      if (__s == 0) goto <D.78910>; else goto <D.78914>;
                                      <D.78914>:
                                      D.78915 = 18446744073709551615 / __s;
                                      if (D.78915 >= __n) goto <D.78910>; else goto <D.78909>;
                                      <D.78910>:
                                      D.78916 = __n * __s;
                                      __p = g_malloc0 (D.78916);
                                      goto <D.78911>;
                                      <D.78909>:
                                      __p = g_malloc0_n (__n, __s);
                                      <D.78911>:
                                      <D.78908>:
                                      g_value = __p;
                                    }
                                    D.78917 = (long unsigned int) p;
                                    D.78918 = D.78917 * 8;
                                    D.78919 = iface_props + D.78918;
                                    D.78920 = *D.78919;
                                    D.78921 = D.78920->value_type;
                                    g_value.13 = g_value;
                                    g_value_init (g_value.13, D.78921);
                                    g_value.13 = g_value;
                                    D.78917 = (long unsigned int) p;
                                    D.78918 = D.78917 * 8;
                                    D.78919 = iface_props + D.78918;
                                    D.78920 = *D.78919;
                                    g_param_value_set_default (D.78920, g_value.13);
                                    std::vector<_GValue*>::push_back (props, &g_value);
                                    D.78917 = (long unsigned int) p;
                                    D.78918 = D.78917 * 8;
                                    D.78919 = iface_props + D.78918;
                                    D.78920 = *D.78919;
                                    prop_name = g_param_spec_get_name (D.78920);
                                    D.78917 = (long unsigned int) p;
                                    D.78918 = D.78917 * 8;
                                    D.78919 = iface_props + D.78918;
                                    D.78920 = *D.78919;
                                    new_spec = g_param_spec_override (prop_name, D.78920);
                                    D.78923 = p + n_existing_props;
                                    D.78924 = D.78923 + 1;
                                    g_object_class_install_property (instance_class, D.78924, new_spec);
                                  }
                                finally
                                  {
                                    g_value = {CLOBBER};
                                  }
                              }
                              p = p + 1;
                              <D.76366>:
                              n_iface_props.14 = n_iface_props;
                              if (p < n_iface_props.14) goto <D.76367>; else goto <D.76374>;
                              <D.76374>:
                            }
                            Glib::Interface_Class::add_interface (interface_class, custom_type);
                            g_type_default_interface_unref (g_iface);
                            g_free (iface_props);
                          }
                        finally
                          {
                            n_iface_props = {CLOBBER};
                          }
                      }
                      goto <D.78926>;
                      <D.78900>:
                      <D.78926>:
                    }
                  }
                  goto <D.78927>;
                  <D.78889>:
                  {
                    struct Lock lock;

                    try
                      {
                        D.78928 = std::auto_ptr<Glib::Threads::Mutex>::operator* (&extra_object_base_data_mutex);
                        Glib::Threads::Mutex::Lock::Lock (&lock, D.78928);
                        try
                          {
                            D.76377 = interface_class;
                            try
                              {
                                if (0 == 0) goto <D.78930>; else goto <D.78931>;
                                <D.78930>:
                                D.78852 = this->_vptr.Interface;
                                D.78853 = D.78852 + 18446744073709551592;
                                D.78854 = MEM[(long int *)D.78853];
                                iftmp.15 = (sizetype) D.78854;
                                goto <D.78932>;
                                <D.78931>:
                                iftmp.15 = 8;
                                <D.78932>:
                                D.78933 = this + iftmp.15;
                                D.76376 = D.78933;
                                try
                                  {
                                    D.78934 = std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::operator[] (&extra_object_base_data, &D.76376);
                                    D.78935 = &D.78934->custom_interface_classes;
                                    std::vector<const Glib::Interface_Class*>::push_back (D.78935, &D.76377);
                                  }
                                finally
                                  {
                                    D.76376 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                D.76377 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            Glib::Threads::Mutex::Lock::~Lock (&lock);
                          }
                      }
                    finally
                      {
                        lock = {CLOBBER};
                      }
                  }
                  <D.78927>:
                }
              }
              goto <D.78936>;
              <D.78881>:
              <D.78936>:
            }
          }
        }
      catch
        {
          if (0 != 0) goto <D.78937>; else goto <D.78938>;
          <D.78937>:
          if (0 == 0) goto <D.78940>; else goto <D.78941>;
          <D.78940>:
          iftmp.16 = __vtt_parm + 16;
          goto <D.78942>;
          <D.78941>:
          iftmp.16 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.78942>:
          D.78843 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.78843, iftmp.16);
          goto <D.78943>;
          <D.78938>:
          <D.78943>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.78944>; else goto <D.78945>;
      <D.78944>:
      D.78835 = &this->D.74380;
      sigc::trackable::~trackable (D.78835);
      goto <D.78946>;
      <D.78945>:
      <D.78946>:
    }
}


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

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


std::vector<_Tp, _Alloc>::vector() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>] (struct vector * const this)
{
  struct _Vector_base * D.78970;

  D.78970 = &this->D.75158;
  std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_Vector_base (D.78970);
  try
    {

    }
  catch
    {
      D.78970 = &this->D.75158;
      std::_Vector_base<_GValue*, std::allocator<_GValue*> >::~_Vector_base (D.78970);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>] (struct _Vector_base * const this)
{
  struct _Vector_impl * D.78971;

  D.78971 = &this->_M_impl;
  std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_Vector_impl::_Vector_impl (D.78971);
  try
    {

    }
  catch
    {
      D.78971 = &this->_M_impl;
      std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_Vector_impl::~_Vector_impl (D.78971);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>] (struct _Vector_impl * const this)
{
  std::allocator<_GValue*>::allocator (this);
  try
    {
      this->_M_start = 0B;
      this->_M_finish = 0B;
      this->_M_end_of_storage = 0B;
    }
  catch
    {
      std::allocator<_GValue*>::~allocator (this);
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<_GValue*>::new_allocator (this);
        try
          {

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


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

  try
    {
      {

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


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.78974;
  struct _GValue * * D.78975;
  long int D.78976;
  struct _GValue * * D.78977;
  long int D.78978;
  long int D.78979;
  long int D.78980;

  D.78975 = this->D.75158._M_impl._M_finish;
  D.78976 = (long int) D.78975;
  D.78977 = this->D.75158._M_impl._M_start;
  D.78978 = (long int) D.78977;
  D.78979 = D.78976 - D.78978;
  D.78980 = D.78979 /[ex] 8;
  D.78974 = (size_type) D.78980;
  return D.78974;
}


void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::value_type = _GValue*] (struct vector * const this, struct _GValue * const & __x)
{
  struct _GValue * * D.78982;
  struct _GValue * * D.78983;
  struct _Vector_impl * D.78986;
  struct _GValue * * D.78987;
  struct __normal_iterator D.78989;

  D.78982 = this->D.75158._M_impl._M_finish;
  D.78983 = this->D.75158._M_impl._M_end_of_storage;
  if (D.78982 != D.78983) goto <D.78984>; else goto <D.78985>;
  <D.78984>:
  D.78982 = this->D.75158._M_impl._M_finish;
  D.78986 = &this->D.75158._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.78986, D.78982, __x);
  D.78982 = this->D.75158._M_impl._M_finish;
  D.78987 = D.78982 + 8;
  this->D.75158._M_impl._M_finish = D.78987;
  goto <D.78988>;
  <D.78985>:
  D.78989 = std::vector<_GValue*>::end (this);
  std::vector<_GValue*>::_M_insert_aux (this, D.78989, __x);
  <D.78988>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::construct(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, const _Tp&) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = _GValue**] (struct allocator & __a, struct _GValue * * __p, struct _GValue * const & __arg)
{
  __gnu_cxx::new_allocator<_GValue*>::construct (__a, __p, __arg);
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = _GValue*; __gnu_cxx::new_allocator<_Tp>::pointer = _GValue**] (struct new_allocator * const this, struct _GValue * * __p, struct _GValue * const & __val)
{
  void * D.77809;
  void * D.77810;
  struct _GValue * * iftmp.17;
  struct _GValue * D.78993;

  D.77809 = __p;
  D.77810 = operator new (8, D.77809);
  if (D.77810 != 0B) goto <D.78991>; else goto <D.78992>;
  <D.78991>:
  try
    {
      D.78993 = *__val;
      MEM[(struct _GValue * *)D.77810] = D.78993;
    }
  catch
    {
      operator delete (D.77810, D.77809);
    }
  iftmp.17 = D.77810;
  goto <D.78994>;
  <D.78992>:
  iftmp.17 = D.77810;
  <D.78994>:
}


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

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


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::end() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = _GValue**] (struct vector * const this)
{
  struct iterator D.78998;
  struct iterator D.77479;
  struct _GValue * * * D.78999;

  D.78999 = &this->D.75158._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::__normal_iterator (&D.77479, D.78999);
  try
    {
      D.78998 = D.77479;
      return D.78998;
    }
  finally
    {
      D.77479 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = _GValue**; _Container = std::vector<_GValue*>] (struct __normal_iterator * const this, struct _GValue * * const & __i)
{
  struct _GValue * * D.79002;

  D.79002 = *__i;
  this->_M_current = D.79002;
}


void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = _GValue**] (struct vector * const this, struct iterator __position, struct _GValue * const & __x)
{
  struct _GValue * * D.79003;
  struct _GValue * * D.79004;
  struct _GValue * const * D.79007;
  struct _Vector_impl * D.79008;
  struct _GValue * * D.79009;
  struct _GValue * * D.79010;
  struct _GValue * * D.79011;
  struct _GValue * * const & D.79012;
  struct _GValue * * D.79013;
  struct _GValue * & D.79014;
  struct iterator D.77456;
  long int D.79016;
  struct _Vector_base * D.79017;
  long unsigned int D.79018;
  struct _GValue * * D.79019;
  struct _Tp_alloc_type & D.79020;
  struct _GValue * * const & D.79021;
  struct _GValue * * D.79022;
  struct _GValue * * D.79023;
  struct _Tp_alloc_type & D.79024;
  struct _GValue * * const & D.79025;
  struct _GValue * * D.79026;
  void * D.79027;
  struct _Tp_alloc_type & D.79031;
  struct _Tp_alloc_type & D.79032;
  long int D.79033;
  long int D.79034;
  long int D.79035;
  long int D.79036;
  long unsigned int D.79037;
  long unsigned int D.79038;
  struct _GValue * * D.79039;

  {
    D.79003 = this->D.75158._M_impl._M_finish;
    D.79004 = this->D.75158._M_impl._M_end_of_storage;
    if (D.79003 != D.79004) goto <D.79005>; else goto <D.79006>;
    <D.79005>:
    {
      struct _GValue * __x_copy;

      D.79003 = this->D.75158._M_impl._M_finish;
      D.79007 = D.79003 + 18446744073709551608;
      D.79003 = this->D.75158._M_impl._M_finish;
      D.79008 = &this->D.75158._M_impl;
      __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.79008, D.79003, D.79007);
      D.79003 = this->D.75158._M_impl._M_finish;
      D.79009 = D.79003 + 8;
      this->D.75158._M_impl._M_finish = D.79009;
      __x_copy = *__x;
      D.79003 = this->D.75158._M_impl._M_finish;
      D.79010 = D.79003 + 18446744073709551608;
      D.79003 = this->D.75158._M_impl._M_finish;
      D.79011 = D.79003 + 18446744073709551600;
      D.79012 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
      D.79013 = *D.79012;
      std::copy_backward<_GValue**, _GValue**> (D.79013, D.79011, D.79010);
      D.79014 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::operator* (&__position);
      *D.79014 = __x_copy;
    }
    goto <D.79015>;
    <D.79006>:
    {
      const size_type __len;
      const size_type __elems_before;
      struct _GValue * * __new_start;
      struct _GValue * * __new_finish;

      __len = std::vector<_GValue*>::_M_check_len (this, 1, "vector::_M_insert_aux");
      D.77456 = std::vector<_GValue*>::begin (this);
      try
        {
          D.79016 = __gnu_cxx::operator-<_GValue**, std::vector<_GValue*> > (&__position, &D.77456);
          __elems_before = (const size_type) D.79016;
        }
      finally
        {
          D.77456 = {CLOBBER};
        }
      D.79017 = &this->D.75158;
      __new_start = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_allocate (D.79017, __len);
      __new_finish = __new_start;
      try
        {
          D.79018 = __elems_before * 8;
          D.79019 = __new_start + D.79018;
          D.79008 = &this->D.75158._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.79008, D.79019, __x);
          __new_finish = 0B;
          D.79017 = &this->D.75158;
          D.79020 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.79017);
          D.79021 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
          D.79022 = *D.79021;
          D.79023 = this->D.75158._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<_GValue**, _GValue**, std::allocator<_GValue*> > (D.79023, D.79022, __new_start, D.79020);
          __new_finish = __new_finish + 8;
          D.79017 = &this->D.75158;
          D.79024 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.79017);
          D.79003 = this->D.75158._M_impl._M_finish;
          D.79025 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
          D.79026 = *D.79025;
          __new_finish = std::__uninitialized_move_if_noexcept_a<_GValue**, _GValue**, std::allocator<_GValue*> > (D.79026, D.79003, __new_finish, D.79024);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.79027 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.79027);
                  if (__new_finish == 0B) goto <D.79028>; else goto <D.79029>;
                  <D.79028>:
                  D.79018 = __elems_before * 8;
                  D.79019 = __new_start + D.79018;
                  D.79008 = &this->D.75158._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::destroy (D.79008, D.79019);
                  goto <D.79030>;
                  <D.79029>:
                  D.79017 = &this->D.75158;
                  D.79031 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.79017);
                  std::_Destroy<_GValue**, _GValue*> (__new_start, __new_finish, D.79031);
                  <D.79030>:
                  D.79017 = &this->D.75158;
                  std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_deallocate (D.79017, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.79017 = &this->D.75158;
      D.79032 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.79017);
      D.79003 = this->D.75158._M_impl._M_finish;
      D.79023 = this->D.75158._M_impl._M_start;
      std::_Destroy<_GValue**, _GValue*> (D.79023, D.79003, D.79032);
      D.79004 = this->D.75158._M_impl._M_end_of_storage;
      D.79033 = (long int) D.79004;
      D.79023 = this->D.75158._M_impl._M_start;
      D.79034 = (long int) D.79023;
      D.79035 = D.79033 - D.79034;
      D.79036 = D.79035 /[ex] 8;
      D.79037 = (long unsigned int) D.79036;
      D.79023 = this->D.75158._M_impl._M_start;
      D.79017 = &this->D.75158;
      std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_deallocate (D.79017, D.79023, D.79037);
      this->D.75158._M_impl._M_start = __new_start;
      this->D.75158._M_impl._M_finish = __new_finish;
      D.79038 = __len * 8;
      D.79039 = __new_start + D.79038;
      this->D.75158._M_impl._M_end_of_storage = D.79039;
    }
    <D.79015>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = _GValue**; _BI2 = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79047;
  struct _GValue * * D.79048;
  struct _GValue * * D.79049;

  D.79048 = std::__miter_base<_GValue**> (__last);
  D.79049 = std::__miter_base<_GValue**> (__first);
  D.79047 = std::__copy_move_backward_a2<false, _GValue**, _GValue**> (D.79049, D.79048, __result);
  return D.79047;
}


typename std::_Miter_base<_Iterator>::iterator_type std::__miter_base(_Iterator) [with _Iterator = _GValue**; typename std::_Miter_base<_Iterator>::iterator_type = _GValue**] (struct _GValue * * __it)
{
  struct _GValue * * D.79054;

  D.79054 = std::_Iter_base<_GValue**, false>::_S_base (__it);
  return D.79054;
}


static std::_Iter_base<_Iterator, _HasBase>::iterator_type std::_Iter_base<_Iterator, _HasBase>::_S_base(_Iterator) [with _Iterator = _GValue**; bool _HasBase = false; std::_Iter_base<_Iterator, _HasBase>::iterator_type = _GValue**] (struct _GValue * * __it)
{
  struct _GValue * * D.79056;

  D.79056 = __it;
  return D.79056;
}


_BI2 std::__copy_move_backward_a2(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = _GValue**; _BI2 = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79058;
  struct _GValue * * D.79059;
  struct _GValue * * D.79060;
  struct _GValue * * D.79061;

  D.79059 = std::__niter_base<_GValue**> (__result);
  D.79060 = std::__niter_base<_GValue**> (__last);
  D.79061 = std::__niter_base<_GValue**> (__first);
  D.79058 = std::__copy_move_backward_a<false, _GValue**, _GValue**> (D.79061, D.79060, D.79059);
  return D.79058;
}


typename std::_Niter_base<_Iterator>::iterator_type std::__niter_base(_Iterator) [with _Iterator = _GValue**; typename std::_Niter_base<_Iterator>::iterator_type = _GValue**] (struct _GValue * * __it)
{
  struct _GValue * * D.79064;

  D.79064 = std::_Iter_base<_GValue**, false>::_S_base (__it);
  return D.79064;
}


_BI2 std::__copy_move_backward_a(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = _GValue**; _BI2 = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79066;
  typedef struct _GValue * _ValueType1;
  typedef struct _GValue * _ValueType2;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.79066 = std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<_GValue*> (__first, __last, __result);
  return D.79066;
}


static _Tp* std::__copy_move_backward<_IsMove, true, std::random_access_iterator_tag>::__copy_move_b(const _Tp*, const _Tp*, _Tp*) [with _Tp = _GValue*; bool _IsMove = false] (struct _GValue * const * __first, struct _GValue * const * __last, struct _GValue * * __result)
{
  long int __last.18;
  long int __first.19;
  long int D.79070;
  long unsigned int _Num.20;
  long unsigned int D.79074;
  sizetype D.79075;
  struct _GValue * * D.79076;
  struct _GValue * * D.79078;
  const ptrdiff_t _Num;

  __last.18 = (long int) __last;
  __first.19 = (long int) __first;
  D.79070 = __last.18 - __first.19;
  _Num = D.79070 /[ex] 8;
  if (_Num != 0) goto <D.79071>; else goto <D.79072>;
  <D.79071>:
  _Num.20 = (long unsigned int) _Num;
  D.79074 = _Num.20 * 8;
  _Num.20 = (long unsigned int) _Num;
  D.79074 = _Num.20 * 8;
  D.79075 = -D.79074;
  D.79076 = __result + D.79075;
  __builtin_memmove (D.79076, __first, D.79074);
  goto <D.79077>;
  <D.79072>:
  <D.79077>:
  _Num.20 = (long unsigned int) _Num;
  D.79074 = _Num.20 * 8;
  D.79075 = -D.79074;
  D.79078 = __result + D.79075;
  return D.79078;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::reference __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator*() const [with _Iterator = _GValue**; _Container = std::vector<_GValue*>; __gnu_cxx::__normal_iterator<_Iterator, _Container>::reference = _GValue*&] (const struct __normal_iterator * const this)
{
  struct _GValue * & D.79080;

  D.79080 = this->_M_current;
  return D.79080;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::_M_check_len(std::vector<_Tp, _Alloc>::size_type, const char*) const [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n, const char * __s)
{
  bool retval.21;
  long unsigned int D.79083;
  long unsigned int D.79084;
  long unsigned int D.79085;
  long unsigned int __n.22;
  long unsigned int D.79089;
  const long unsigned int D.77836;
  long unsigned int D.79090;
  const long unsigned int & D.79091;
  long unsigned int D.79092;
  size_type D.79093;
  size_type iftmp.23;
  long unsigned int D.79098;
  long unsigned int D.79100;
  const size_type __len;

  D.79083 = std::vector<_GValue*>::max_size (this);
  D.79084 = std::vector<_GValue*>::size (this);
  D.79085 = D.79083 - D.79084;
  __n.22 = __n;
  retval.21 = D.79085 < __n.22;
  if (retval.21 != 0) goto <D.79087>; else goto <D.79088>;
  <D.79087>:
  std::__throw_length_error (__s);
  <D.79088>:
  D.79089 = std::vector<_GValue*>::size (this);
  D.79090 = std::vector<_GValue*>::size (this);
  D.77836 = D.79090;
  try
    {
      D.79091 = std::max<long unsigned int> (&D.77836, &__n);
      D.79092 = *D.79091;
      __len = D.79089 + D.79092;
    }
  finally
    {
      D.77836 = {CLOBBER};
    }
  D.79098 = std::vector<_GValue*>::size (this);
  if (D.79098 > __len) goto <D.79095>; else goto <D.79099>;
  <D.79099>:
  D.79100 = std::vector<_GValue*>::max_size (this);
  if (D.79100 < __len) goto <D.79095>; else goto <D.79096>;
  <D.79095>:
  iftmp.23 = std::vector<_GValue*>::max_size (this);
  goto <D.79097>;
  <D.79096>:
  iftmp.23 = __len;
  <D.79097>:
  D.79093 = iftmp.23;
  return D.79093;
}


const _Tp& std::max(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.79105;
  long unsigned int D.79106;
  const long unsigned int & D.79109;

  D.79105 = *__a;
  D.79106 = *__b;
  if (D.79105 < D.79106) goto <D.79107>; else goto <D.79108>;
  <D.79107>:
  D.79109 = __b;
  return D.79109;
  <D.79108>:
  D.79109 = __a;
  return D.79109;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::max_size() const [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.79111;
  const struct _Vector_base * D.79112;
  const struct _Tp_alloc_type & D.79113;

  D.79112 = &this->D.75158;
  D.79113 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.79112);
  D.79111 = __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::max_size (D.79113);
  return D.79111;
}


const _Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<_GValue*>] (const struct _Vector_base * const this)
{
  const struct _Tp_alloc_type & D.79115;

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


static __gnu_cxx::__alloc_traits<_Alloc>::size_type __gnu_cxx::__alloc_traits<_Alloc>::max_size(const _Alloc&) [with _Alloc = std::allocator<_GValue*>; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (const struct allocator & __a)
{
  size_type D.79117;

  D.79117 = __gnu_cxx::new_allocator<_GValue*>::max_size (__a);
  return D.79117;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = _GValue*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.79119;
  void * D.79120;

  try
    {
      D.79119 = 2305843009213693951;
      return D.79119;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79120 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79120);
          
        }
    }
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::begin() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = _GValue**] (struct vector * const this)
{
  struct iterator D.79122;
  struct iterator D.77838;
  struct _GValue * * * D.79123;

  D.79123 = &this->D.75158._M_impl._M_start;
  __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::__normal_iterator (&D.77838, D.79123);
  try
    {
      D.79122 = D.77838;
      return D.79122;
    }
  finally
    {
      D.77838 = {CLOBBER};
    }
}


typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type __gnu_cxx::operator-(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = _GValue**; _Container = std::vector<_GValue*>; typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type = long int] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  difference_type D.79126;
  struct _GValue * * const & D.79127;
  struct _GValue * * D.79128;
  long int D.79129;
  struct _GValue * * const & D.79130;
  struct _GValue * * D.79131;
  long int D.79132;
  long int D.79133;

  D.79127 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (__lhs);
  D.79128 = *D.79127;
  D.79129 = (long int) D.79128;
  D.79130 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (__rhs);
  D.79131 = *D.79130;
  D.79132 = (long int) D.79131;
  D.79133 = D.79129 - D.79132;
  D.79126 = D.79133 /[ex] 8;
  return D.79126;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::_Vector_base<_Tp, _Alloc>::pointer = _GValue**; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct _GValue * * D.79135;
  struct _GValue * * iftmp.24;
  struct _Vector_impl * D.79139;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.79137>; else goto <D.79138>;
  <D.79137>:
  D.79139 = &this->_M_impl;
  iftmp.24 = __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::allocate (D.79139, __n);
  goto <D.79140>;
  <D.79138>:
  iftmp.24 = 0B;
  <D.79140>:
  D.79135 = iftmp.24;
  return D.79135;
}


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<_GValue*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = _GValue**; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct _GValue * * D.79143;

  D.79143 = __gnu_cxx::new_allocator<_GValue*>::allocate (__a, __n, 0B);
  return D.79143;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = _GValue*; __gnu_cxx::new_allocator<_Tp>::pointer = _GValue**; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.74471)
{
  bool retval.25;
  long unsigned int D.79147;
  struct _GValue * * D.79150;
  long unsigned int D.79151;

  D.79147 = __gnu_cxx::new_allocator<_GValue*>::max_size (this);
  retval.25 = D.79147 < __n;
  if (retval.25 != 0) goto <D.79148>; else goto <D.79149>;
  <D.79148>:
  std::__throw_bad_alloc ();
  <D.79149>:
  D.79151 = __n * 8;
  D.79150 = operator new (D.79151);
  return D.79150;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = _GValue**; _Container = std::vector<_GValue*>] (const struct __normal_iterator * const this)
{
  struct _GValue * * const & D.79154;

  D.79154 = &this->_M_current;
  return D.79154;
}


_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = _GValue**; _ForwardIterator = _GValue**; _Allocator = std::allocator<_GValue*>] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result, struct allocator & __alloc)
{
  struct _GValue * * D.79156;

  D.79156 = std::__uninitialized_copy_a<_GValue**, _GValue**, _GValue*> (__first, __last, __result, __alloc);
  return D.79156;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = _GValue**; _ForwardIterator = _GValue**; _Tp = _GValue*] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result, struct allocator & D.77848)
{
  struct _GValue * * D.79159;

  D.79159 = std::uninitialized_copy<_GValue**, _GValue**> (__first, __last, __result);
  return D.79159;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = _GValue**; _ForwardIterator = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79162;
  typedef struct _GValue * _ValueType1;
  typedef struct _GValue * _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.79162 = std::__uninitialized_copy<true>::__uninit_copy<_GValue**, _GValue**> (__first, __last, __result);
  return D.79162;
}


static _ForwardIterator std::__uninitialized_copy<true>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = _GValue**; _ForwardIterator = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79165;

  D.79165 = std::copy<_GValue**, _GValue**> (__first, __last, __result);
  return D.79165;
}


_OI std::copy(_II, _II, _OI) [with _II = _GValue**; _OI = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79168;
  struct _GValue * * D.79169;
  struct _GValue * * D.79170;

  D.79169 = std::__miter_base<_GValue**> (__last);
  D.79170 = std::__miter_base<_GValue**> (__first);
  D.79168 = std::__copy_move_a2<false, _GValue**, _GValue**> (D.79170, D.79169, __result);
  return D.79168;
}


_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = _GValue**; _OI = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79175;
  struct _GValue * * D.79176;
  struct _GValue * * D.79177;
  struct _GValue * * D.79178;

  D.79176 = std::__niter_base<_GValue**> (__result);
  D.79177 = std::__niter_base<_GValue**> (__last);
  D.79178 = std::__niter_base<_GValue**> (__first);
  D.79175 = std::__copy_move_a<false, _GValue**, _GValue**> (D.79178, D.79177, D.79176);
  return D.79175;
}


_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = _GValue**; _OI = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.79181;
  typedef struct _GValue * _ValueTypeI;
  typedef struct _GValue * _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.79181 = std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<_GValue*> (__first, __last, __result);
  return D.79181;
}


static _Tp* std::__copy_move<_IsMove, true, std::random_access_iterator_tag>::__copy_m(const _Tp*, const _Tp*, _Tp*) [with _Tp = _GValue*; bool _IsMove = false] (struct _GValue * const * __first, struct _GValue * const * __last, struct _GValue * * __result)
{
  long int __last.26;
  long int __first.27;
  long int D.79185;
  long unsigned int _Num.28;
  long unsigned int D.79189;
  struct _GValue * * D.79191;
  const ptrdiff_t _Num;

  __last.26 = (long int) __last;
  __first.27 = (long int) __first;
  D.79185 = __last.26 - __first.27;
  _Num = D.79185 /[ex] 8;
  if (_Num != 0) goto <D.79186>; else goto <D.79187>;
  <D.79186>:
  _Num.28 = (long unsigned int) _Num;
  D.79189 = _Num.28 * 8;
  __builtin_memmove (__result, __first, D.79189);
  goto <D.79190>;
  <D.79187>:
  <D.79190>:
  _Num.28 = (long unsigned int) _Num;
  D.79189 = _Num.28 * 8;
  D.79191 = __result + D.79189;
  return D.79191;
}


static void __gnu_cxx::__alloc_traits<_Alloc>::destroy(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer) [with _Alloc = std::allocator<_GValue*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = _GValue**] (struct allocator & __a, struct _GValue * * __p)
{
  __gnu_cxx::new_allocator<_GValue*>::destroy (__a, __p);
}


void __gnu_cxx::new_allocator<_Tp>::destroy(__gnu_cxx::new_allocator<_Tp>::pointer) [with _Tp = _GValue*; __gnu_cxx::new_allocator<_Tp>::pointer = _GValue**] (struct new_allocator * const this, struct _GValue * * __p)
{
  GIMPLE_NOP
}


std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<_GValue*>] (struct _Vector_base * const this)
{
  struct _Tp_alloc_type & D.79193;

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


void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = _GValue**; _Tp = _GValue*] (struct _GValue * * __first, struct _GValue * * __last, struct allocator & D.77473)
{
  std::_Destroy<_GValue**> (__first, __last);
}


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = _GValue**] (struct _GValue * * __first, struct _GValue * * __last)
{
  typedef struct _GValue * _Value_type;

  std::_Destroy_aux<true>::__destroy<_GValue**> (__first, __last);
}


static void std::_Destroy_aux<true>::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = _GValue**] (struct _GValue * * D.78217, struct _GValue * * D.78218)
{
  GIMPLE_NOP
}


void std::_Vector_base<_Tp, _Alloc>::_M_deallocate(std::_Vector_base<_Tp, _Alloc>::pointer, std::size_t) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::_Vector_base<_Tp, _Alloc>::pointer = _GValue**; std::size_t = long unsigned int] (struct _Vector_base * const this, struct _GValue * * __p, size_t __n)
{
  struct _Vector_impl * D.79197;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.79195>; else goto <D.79196>;
  <D.79195>:
  D.79197 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::deallocate (D.79197, __p, __n);
  goto <D.79198>;
  <D.79196>:
  <D.79198>:
}


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<_GValue*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = _GValue**; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct _GValue * * __p, size_type __n)
{
  __gnu_cxx::new_allocator<_GValue*>::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 = _GValue*; __gnu_cxx::new_allocator<_Tp>::pointer = _GValue**; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _GValue * * __p, size_type D.74475)
{
  operator delete (__p);
}


std::auto_ptr<_Tp>::element_type& std::auto_ptr<_Tp>::operator*() const [with _Tp = Glib::Threads::Mutex; std::auto_ptr<_Tp>::element_type = Glib::Threads::Mutex] (const struct auto_ptr * const this)
{
  struct element_type & D.79199;
  void * D.79200;

  try
    {
      D.79199 = this->_M_ptr;
      return D.79199;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79200 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79200);
          
        }
    }
}


Glib::Threads::Mutex::Lock::Lock(Glib::Threads::Mutex&) (struct Lock * const this, struct Mutex & mutex)
{
  struct Mutex & D.79202;

  this->mutex_ = mutex;
  this->locked_ = 1;
  D.79202 = this->mutex_;
  Glib::Threads::Mutex::lock (D.79202);
}


std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = const Glib::ObjectBase*; _Tp = Glib::ObjectBase::ExtraObjectBaseData; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = Glib::ObjectBase::ExtraObjectBaseData; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = const Glib::ObjectBase*] (struct map * const this, const struct ObjectBase * const & __k)
{
  bool retval.29;
  bool iftmp.30;
  struct iterator D.77118;
  bool cleanup.31;
  bool D.79211;
  struct pair & D.79213;
  const struct ObjectBase * const * D.79214;
  struct key_compare D.77117;
  bool cleanup.32;
  bool D.79218;
  struct value_type D.77172;
  struct mapped_type D.77146;
  struct mapped_type & D.79222;
  struct pair & D.79223;
  struct iterator __i;

  try
    {
      __i = std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::lower_bound (this, __k);
      cleanup.31 = 0;
      try
        {
          cleanup.32 = 0;
          try
            {
              D.77118 = std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::end (this);
              cleanup.31 = 1;
              D.79211 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator== (&__i, &D.77118);
              if (D.79211 != 0) goto <D.79205>; else goto <D.79212>;
              <D.79212>:
              D.79213 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator* (&__i);
              D.79214 = &D.79213->first;
              std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::key_comp (this);
              cleanup.32 = 1;
              D.79218 = std::less<const Glib::ObjectBase*>::operator() (&D.77117, __k, D.79214);
              if (D.79218 != 0) goto <D.79205>; else goto <D.79206>;
              <D.79205>:
              iftmp.30 = 1;
              goto <D.79207>;
              <D.79206>:
              iftmp.30 = 0;
              <D.79207>:
              retval.29 = iftmp.30;
            }
          finally
            {
              if (cleanup.32 != 0) goto <D.79216>; else goto <D.79217>;
              <D.79216>:
              D.77117 = {CLOBBER};
              <D.79217>:
            }
        }
      finally
        {
          if (cleanup.31 != 0) goto <D.79209>; else goto <D.79210>;
          <D.79209>:
          D.77118 = {CLOBBER};
          <D.79210>:
        }
      if (retval.29 != 0) goto <D.79219>; else goto <D.79220>;
      <D.79219>:
      D.77146.custom_interface_classes.D.67283._M_impl._M_start = 0B;
      D.77146.custom_interface_classes.D.67283._M_impl._M_finish = 0B;
      D.77146.custom_interface_classes.D.67283._M_impl._M_end_of_storage = 0B;
      Glib::ObjectBase::ExtraObjectBaseData::ExtraObjectBaseData (&D.77146);
      try
        {
          std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>::pair (&D.77172, __k, &D.77146);
          try
            {
              __i = std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::insert (this, __i, &D.77172);
            }
          finally
            {
              std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>::~pair (&D.77172);
              D.77172 = {CLOBBER};
            }
        }
      finally
        {
          Glib::ObjectBase::ExtraObjectBaseData::~ExtraObjectBaseData (&D.77146);
          D.77146 = {CLOBBER};
        }
      goto <D.79221>;
      <D.79220>:
      <D.79221>:
      D.79223 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator* (&__i);
      D.79222 = &D.79223->second;
      return D.79222;
    }
  finally
    {
      __i = {CLOBBER};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::lower_bound(const key_type&) [with _Key = const Glib::ObjectBase*; _Tp = Glib::ObjectBase::ExtraObjectBaseData; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::key_type = const Glib::ObjectBase*] (struct map * const this, const struct ObjectBase * const & __x)
{
  struct iterator D.79237;
  struct _Rep_type * D.79238;

  D.79238 = &this->_M_t;
  D.79237 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::lower_bound (D.79238, __x);
  return D.79237;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::lower_bound(const key_type&) [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = const Glib::ObjectBase*] (struct _Rb_tree * const this, const struct ObjectBase * const & __k)
{
  struct iterator D.79240;
  struct _Rb_tree_node * D.79241;
  struct _Rb_tree_node * D.79242;

  D.79241 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_end (this);
  D.79242 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_begin (this);
  D.79240 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_lower_bound (this, D.79242, D.79241, __k);
  return D.79240;
}


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

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


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

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


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_lower_bound(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type, std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type, const _Key&) [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __x, struct _Rb_tree_node * __y, const struct ObjectBase * const & __k)
{
  bool retval.33;
  const struct ObjectBase * const & D.79249;
  struct less * D.79250;
  bool D.79251;
  struct iterator D.79255;
  struct iterator D.78222;

  goto <D.78224>;
  <D.78225>:
  D.79249 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (__x);
  D.79250 = &this->_M_impl._M_key_compare;
  D.79251 = std::less<const Glib::ObjectBase*>::operator() (D.79250, D.79249, __k);
  retval.33 = ~D.79251;
  if (retval.33 != 0) goto <D.79252>; else goto <D.79253>;
  <D.79252>:
  __y = __x;
  __x = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_left (__x);
  goto <D.79254>;
  <D.79253>:
  __x = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_right (__x);
  <D.79254>:
  <D.78224>:
  if (__x != 0B) goto <D.78225>; else goto <D.78223>;
  <D.78223>:
  std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.78222, __y);
  try
    {
      D.79255 = D.78222;
      return D.79255;
    }
  finally
    {
      D.78222 = {CLOBBER};
    }
}


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*] (const struct _Rb_tree_node * __x)
{
  const struct ObjectBase * const & D.79259;
  const struct value_type & D.79260;
  struct _Select1st D.78393;

  D.79260 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_value (__x);
  try
    {
      D.79259 = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator() (&D.78393, D.79260);
      return D.79259;
    }
  finally
    {
      D.78393 = {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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*] (const struct _Rb_tree_node * __x)
{
  const struct value_type & D.79264;

  D.79264 = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_M_valptr (__x);
  return D.79264;
}


const _Val* std::_Rb_tree_node<_Val>::_M_valptr() const [with _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>] (const struct _Rb_tree_node * const this)
{
  const struct pair * D.79267;
  const struct pair * D.79268;

  D.79268 = &this->_M_value_field;
  D.79267 = std::__addressof<const std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > (D.79268);
  return D.79267;
}


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

  D.79270 = __r;
  return D.79270;
}


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

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


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; 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.79274;

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


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; 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.79276;

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


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


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::end() [with _Key = const Glib::ObjectBase*; _Tp = Glib::ObjectBase::ExtraObjectBaseData; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct map * const this)
{
  struct iterator D.79278;
  struct _Rep_type * D.79279;

  D.79279 = &this->_M_t;
  D.79278 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::end (D.79279);
  return D.79278;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::end() [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree * const this)
{
  struct iterator D.79281;
  struct iterator D.77870;
  struct _Rb_tree_node_base * D.79282;

  D.79282 = &this->_M_impl._M_header;
  std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.77870, D.79282);
  try
    {
      D.79281 = D.77870;
      return D.79281;
    }
  finally
    {
      D.77870 = {CLOBBER};
    }
}


bool std::_Rb_tree_iterator<_Tp>::operator==(const _Self&) const [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (const struct _Rb_tree_iterator * const this, const struct _Self & __x)
{
  bool D.79285;
  struct _Rb_tree_node_base * D.79286;
  struct _Rb_tree_node_base * D.79287;

  D.79286 = this->_M_node;
  D.79287 = __x->_M_node;
  D.79285 = D.79286 == D.79287;
  return D.79285;
}


std::map<_Key, _Tp, _Compare, _Alloc>::key_compare std::map<_Key, _Tp, _Compare, _Alloc>::key_comp() const [with _Key = const Glib::ObjectBase*; _Tp = Glib::ObjectBase::ExtraObjectBaseData; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::key_compare = std::less<const Glib::ObjectBase*>] (const struct map * const this)
{
  struct key_compare D.79289;
  const struct _Rep_type * D.79290;

  D.79290 = &this->_M_t;
  std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::key_comp (D.79290);
  return D.79289;
}


_Compare std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_comp() const [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (const struct _Rb_tree * const this)
{
  struct less D.79292;

  return D.79292;
}


bool std::less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = const Glib::ObjectBase*] (const struct less * const this, const struct ObjectBase * const & __x, const struct ObjectBase * const & __y)
{
  bool D.79294;
  const struct ObjectBase * D.79295;
  const struct ObjectBase * D.79296;

  D.79295 = *__x;
  D.79296 = *__y;
  D.79294 = D.79295 < D.79296;
  return D.79294;
}


Glib::ObjectBase::ExtraObjectBaseData::ExtraObjectBaseData() (struct ExtraObjectBaseData * const this)
{
  struct interface_class_vector_type * D.79298;

  D.79298 = &this->custom_interface_classes;
  std::vector<const Glib::Interface_Class*>::vector (D.79298);
  try
    {

    }
  catch
    {
      D.79298 = &this->custom_interface_classes;
      std::vector<const Glib::Interface_Class*>::~vector (D.79298);
    }
}


std::vector<_Tp, _Alloc>::vector() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct vector * const this)
{
  struct _Vector_base * D.79299;

  D.79299 = &this->D.67283;
  std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_base (D.79299);
  try
    {

    }
  catch
    {
      D.79299 = &this->D.67283;
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::~_Vector_base (D.79299);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct _Vector_base * const this)
{
  struct _Vector_impl * D.79300;

  D.79300 = &this->_M_impl;
  std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::_Vector_impl (D.79300);
  try
    {

    }
  catch
    {
      D.79300 = &this->_M_impl;
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::~_Vector_impl (D.79300);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct _Vector_impl * const this)
{
  std::allocator<const Glib::Interface_Class*>::allocator (this);
  try
    {
      this->_M_start = 0B;
      this->_M_finish = 0B;
      this->_M_end_of_storage = 0B;
    }
  catch
    {
      std::allocator<const Glib::Interface_Class*>::~allocator (this);
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<const Glib::Interface_Class*>::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<const Glib::Interface_Class*>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79301 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79301);
          
        }
    }
}


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

  try
    {
      {

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


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = const Glib::ObjectBase* const; _T2 = Glib::ObjectBase::ExtraObjectBaseData] (struct pair * const this, const struct ObjectBase * const & __a, const struct ExtraObjectBaseData & __b)
{
  const struct ObjectBase * D.79303;
  struct ExtraObjectBaseData * D.79304;

  D.79303 = *__a;
  this->first = D.79303;
  D.79304 = &this->second;
  Glib::ObjectBase::ExtraObjectBaseData::ExtraObjectBaseData (D.79304, __b);
  try
    {

    }
  catch
    {
      D.79304 = &this->second;
      Glib::ObjectBase::ExtraObjectBaseData::~ExtraObjectBaseData (D.79304);
    }
}


Glib::ObjectBase::ExtraObjectBaseData::ExtraObjectBaseData(const Glib::ObjectBase::ExtraObjectBaseData&) (struct ExtraObjectBaseData * const this, const struct ExtraObjectBaseData & D.77142)
{
  const struct interface_class_vector_type * D.79305;
  struct interface_class_vector_type * D.79306;

  D.79305 = &D.77142->custom_interface_classes;
  D.79306 = &this->custom_interface_classes;
  std::vector<const Glib::Interface_Class*>::vector (D.79306, D.79305);
  try
    {

    }
  catch
    {
      D.79306 = &this->custom_interface_classes;
      std::vector<const Glib::Interface_Class*>::~vector (D.79306);
    }
}


std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct vector * const this, const struct vector & __x)
{
  const struct _Vector_base * D.79307;
  const struct _Tp_alloc_type & D.79308;
  const struct allocator & D.79309;
  long unsigned int D.79310;
  struct _Vector_base * D.79311;
  struct _Tp_alloc_type & D.79312;
  const struct Interface_Class * * D.79313;
  struct __normal_iterator D.79314;
  struct __normal_iterator D.79315;
  const struct Interface_Class * * D.79316;

  D.79307 = &__x->D.67283;
  D.79308 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79307);
  D.79309 = __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::_S_select_on_copy (D.79308);
  D.79310 = std::vector<const Glib::Interface_Class*>::size (__x);
  D.79311 = &this->D.67283;
  std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_base (D.79311, D.79310, D.79309);
  try
    {
      D.79311 = &this->D.67283;
      D.79312 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79311);
      D.79313 = this->D.67283._M_impl._M_start;
      D.79314 = std::vector<const Glib::Interface_Class*>::end (__x);
      D.79315 = std::vector<const Glib::Interface_Class*>::begin (__x);
      D.79316 = std::__uninitialized_copy_a<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, const Glib::Interface_Class**, const Glib::Interface_Class*> (D.79315, D.79314, D.79313, D.79312);
      this->D.67283._M_impl._M_finish = D.79316;
    }
  catch
    {
      D.79311 = &this->D.67283;
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::~_Vector_base (D.79311);
    }
}


const _Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<const Glib::Interface_Class*>] (const struct _Vector_base * const this)
{
  const struct _Tp_alloc_type & D.79319;

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


static const _Alloc& __gnu_cxx::__alloc_traits<_Alloc>::_S_select_on_copy(const _Alloc&) [with _Alloc = std::allocator<const Glib::Interface_Class*>] (const struct allocator & __a)
{
  const struct allocator & D.79321;

  D.79321 = __a;
  return D.79321;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.79323;
  const struct Interface_Class * * D.79324;
  long int D.79325;
  const struct Interface_Class * * D.79326;
  long int D.79327;
  long int D.79328;
  long int D.79329;

  D.79324 = this->D.67283._M_impl._M_finish;
  D.79325 = (long int) D.79324;
  D.79326 = this->D.67283._M_impl._M_start;
  D.79327 = (long int) D.79326;
  D.79328 = D.79325 - D.79327;
  D.79329 = D.79328 /[ex] 8;
  D.79323 = (size_type) D.79329;
  return D.79323;
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base(std::size_t, const allocator_type&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::size_t = long unsigned int; std::_Vector_base<_Tp, _Alloc>::allocator_type = std::allocator<const Glib::Interface_Class*>] (struct _Vector_base * const this, size_t __n, const struct allocator_type & __a)
{
  struct _Vector_impl * D.79331;

  D.79331 = &this->_M_impl;
  std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::_Vector_impl (D.79331, __a);
  try
    {
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_create_storage (this, __n);
    }
  catch
    {
      D.79331 = &this->_M_impl;
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::~_Vector_impl (D.79331);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl(const _Tp_alloc_type&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<const Glib::Interface_Class*>] (struct _Vector_impl * const this, const struct _Tp_alloc_type & __a)
{
  std::allocator<const Glib::Interface_Class*>::allocator (this, __a);
  try
    {
      this->_M_start = 0B;
      this->_M_finish = 0B;
      this->_M_end_of_storage = 0B;
    }
  catch
    {
      std::allocator<const Glib::Interface_Class*>::~allocator (this);
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<const Glib::Interface_Class*>::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<const Glib::Interface_Class*>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79333 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79333);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = const Glib::Interface_Class*] (struct new_allocator * const this, const struct new_allocator & D.66623)
{
  void * D.79334;

  try
    {
      {

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


void std::_Vector_base<_Tp, _Alloc>::_M_create_storage(std::size_t) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  const struct Interface_Class * * D.79335;
  const struct Interface_Class * * D.79336;
  long unsigned int D.79337;
  const struct Interface_Class * * D.79338;

  D.79335 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_allocate (this, __n);
  this->_M_impl._M_start = D.79335;
  D.79336 = this->_M_impl._M_start;
  this->_M_impl._M_finish = D.79336;
  D.79336 = this->_M_impl._M_start;
  D.79337 = __n * 8;
  D.79338 = D.79336 + D.79337;
  this->_M_impl._M_end_of_storage = D.79338;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::_Vector_base<_Tp, _Alloc>::pointer = const Glib::Interface_Class**; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  const struct Interface_Class * * D.79340;
  const struct Interface_Class * * iftmp.34;
  struct _Vector_impl * D.79344;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.79342>; else goto <D.79343>;
  <D.79342>:
  D.79344 = &this->_M_impl;
  iftmp.34 = __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::allocate (D.79344, __n);
  goto <D.79345>;
  <D.79343>:
  iftmp.34 = 0B;
  <D.79345>:
  D.79340 = iftmp.34;
  return D.79340;
}


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<const Glib::Interface_Class*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = const Glib::Interface_Class**; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  const struct Interface_Class * * D.79348;

  D.79348 = __gnu_cxx::new_allocator<const Glib::Interface_Class*>::allocate (__a, __n, 0B);
  return D.79348;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = const Glib::Interface_Class*; __gnu_cxx::new_allocator<_Tp>::pointer = const Glib::Interface_Class**; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.66596)
{
  bool retval.35;
  long unsigned int D.79352;
  const struct Interface_Class * * D.79355;
  long unsigned int D.79356;

  D.79352 = __gnu_cxx::new_allocator<const Glib::Interface_Class*>::max_size (this);
  retval.35 = D.79352 < __n;
  if (retval.35 != 0) goto <D.79353>; else goto <D.79354>;
  <D.79353>:
  std::__throw_bad_alloc ();
  <D.79354>:
  D.79356 = __n * 8;
  D.79355 = operator new (D.79356);
  return D.79355;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = const Glib::Interface_Class*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.79359;
  void * D.79360;

  try
    {
      D.79359 = 2305843009213693951;
      return D.79359;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79360 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79360);
          
        }
    }
}


std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::~_Vector_impl() (struct _Vector_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<const Glib::Interface_Class*>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.77877>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<const Glib::Interface_Class*>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.78237>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79362 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79362);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<const Glib::Interface_Class*>] (struct _Vector_base * const this)
{
  struct _Tp_alloc_type & D.79364;

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


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::end() const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::Interface_Class* const*] (const struct vector * const this)
{
  struct const_iterator D.79366;
  struct const_iterator D.78256;
  const struct Interface_Class * const * const D.78255;
  const struct Interface_Class * * D.79367;

  D.79367 = this->D.67283._M_impl._M_finish;
  D.78255 = D.79367;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >::__normal_iterator (&D.78256, &D.78255);
      try
        {
          D.79366 = D.78256;
          return D.79366;
        }
      finally
        {
          D.78256 = {CLOBBER};
        }
    }
  finally
    {
      D.78255 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = const Glib::Interface_Class* const*; _Container = std::vector<const Glib::Interface_Class*>] (struct __normal_iterator * const this, const struct Interface_Class * const * const & __i)
{
  const struct Interface_Class * const * D.79371;

  D.79371 = *__i;
  this->_M_current = D.79371;
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::begin() const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::Interface_Class* const*] (const struct vector * const this)
{
  struct const_iterator D.79372;
  struct const_iterator D.78253;
  const struct Interface_Class * const * const D.78252;
  const struct Interface_Class * * D.79373;

  D.79373 = this->D.67283._M_impl._M_start;
  D.78252 = D.79373;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >::__normal_iterator (&D.78253, &D.78252);
      try
        {
          D.79372 = D.78253;
          return D.79372;
        }
      finally
        {
          D.78253 = {CLOBBER};
        }
    }
  finally
    {
      D.78252 = {CLOBBER};
    }
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; _ForwardIterator = const Glib::Interface_Class**; _Tp = const Glib::Interface_Class*] (struct __normal_iterator __first, struct __normal_iterator __last, const struct Interface_Class * * __result, struct allocator & D.77991)
{
  const struct Interface_Class * * D.79377;

  D.79377 = std::uninitialized_copy<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79377;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; _ForwardIterator = const Glib::Interface_Class**] (struct __normal_iterator __first, struct __normal_iterator __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79380;
  typedef const struct Interface_Class * _ValueType1;
  typedef const struct Interface_Class * _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.79380 = std::__uninitialized_copy<true>::__uninit_copy<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79380;
}


static _ForwardIterator std::__uninitialized_copy<true>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; _ForwardIterator = const Glib::Interface_Class**] (struct __normal_iterator __first, struct __normal_iterator __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79383;

  D.79383 = std::copy<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79383;
}


_OI std::copy(_II, _II, _OI) [with _II = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; _OI = const Glib::Interface_Class**] (struct __normal_iterator __first, struct __normal_iterator __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79386;
  struct __normal_iterator D.79387;
  struct __normal_iterator D.79388;

  D.79387 = std::__miter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> > > (__last);
  D.79388 = std::__miter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> > > (__first);
  D.79386 = std::__copy_move_a2<false, __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, const Glib::Interface_Class**> (D.79388, D.79387, __result);
  return D.79386;
}


typename std::_Miter_base<_Iterator>::iterator_type std::__miter_base(_Iterator) [with _Iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; typename std::_Miter_base<_Iterator>::iterator_type = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >] (struct __normal_iterator __it)
{
  struct iterator_type D.79391;

  D.79391 = std::_Iter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, false>::_S_base (__it);
  return D.79391;
}


static std::_Iter_base<_Iterator, _HasBase>::iterator_type std::_Iter_base<_Iterator, _HasBase>::_S_base(_Iterator) [with _Iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; bool _HasBase = false; std::_Iter_base<_Iterator, _HasBase>::iterator_type = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >] (struct __normal_iterator __it)
{
  struct iterator_type D.79393;

  D.79393 = __it;
  return D.79393;
}


_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; _OI = const Glib::Interface_Class**] (struct __normal_iterator __first, struct __normal_iterator __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79395;
  const struct Interface_Class * * D.79396;
  const struct Interface_Class * const * D.79397;
  const struct Interface_Class * const * D.79398;

  D.79396 = std::__niter_base<const Glib::Interface_Class**> (__result);
  D.79397 = std::__niter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> > > (__last);
  D.79398 = std::__niter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> > > (__first);
  D.79395 = std::__copy_move_a<false, const Glib::Interface_Class* const*, const Glib::Interface_Class**> (D.79398, D.79397, D.79396);
  return D.79395;
}


typename std::_Niter_base<_Iterator>::iterator_type std::__niter_base(_Iterator) [with _Iterator = const Glib::Interface_Class**; typename std::_Niter_base<_Iterator>::iterator_type = const Glib::Interface_Class**] (const struct Interface_Class * * __it)
{
  const struct Interface_Class * * D.79403;

  D.79403 = std::_Iter_base<const Glib::Interface_Class**, false>::_S_base (__it);
  return D.79403;
}


static std::_Iter_base<_Iterator, _HasBase>::iterator_type std::_Iter_base<_Iterator, _HasBase>::_S_base(_Iterator) [with _Iterator = const Glib::Interface_Class**; bool _HasBase = false; std::_Iter_base<_Iterator, _HasBase>::iterator_type = const Glib::Interface_Class**] (const struct Interface_Class * * __it)
{
  const struct Interface_Class * * D.79405;

  D.79405 = __it;
  return D.79405;
}


typename std::_Niter_base<_Iterator>::iterator_type std::__niter_base(_Iterator) [with _Iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; typename std::_Niter_base<_Iterator>::iterator_type = const Glib::Interface_Class* const*] (struct __normal_iterator __it)
{
  const struct Interface_Class * const * D.79407;

  D.79407 = std::_Iter_base<__gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >, true>::_S_base (__it);
  return D.79407;
}


static std::_Iter_base<_Iterator, true>::iterator_type std::_Iter_base<_Iterator, true>::_S_base(_Iterator) [with _Iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >; std::_Iter_base<_Iterator, true>::iterator_type = const Glib::Interface_Class* const*] (struct __normal_iterator __it)
{
  const struct Interface_Class * const * D.79410;
  const struct Interface_Class * const * const & D.79411;

  D.79411 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class* const*, std::vector<const Glib::Interface_Class*> >::base (&__it);
  D.79410 = *D.79411;
  return D.79410;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = const Glib::Interface_Class* const*; _Container = std::vector<const Glib::Interface_Class*>] (const struct __normal_iterator * const this)
{
  const struct Interface_Class * const * const & D.79413;

  D.79413 = &this->_M_current;
  return D.79413;
}


_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = const Glib::Interface_Class* const*; _OI = const Glib::Interface_Class**] (const struct Interface_Class * const * __first, const struct Interface_Class * const * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79415;
  typedef const struct Interface_Class * _ValueTypeI;
  typedef const struct Interface_Class * _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.79415 = std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<const Glib::Interface_Class*> (__first, __last, __result);
  return D.79415;
}


static _Tp* std::__copy_move<_IsMove, true, std::random_access_iterator_tag>::__copy_m(const _Tp*, const _Tp*, _Tp*) [with _Tp = const Glib::Interface_Class*; bool _IsMove = false] (const struct Interface_Class * const * __first, const struct Interface_Class * const * __last, const struct Interface_Class * * __result)
{
  long int __last.36;
  long int __first.37;
  long int D.79419;
  long unsigned int _Num.38;
  long unsigned int D.79423;
  const struct Interface_Class * * D.79425;
  const ptrdiff_t _Num;

  __last.36 = (long int) __last;
  __first.37 = (long int) __first;
  D.79419 = __last.36 - __first.37;
  _Num = D.79419 /[ex] 8;
  if (_Num != 0) goto <D.79420>; else goto <D.79421>;
  <D.79420>:
  _Num.38 = (long unsigned int) _Num;
  D.79423 = _Num.38 * 8;
  __builtin_memmove (__result, __first, D.79423);
  goto <D.79424>;
  <D.79421>:
  <D.79424>:
  _Num.38 = (long unsigned int) _Num;
  D.79423 = _Num.38 * 8;
  D.79425 = __result + D.79423;
  return D.79425;
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct _Vector_base * const this)
{
  const struct Interface_Class * * D.79427;
  long int D.79428;
  const struct Interface_Class * * D.79429;
  long int D.79430;
  long int D.79431;
  long int D.79432;
  long unsigned int D.79433;
  struct _Vector_impl * D.79434;

  {
    try
      {
        try
          {
            D.79427 = this->_M_impl._M_end_of_storage;
            D.79428 = (long int) D.79427;
            D.79429 = this->_M_impl._M_start;
            D.79430 = (long int) D.79429;
            D.79431 = D.79428 - D.79430;
            D.79432 = D.79431 /[ex] 8;
            D.79433 = (long unsigned int) D.79432;
            D.79429 = this->_M_impl._M_start;
            std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_deallocate (this, D.79429, D.79433);
          }
        finally
          {
            D.79434 = &this->_M_impl;
            std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_Vector_impl::~_Vector_impl (D.79434);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.77887>:
}


void std::_Vector_base<_Tp, _Alloc>::_M_deallocate(std::_Vector_base<_Tp, _Alloc>::pointer, std::size_t) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::_Vector_base<_Tp, _Alloc>::pointer = const Glib::Interface_Class**; std::size_t = long unsigned int] (struct _Vector_base * const this, const struct Interface_Class * * __p, size_t __n)
{
  struct _Vector_impl * D.79439;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.79437>; else goto <D.79438>;
  <D.79437>:
  D.79439 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::deallocate (D.79439, __p, __n);
  goto <D.79440>;
  <D.79438>:
  <D.79440>:
}


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<const Glib::Interface_Class*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = const Glib::Interface_Class**; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, const struct Interface_Class * * __p, size_type __n)
{
  __gnu_cxx::new_allocator<const Glib::Interface_Class*>::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 = const Glib::Interface_Class*; __gnu_cxx::new_allocator<_Tp>::pointer = const Glib::Interface_Class**; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, const struct Interface_Class * * __p, size_type D.66600)
{
  operator delete (__p);
}


std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::insert(std::map<_Key, _Tp, _Compare, _Alloc>::iterator, const value_type&) [with _Key = const Glib::ObjectBase*; _Tp = Glib::ObjectBase::ExtraObjectBaseData; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::map<_Key, _Tp, _Compare, _Alloc>::value_type = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>] (struct map * const this, struct iterator __position, const struct value_type & __x)
{
  struct iterator D.79441;
  struct const_iterator D.77642;
  struct _Rep_type * D.79442;

  std::_Rb_tree_const_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_const_iterator (&D.77642, &__position);
  try
    {
      D.79442 = &this->_M_t;
      D.79441 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_insert_unique_ (D.79442, D.77642, __x);
      return D.79441;
    }
  finally
    {
      D.77642 = {CLOBBER};
    }
}


std::_Rb_tree_const_iterator<_Tp>::_Rb_tree_const_iterator(const iterator&) [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_const_iterator<_Tp>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree_const_iterator * const this, const struct iterator & __it)
{
  struct _Rb_tree_node_base * D.79446;

  D.79446 = __it->_M_node;
  this->_M_node = D.79446;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_unique_(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, const _Val&) [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree * const this, struct const_iterator __position, const struct pair & __v)
{
  struct _Select1st D.78036;
  const struct ObjectBase * const & D.79447;
  struct _Rb_tree_node_base * D.79448;
  struct iterator D.79451;
  struct _Rb_tree_node_base * D.79452;
  struct iterator D.78058;
  struct pair __res;

  try
    {
      try
        {
          D.79447 = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator() (&D.78036, __v);
          __res = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_insert_hint_unique_pos (this, __position, D.79447);
        }
      finally
        {
          D.78036 = {CLOBBER};
        }
      D.79448 = __res.second;
      if (D.79448 != 0B) goto <D.79449>; else goto <D.79450>;
      <D.79449>:
      D.79448 = __res.second;
      D.79452 = __res.first;
      D.79451 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_insert_ (this, D.79452, D.79448, __v);
      return D.79451;
      <D.79450>:
      D.79452 = __res.first;
      std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.78058, D.79452);
      try
        {
          D.79451 = D.78058;
          return D.79451;
        }
      finally
        {
          D.78058 = {CLOBBER};
        }
    }
  finally
    {
      __res = {CLOBBER};
    }
}


std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_hint_unique_pos(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, const key_type&) [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = const Glib::ObjectBase*] (struct _Rb_tree * const this, struct const_iterator __position, const struct ObjectBase * const & __k)
{
  bool retval.39;
  struct _Rb_tree_node_base * D.79459;
  struct _Rb_tree_node * D.79460;
  bool retval.40;
  bool iftmp.41;
  long unsigned int D.79467;
  struct _Rb_tree_node_base * & D.79469;
  struct _Rb_tree_node_base * D.79470;
  const struct ObjectBase * const & D.79471;
  struct less * D.79472;
  bool D.79473;
  struct pair D.79477;
  struct _Res D.78269;
  struct _Rb_tree_node_base * & D.79478;
  struct _Rb_tree_node_base * const D.78268;
  bool retval.42;
  const struct ObjectBase * const & D.79480;
  bool retval.43;
  struct _Rb_tree_node_base * & D.79484;
  struct _Rb_tree_node_base * D.79485;
  struct _Res D.78273;
  struct _Rb_tree_node_base * & D.79488;
  struct _Rb_tree_node_base * & D.79489;
  bool retval.44;
  struct _Self & D.79491;
  struct _Rb_tree_node_base * D.79492;
  const struct ObjectBase * const & D.79493;
  bool retval.45;
  struct _Rb_tree_node_base * D.79497;
  struct _Rb_tree_node * D.79498;
  struct _Res D.78275;
  struct _Rb_tree_node_base * const D.78274;
  struct _Res D.78276;
  bool retval.46;
  const struct ObjectBase * const & D.79502;
  bool retval.47;
  struct _Rb_tree_node_base * & D.79506;
  struct _Rb_tree_node_base * D.79507;
  struct _Res D.78281;
  struct _Rb_tree_node_base * & D.79510;
  struct _Rb_tree_node_base * const D.78280;
  bool retval.48;
  struct _Self & D.79512;
  struct _Rb_tree_node_base * D.79513;
  const struct ObjectBase * const & D.79514;
  bool retval.49;
  struct _Rb_tree_node * D.79518;
  struct _Res D.78283;
  struct _Rb_tree_node_base * const D.78282;
  struct _Res D.78284;
  struct _Res D.78287;
  struct _Rb_tree_node_base * const D.78286;
  struct iterator __pos;
  typedef struct _Res _Res;

  try
    {
      __pos = std::_Rb_tree_const_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_M_const_cast (&__position);
      {
        D.79459 = __pos._M_node;
        D.79460 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_end (this);
        retval.39 = D.79459 == D.79460;
        if (retval.39 != 0) goto <D.79461>; else goto <D.79462>;
        <D.79461>:
        D.79467 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::size (this);
        if (D.79467 != 0) goto <D.79468>; else goto <D.79465>;
        <D.79468>:
        D.79469 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_rightmost (this);
        D.79470 = *D.79469;
        D.79471 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79470);
        D.79472 = &this->_M_impl._M_key_compare;
        D.79473 = std::less<const Glib::ObjectBase*>::operator() (D.79472, D.79471, __k);
        if (D.79473 != 0) goto <D.79474>; else goto <D.79465>;
        <D.79474>:
        iftmp.41 = 1;
        goto <D.79466>;
        <D.79465>:
        iftmp.41 = 0;
        <D.79466>:
        retval.40 = iftmp.41;
        if (retval.40 != 0) goto <D.79475>; else goto <D.79476>;
        <D.79475>:
        D.79478 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_rightmost (this);
        D.78268 = 0B;
        try
          {
            std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78269, &D.78268, D.79478);
            try
              {
                D.79477 = D.78269;
                return D.79477;
              }
            finally
              {
                D.78269 = {CLOBBER};
              }
          }
        finally
          {
            D.78268 = {CLOBBER};
          }
        <D.79476>:
        D.79477 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_insert_unique_pos (this, __k);
        return D.79477;
        <D.79462>:
        {
          {
            D.79459 = __pos._M_node;
            D.79480 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79459);
            D.79472 = &this->_M_impl._M_key_compare;
            retval.42 = std::less<const Glib::ObjectBase*>::operator() (D.79472, __k, D.79480);
            if (retval.42 != 0) goto <D.79481>; else goto <D.79482>;
            <D.79481>:
            {
              struct iterator __before;

              try
                {
                  __before = __pos;
                  D.79459 = __pos._M_node;
                  D.79484 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_leftmost (this);
                  D.79485 = *D.79484;
                  retval.43 = D.79459 == D.79485;
                  if (retval.43 != 0) goto <D.79486>; else goto <D.79487>;
                  <D.79486>:
                  D.79488 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_leftmost (this);
                  D.79489 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_leftmost (this);
                  std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78273, D.79489, D.79488);
                  try
                    {
                      D.79477 = D.78273;
                      return D.79477;
                    }
                  finally
                    {
                      D.78273 = {CLOBBER};
                    }
                  <D.79487>:
                  D.79491 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator-- (&__before);
                  D.79492 = D.79491->_M_node;
                  D.79493 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79492);
                  D.79472 = &this->_M_impl._M_key_compare;
                  retval.44 = std::less<const Glib::ObjectBase*>::operator() (D.79472, D.79493, __k);
                  if (retval.44 != 0) goto <D.79494>; else goto <D.79495>;
                  <D.79494>:
                  D.79497 = __before._M_node;
                  D.79498 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_right (D.79497);
                  retval.45 = D.79498 == 0B;
                  if (retval.45 != 0) goto <D.79499>; else goto <D.79500>;
                  <D.79499>:
                  D.78274 = 0B;
                  try
                    {
                      std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78275, &D.78274, &__before._M_node);
                      try
                        {
                          D.79477 = D.78275;
                          return D.79477;
                        }
                      finally
                        {
                          D.78275 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.78274 = {CLOBBER};
                    }
                  <D.79500>:
                  std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78276, &__pos._M_node, &__pos._M_node);
                  try
                    {
                      D.79477 = D.78276;
                      return D.79477;
                    }
                  finally
                    {
                      D.78276 = {CLOBBER};
                    }
                  <D.79495>:
                  D.79477 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_insert_unique_pos (this, __k);
                  return D.79477;
                }
              finally
                {
                  __before = {CLOBBER};
                }
            }
            <D.79482>:
            {
              {
                D.79459 = __pos._M_node;
                D.79502 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79459);
                D.79472 = &this->_M_impl._M_key_compare;
                retval.46 = std::less<const Glib::ObjectBase*>::operator() (D.79472, D.79502, __k);
                if (retval.46 != 0) goto <D.79503>; else goto <D.79504>;
                <D.79503>:
                {
                  struct iterator __after;

                  try
                    {
                      __after = __pos;
                      D.79459 = __pos._M_node;
                      D.79506 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_rightmost (this);
                      D.79507 = *D.79506;
                      retval.47 = D.79459 == D.79507;
                      if (retval.47 != 0) goto <D.79508>; else goto <D.79509>;
                      <D.79508>:
                      D.79510 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_rightmost (this);
                      D.78280 = 0B;
                      try
                        {
                          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78281, &D.78280, D.79510);
                          try
                            {
                              D.79477 = D.78281;
                              return D.79477;
                            }
                          finally
                            {
                              D.78281 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.78280 = {CLOBBER};
                        }
                      <D.79509>:
                      D.79512 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator++ (&__after);
                      D.79513 = D.79512->_M_node;
                      D.79514 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79513);
                      D.79472 = &this->_M_impl._M_key_compare;
                      retval.48 = std::less<const Glib::ObjectBase*>::operator() (D.79472, __k, D.79514);
                      if (retval.48 != 0) goto <D.79515>; else goto <D.79516>;
                      <D.79515>:
                      D.79459 = __pos._M_node;
                      D.79518 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_right (D.79459);
                      retval.49 = D.79518 == 0B;
                      if (retval.49 != 0) goto <D.79519>; else goto <D.79520>;
                      <D.79519>:
                      D.78282 = 0B;
                      try
                        {
                          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78283, &D.78282, &__pos._M_node);
                          try
                            {
                              D.79477 = D.78283;
                              return D.79477;
                            }
                          finally
                            {
                              D.78283 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.78282 = {CLOBBER};
                        }
                      <D.79520>:
                      std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78284, &__after._M_node, &__after._M_node);
                      try
                        {
                          D.79477 = D.78284;
                          return D.79477;
                        }
                      finally
                        {
                          D.78284 = {CLOBBER};
                        }
                      <D.79516>:
                      D.79477 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_insert_unique_pos (this, __k);
                      return D.79477;
                    }
                  finally
                    {
                      __after = {CLOBBER};
                    }
                }
                <D.79504>:
                D.78286 = 0B;
                try
                  {
                    std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78287, &__pos._M_node, &D.78286);
                    try
                      {
                        D.79477 = D.78287;
                        return D.79477;
                      }
                    finally
                      {
                        D.78287 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.78286 = {CLOBBER};
                  }
              }
            }
          }
        }
      }
    }
  finally
    {
      __pos = {CLOBBER};
    }
}


std::_Rb_tree_const_iterator<_Tp>::iterator std::_Rb_tree_const_iterator<_Tp>::_M_const_cast() const [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_const_iterator<_Tp>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (const struct _Rb_tree_const_iterator * const this)
{
  struct iterator D.79546;
  struct iterator D.78433;
  const struct _Rb_tree_node_base * D.79547;

  D.79547 = this->_M_node;
  std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.78433, D.79547);
  try
    {
      D.79546 = D.78433;
      return D.79546;
    }
  finally
    {
      D.78433 = {CLOBBER};
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size() const [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type = long unsigned int] (const struct _Rb_tree * const this)
{
  size_type D.79550;

  D.79550 = this->_M_impl._M_node_count;
  return D.79550;
}


std::_Rb_tree_node_base*& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_leftmost() [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; 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 * & D.79552;

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


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator--() [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.79554;
  struct _Rb_tree_node_base * D.79555;
  struct _Self & D.79556;

  D.79554 = this->_M_node;
  D.79555 = std::_Rb_tree_decrement (D.79554);
  this->_M_node = D.79555;
  D.79556 = this;
  return D.79556;
}


std::_Rb_tree_node_base*& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_rightmost() [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; 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 * & D.79558;

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


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator++() [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.79560;
  struct _Rb_tree_node_base * D.79561;
  struct _Self & D.79562;

  D.79560 = this->_M_node;
  D.79561 = std::_Rb_tree_increment (D.79560);
  this->_M_node = D.79561;
  D.79562 = this;
  return D.79562;
}


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; 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 ObjectBase * const & D.79564;
  const struct value_type & D.79565;
  struct _Select1st D.78436;

  D.79565 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_value (__x);
  try
    {
      D.79564 = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator() (&D.78436, D.79565);
      return D.79564;
    }
  finally
    {
      D.78436 = {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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; 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.79569;

  D.79569 = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_M_valptr (__x);
  return D.79569;
}


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = const Glib::ObjectBase*] (struct _Rb_tree * const this, const struct ObjectBase * const & __k)
{
  const struct ObjectBase * const & D.79572;
  struct less * D.79573;
  struct _Rb_tree_node * iftmp.50;
  bool retval.51;
  struct iterator D.78448;
  struct pair D.79583;
  struct _Res D.78451;
  struct _Rb_tree_node_base * const D.78450;
  struct _Rb_tree_node_base * const D.78449;
  bool retval.52;
  struct _Rb_tree_node_base * D.79586;
  const struct ObjectBase * const & D.79587;
  struct _Res D.78454;
  struct _Rb_tree_node_base * const D.78453;
  struct _Rb_tree_node_base * const D.78452;
  struct _Res D.78456;
  struct _Rb_tree_node_base * const D.78455;
  typedef struct _Res _Res;
  struct _Rb_tree_node * __x;
  struct _Rb_tree_node * __y;
  bool __comp;
  struct iterator __j;

  try
    {
      __x = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_begin (this);
      __y = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_end (this);
      __comp = 1;
      goto <D.78458>;
      <D.78459>:
      __y = __x;
      D.79572 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (__x);
      D.79573 = &this->_M_impl._M_key_compare;
      __comp = std::less<const Glib::ObjectBase*>::operator() (D.79573, __k, D.79572);
      if (__comp != 0) goto <D.79575>; else goto <D.79576>;
      <D.79575>:
      iftmp.50 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_left (__x);
      goto <D.79577>;
      <D.79576>:
      iftmp.50 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_right (__x);
      <D.79577>:
      __x = iftmp.50;
      <D.78458>:
      if (__x != 0B) goto <D.78459>; else goto <D.78457>;
      <D.78457>:
      std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&__j, __y);
      if (__comp != 0) goto <D.79578>; else goto <D.79579>;
      <D.79578>:
      D.78448 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::begin (this);
      try
        {
          retval.51 = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator== (&__j, &D.78448);
        }
      finally
        {
          D.78448 = {CLOBBER};
        }
      if (retval.51 != 0) goto <D.79581>; else goto <D.79582>;
      <D.79581>:
      D.78450 = __y;
      try
        {
          D.78449 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78451, &D.78449, &D.78450);
              try
                {
                  D.79583 = D.78451;
                  return D.79583;
                }
              finally
                {
                  D.78451 = {CLOBBER};
                }
            }
          finally
            {
              D.78449 = {CLOBBER};
            }
        }
      finally
        {
          D.78450 = {CLOBBER};
        }
      <D.79582>:
      std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator-- (&__j);
      goto <D.79584>;
      <D.79579>:
      <D.79584>:
      D.79586 = __j._M_node;
      D.79587 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (D.79586);
      D.79573 = &this->_M_impl._M_key_compare;
      retval.52 = std::less<const Glib::ObjectBase*>::operator() (D.79573, D.79587, __k);
      if (retval.52 != 0) goto <D.79588>; else goto <D.79589>;
      <D.79588>:
      D.78453 = __y;
      try
        {
          D.78452 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78454, &D.78452, &D.78453);
              try
                {
                  D.79583 = D.78454;
                  return D.79583;
                }
              finally
                {
                  D.78454 = {CLOBBER};
                }
            }
          finally
            {
              D.78452 = {CLOBBER};
            }
        }
      finally
        {
          D.78453 = {CLOBBER};
        }
      <D.79589>:
      D.78455 = 0B;
      try
        {
          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.78456, &__j._M_node, &D.78455);
          try
            {
              D.79583 = D.78456;
              return D.79583;
            }
          finally
            {
              D.78456 = {CLOBBER};
            }
        }
      finally
        {
          D.78455 = {CLOBBER};
        }
    }
  finally
    {
      __j = {CLOBBER};
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::begin() [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >] (struct _Rb_tree * const this)
{
  struct iterator D.79603;
  struct iterator D.78538;
  struct _Rb_tree_node_base * D.79604;

  D.79604 = this->_M_impl._M_header._M_left;
  std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.78538, D.79604);
  try
    {
      D.79603 = D.78538;
      return D.79603;
    }
  finally
    {
      D.78538 = {CLOBBER};
    }
}


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.79607;
  struct _Rb_tree_node_base * D.79608;

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


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 = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; 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.53;
  struct _Rb_tree_node * D.79614;
  const struct ObjectBase * const & D.79616;
  struct _Select1st D.78291;
  bool cleanup.54;
  const struct ObjectBase * const & D.79620;
  struct less * D.79621;
  bool D.79622;
  struct _Rb_tree_node_base * D.79623;
  int D.79624;
  long unsigned int D.79625;
  long unsigned int D.79626;
  struct iterator D.79627;
  struct iterator D.78293;
  bool __insert_left;
  struct _Rb_tree_node * __z;

  cleanup.54 = 0;
  try
    {
      if (__x != 0B) goto <D.79610>; else goto <D.79613>;
      <D.79613>:
      D.79614 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_end (this);
      if (D.79614 == __p) goto <D.79610>; else goto <D.79615>;
      <D.79615>:
      D.79616 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_S_key (__p);
      cleanup.54 = 1;
      D.79620 = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::operator() (&D.78291, __v);
      D.79621 = &this->_M_impl._M_key_compare;
      D.79622 = std::less<const Glib::ObjectBase*>::operator() (D.79621, D.79620, D.79616);
      if (D.79622 != 0) goto <D.79610>; else goto <D.79611>;
      <D.79610>:
      iftmp.53 = 1;
      goto <D.79612>;
      <D.79611>:
      iftmp.53 = 0;
      <D.79612>:
      __insert_left = iftmp.53;
    }
  finally
    {
      if (cleanup.54 != 0) goto <D.79618>; else goto <D.79619>;
      <D.79618>:
      D.78291 = {CLOBBER};
      <D.79619>:
    }
  __z = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_create_node (this, __v);
  D.79623 = &this->_M_impl._M_header;
  D.79624 = (int) __insert_left;
  std::_Rb_tree_insert_and_rebalance (D.79624, __z, __p, D.79623);
  D.79625 = this->_M_impl._M_node_count;
  D.79626 = D.79625 + 1;
  this->_M_impl._M_node_count = D.79626;
  std::_Rb_tree_iterator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_Rb_tree_iterator (&D.78293, __z);
  try
    {
      D.79627 = D.78293;
      return D.79627;
    }
  finally
    {
      D.78293 = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_create_node(const value_type&) [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>] (struct _Rb_tree * const this, const struct value_type & __x)
{
  struct pair * D.79635;
  struct allocator_type D.78465;
  void * D.79636;
  struct _Rb_tree_node * D.79637;
  struct _Rb_tree_node * __tmp;

  __tmp = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_node (this);
  try
    {
      D.79635 = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_M_valptr (__tmp);
      D.78465 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::get_allocator (this); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::construct (&D.78465, D.79635, __x);
        }
      finally
        {
          std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::~allocator (&D.78465);
          D.78465 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.79636 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.79636);
              std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_put_node (this, __tmp);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.79637 = __tmp;
  return D.79637;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_node() [with _Key = const Glib::ObjectBase*; _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; _Compare = std::less<const Glib::ObjectBase*>; _Alloc = std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.79645;
  struct _Node_allocator & D.79646;

  D.79646 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_Node_allocator (this);
  D.79645 = __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > > >::allocate (D.79646, 1);
  return D.79645;
}


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

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


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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct _Rb_tree_node * D.79651;

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


_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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.75621)
{
  bool retval.55;
  long unsigned int D.79655;
  struct _Rb_tree_node * D.79658;
  long unsigned int D.79659;

  D.79655 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::max_size (this);
  retval.55 = D.79655 < __n;
  if (retval.55 != 0) goto <D.79656>; else goto <D.79657>;
  <D.79656>:
  std::__throw_bad_alloc ();
  <D.79657>:
  D.79659 = __n * 64;
  D.79658 = operator new (D.79659);
  return D.79658;
}


__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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.79662;
  void * D.79663;

  try
    {
      D.79662 = 288230376151711743;
      return D.79662;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.79663 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.79663);
          
        }
    }
}


_Val* std::_Rb_tree_node<_Val>::_M_valptr() [with _Val = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>] (struct _Rb_tree_node * const this)
{
  struct pair * D.79665;
  struct pair * D.79666;

  D.79666 = &this->_M_value_field;
  D.79665 = std::__addressof<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > (D.79666);
  return D.79665;
}


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

  D.79668 = __r;
  return D.79668;
}


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

  D.79671 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_Node_allocator (this);
  std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::allocator<std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > > (<retval>, D.79671);
  return <retval>;
}


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

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


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

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

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


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

  try
    {
      {

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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>*] (struct new_allocator * const this, struct pair * __p, const struct pair & __val)
{
  void * D.78612;
  void * D.78613;
  struct pair * iftmp.56;

  D.78612 = __p;
  D.78613 = operator new (32, D.78612);
  if (D.78613 != 0B) goto <D.79678>; else goto <D.79679>;
  <D.79678>:
  try
    {
      std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>::pair (D.78613, __val);
    }
  catch
    {
      operator delete (D.78613, D.78612);
    }
  iftmp.56 = D.78613;
  goto <D.79680>;
  <D.79679>:
  iftmp.56 = D.78613;
  <D.79680>:
}


std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>::pair(const std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>&) (struct pair * const this, const struct pair & D.77171)
{
  const struct ObjectBase * D.79682;
  const struct ExtraObjectBaseData * D.79683;
  struct ExtraObjectBaseData * D.79684;

  D.79682 = D.77171->first;
  this->first = D.79682;
  D.79683 = &D.77171->second;
  D.79684 = &this->second;
  Glib::ObjectBase::ExtraObjectBaseData::ExtraObjectBaseData (D.79684, D.79683);
  try
    {

    }
  catch
    {
      D.79684 = &this->second;
      Glib::ObjectBase::ExtraObjectBaseData::~ExtraObjectBaseData (D.79684);
    }
}


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

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  D.79688 = std::_Rb_tree<const Glib::ObjectBase*, std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>, std::_Select1st<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >, std::less<const Glib::ObjectBase*>, std::allocator<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::_M_get_Node_allocator (this);
  __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > > >::deallocate (D.79688, __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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; __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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> > >::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::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, struct _Rb_tree_node * __p, size_type D.75625)
{
  operator delete (__p);
}


_Tp& std::_Rb_tree_iterator<_Tp>::operator*() const [with _Tp = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>; std::_Rb_tree_iterator<_Tp>::reference = std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>&] (const struct _Rb_tree_iterator * const this)
{
  struct pair & D.79689;
  struct _Rb_tree_node_base * D.79690;

  D.79690 = this->_M_node;
  D.79689 = std::_Rb_tree_node<std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData> >::_M_valptr (D.79690);
  return D.79689;
}


std::pair<const Glib::ObjectBase* const, Glib::ObjectBase::ExtraObjectBaseData>::~pair() (struct pair * const this)
{
  struct ExtraObjectBaseData * D.79693;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.79693 = &this->second;
            Glib::ObjectBase::ExtraObjectBaseData::~ExtraObjectBaseData (D.79693);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.77186>:
}


Glib::ObjectBase::ExtraObjectBaseData::~ExtraObjectBaseData() (struct ExtraObjectBaseData * const this)
{
  struct interface_class_vector_type * D.79695;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.79695 = &this->custom_interface_classes;
            std::vector<const Glib::Interface_Class*>::~vector (D.79695);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.77160>:
}


std::vector<_Tp, _Alloc>::~vector() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>] (struct vector * const this)
{
  struct _Vector_base * D.79697;
  struct _Tp_alloc_type & D.79698;
  const struct Interface_Class * * D.79699;
  const struct Interface_Class * * D.79700;

  {
    try
      {
        try
          {
            D.79697 = &this->D.67283;
            D.79698 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79697);
            D.79699 = this->D.67283._M_impl._M_finish;
            D.79700 = this->D.67283._M_impl._M_start;
            std::_Destroy<const Glib::Interface_Class**, const Glib::Interface_Class*> (D.79700, D.79699, D.79698);
          }
        finally
          {
            D.79697 = &this->D.67283;
            std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::~_Vector_base (D.79697);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.77565>:
}


void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = const Glib::Interface_Class**; _Tp = const Glib::Interface_Class*] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, struct allocator & D.77558)
{
  std::_Destroy<const Glib::Interface_Class**> (__first, __last);
}


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last)
{
  typedef const struct Interface_Class * _Value_type;

  std::_Destroy_aux<true>::__destroy<const Glib::Interface_Class**> (__first, __last);
}


static void std::_Destroy_aux<true>::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = const Glib::Interface_Class**] (const struct Interface_Class * * D.78243, const struct Interface_Class * * D.78244)
{
  GIMPLE_NOP
}


void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::value_type = const Glib::Interface_Class*] (struct vector * const this, const struct Interface_Class * const & __x)
{
  const struct Interface_Class * * D.79703;
  const struct Interface_Class * * D.79704;
  struct _Vector_impl * D.79707;
  const struct Interface_Class * * D.79708;
  struct __normal_iterator D.79710;

  D.79703 = this->D.67283._M_impl._M_finish;
  D.79704 = this->D.67283._M_impl._M_end_of_storage;
  if (D.79703 != D.79704) goto <D.79705>; else goto <D.79706>;
  <D.79705>:
  D.79703 = this->D.67283._M_impl._M_finish;
  D.79707 = &this->D.67283._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::construct<const Glib::Interface_Class*> (D.79707, D.79703, __x);
  D.79703 = this->D.67283._M_impl._M_finish;
  D.79708 = D.79703 + 8;
  this->D.67283._M_impl._M_finish = D.79708;
  goto <D.79709>;
  <D.79706>:
  D.79710 = std::vector<const Glib::Interface_Class*>::end (this);
  std::vector<const Glib::Interface_Class*>::_M_insert_aux (this, D.79710, __x);
  <D.79709>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::construct(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, const _Tp&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = const Glib::Interface_Class**] (struct allocator & __a, const struct Interface_Class * * __p, const struct Interface_Class * const & __arg)
{
  __gnu_cxx::new_allocator<const Glib::Interface_Class*>::construct (__a, __p, __arg);
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = const Glib::Interface_Class*; __gnu_cxx::new_allocator<_Tp>::pointer = const Glib::Interface_Class**] (struct new_allocator * const this, const struct Interface_Class * * __p, const struct Interface_Class * const & __val)
{
  void * D.78060;
  void * D.78061;
  const struct Interface_Class * * iftmp.57;
  const struct Interface_Class * D.79714;

  D.78060 = __p;
  D.78061 = operator new (8, D.78060);
  if (D.78061 != 0B) goto <D.79712>; else goto <D.79713>;
  <D.79712>:
  try
    {
      D.79714 = *__val;
      MEM[(const struct Interface_Class * *)D.78061] = D.79714;
    }
  catch
    {
      operator delete (D.78061, D.78060);
    }
  iftmp.57 = D.78061;
  goto <D.79715>;
  <D.79713>:
  iftmp.57 = D.78061;
  <D.79715>:
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::end() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = const Glib::Interface_Class**] (struct vector * const this)
{
  struct iterator D.79716;
  struct iterator D.77670;
  const struct Interface_Class * * * D.79717;

  D.79717 = &this->D.67283._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::__normal_iterator (&D.77670, D.79717);
  try
    {
      D.79716 = D.77670;
      return D.79716;
    }
  finally
    {
      D.77670 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = const Glib::Interface_Class**; _Container = std::vector<const Glib::Interface_Class*>] (struct __normal_iterator * const this, const struct Interface_Class * * const & __i)
{
  const struct Interface_Class * * D.79720;

  D.79720 = *__i;
  this->_M_current = D.79720;
}


void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = const Glib::Interface_Class**] (struct vector * const this, struct iterator __position, const struct Interface_Class * const & __x)
{
  const struct Interface_Class * * D.79721;
  const struct Interface_Class * * D.79722;
  const struct Interface_Class * const * D.79725;
  struct _Vector_impl * D.79726;
  const struct Interface_Class * * D.79727;
  const struct Interface_Class * * D.79728;
  const struct Interface_Class * * D.79729;
  const struct Interface_Class * * const & D.79730;
  const struct Interface_Class * * D.79731;
  const struct Interface_Class * & D.79732;
  struct iterator D.77655;
  long int D.79734;
  struct _Vector_base * D.79735;
  long unsigned int D.79736;
  const struct Interface_Class * * D.79737;
  struct _Tp_alloc_type & D.79738;
  const struct Interface_Class * * const & D.79739;
  const struct Interface_Class * * D.79740;
  const struct Interface_Class * * D.79741;
  struct _Tp_alloc_type & D.79742;
  const struct Interface_Class * * const & D.79743;
  const struct Interface_Class * * D.79744;
  void * D.79745;
  struct _Tp_alloc_type & D.79749;
  struct _Tp_alloc_type & D.79750;
  long int D.79751;
  long int D.79752;
  long int D.79753;
  long int D.79754;
  long unsigned int D.79755;
  long unsigned int D.79756;
  const struct Interface_Class * * D.79757;

  {
    D.79721 = this->D.67283._M_impl._M_finish;
    D.79722 = this->D.67283._M_impl._M_end_of_storage;
    if (D.79721 != D.79722) goto <D.79723>; else goto <D.79724>;
    <D.79723>:
    {
      const struct Interface_Class * __x_copy;

      D.79721 = this->D.67283._M_impl._M_finish;
      D.79725 = D.79721 + 18446744073709551608;
      D.79721 = this->D.67283._M_impl._M_finish;
      D.79726 = &this->D.67283._M_impl;
      __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::construct<const Glib::Interface_Class*> (D.79726, D.79721, D.79725);
      D.79721 = this->D.67283._M_impl._M_finish;
      D.79727 = D.79721 + 8;
      this->D.67283._M_impl._M_finish = D.79727;
      __x_copy = *__x;
      D.79721 = this->D.67283._M_impl._M_finish;
      D.79728 = D.79721 + 18446744073709551608;
      D.79721 = this->D.67283._M_impl._M_finish;
      D.79729 = D.79721 + 18446744073709551600;
      D.79730 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::base (&__position);
      D.79731 = *D.79730;
      std::copy_backward<const Glib::Interface_Class**, const Glib::Interface_Class**> (D.79731, D.79729, D.79728);
      D.79732 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::operator* (&__position);
      *D.79732 = __x_copy;
    }
    goto <D.79733>;
    <D.79724>:
    {
      const size_type __len;
      const size_type __elems_before;
      const struct Interface_Class * * __new_start;
      const struct Interface_Class * * __new_finish;

      __len = std::vector<const Glib::Interface_Class*>::_M_check_len (this, 1, "vector::_M_insert_aux");
      D.77655 = std::vector<const Glib::Interface_Class*>::begin (this);
      try
        {
          D.79734 = __gnu_cxx::operator-<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> > (&__position, &D.77655);
          __elems_before = (const size_type) D.79734;
        }
      finally
        {
          D.77655 = {CLOBBER};
        }
      D.79735 = &this->D.67283;
      __new_start = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_allocate (D.79735, __len);
      __new_finish = __new_start;
      try
        {
          D.79736 = __elems_before * 8;
          D.79737 = __new_start + D.79736;
          D.79726 = &this->D.67283._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::construct<const Glib::Interface_Class*> (D.79726, D.79737, __x);
          __new_finish = 0B;
          D.79735 = &this->D.67283;
          D.79738 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79735);
          D.79739 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::base (&__position);
          D.79740 = *D.79739;
          D.79741 = this->D.67283._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<const Glib::Interface_Class**, const Glib::Interface_Class**, std::allocator<const Glib::Interface_Class*> > (D.79741, D.79740, __new_start, D.79738);
          __new_finish = __new_finish + 8;
          D.79735 = &this->D.67283;
          D.79742 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79735);
          D.79721 = this->D.67283._M_impl._M_finish;
          D.79743 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::base (&__position);
          D.79744 = *D.79743;
          __new_finish = std::__uninitialized_move_if_noexcept_a<const Glib::Interface_Class**, const Glib::Interface_Class**, std::allocator<const Glib::Interface_Class*> > (D.79744, D.79721, __new_finish, D.79742);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.79745 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.79745);
                  if (__new_finish == 0B) goto <D.79746>; else goto <D.79747>;
                  <D.79746>:
                  D.79736 = __elems_before * 8;
                  D.79737 = __new_start + D.79736;
                  D.79726 = &this->D.67283._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::destroy (D.79726, D.79737);
                  goto <D.79748>;
                  <D.79747>:
                  D.79735 = &this->D.67283;
                  D.79749 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79735);
                  std::_Destroy<const Glib::Interface_Class**, const Glib::Interface_Class*> (__new_start, __new_finish, D.79749);
                  <D.79748>:
                  D.79735 = &this->D.67283;
                  std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_deallocate (D.79735, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.79735 = &this->D.67283;
      D.79750 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79735);
      D.79721 = this->D.67283._M_impl._M_finish;
      D.79741 = this->D.67283._M_impl._M_start;
      std::_Destroy<const Glib::Interface_Class**, const Glib::Interface_Class*> (D.79741, D.79721, D.79750);
      D.79722 = this->D.67283._M_impl._M_end_of_storage;
      D.79751 = (long int) D.79722;
      D.79741 = this->D.67283._M_impl._M_start;
      D.79752 = (long int) D.79741;
      D.79753 = D.79751 - D.79752;
      D.79754 = D.79753 /[ex] 8;
      D.79755 = (long unsigned int) D.79754;
      D.79741 = this->D.67283._M_impl._M_start;
      D.79735 = &this->D.67283;
      std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_deallocate (D.79735, D.79741, D.79755);
      this->D.67283._M_impl._M_start = __new_start;
      this->D.67283._M_impl._M_finish = __new_finish;
      D.79756 = __len * 8;
      D.79757 = __new_start + D.79756;
      this->D.67283._M_impl._M_end_of_storage = D.79757;
    }
    <D.79733>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = const Glib::Interface_Class**; _BI2 = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79765;
  const struct Interface_Class * * D.79766;
  const struct Interface_Class * * D.79767;

  D.79766 = std::__miter_base<const Glib::Interface_Class**> (__last);
  D.79767 = std::__miter_base<const Glib::Interface_Class**> (__first);
  D.79765 = std::__copy_move_backward_a2<false, const Glib::Interface_Class**, const Glib::Interface_Class**> (D.79767, D.79766, __result);
  return D.79765;
}


typename std::_Miter_base<_Iterator>::iterator_type std::__miter_base(_Iterator) [with _Iterator = const Glib::Interface_Class**; typename std::_Miter_base<_Iterator>::iterator_type = const Glib::Interface_Class**] (const struct Interface_Class * * __it)
{
  const struct Interface_Class * * D.79772;

  D.79772 = std::_Iter_base<const Glib::Interface_Class**, false>::_S_base (__it);
  return D.79772;
}


_BI2 std::__copy_move_backward_a2(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = const Glib::Interface_Class**; _BI2 = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79774;
  const struct Interface_Class * * D.79775;
  const struct Interface_Class * * D.79776;
  const struct Interface_Class * * D.79777;

  D.79775 = std::__niter_base<const Glib::Interface_Class**> (__result);
  D.79776 = std::__niter_base<const Glib::Interface_Class**> (__last);
  D.79777 = std::__niter_base<const Glib::Interface_Class**> (__first);
  D.79774 = std::__copy_move_backward_a<false, const Glib::Interface_Class**, const Glib::Interface_Class**> (D.79777, D.79776, D.79775);
  return D.79774;
}


_BI2 std::__copy_move_backward_a(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = const Glib::Interface_Class**; _BI2 = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79780;
  typedef const struct Interface_Class * _ValueType1;
  typedef const struct Interface_Class * _ValueType2;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.79780 = std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<const Glib::Interface_Class*> (__first, __last, __result);
  return D.79780;
}


static _Tp* std::__copy_move_backward<_IsMove, true, std::random_access_iterator_tag>::__copy_move_b(const _Tp*, const _Tp*, _Tp*) [with _Tp = const Glib::Interface_Class*; bool _IsMove = false] (const struct Interface_Class * const * __first, const struct Interface_Class * const * __last, const struct Interface_Class * * __result)
{
  long int __last.58;
  long int __first.59;
  long int D.79784;
  long unsigned int _Num.60;
  long unsigned int D.79788;
  sizetype D.79789;
  const struct Interface_Class * * D.79790;
  const struct Interface_Class * * D.79792;
  const ptrdiff_t _Num;

  __last.58 = (long int) __last;
  __first.59 = (long int) __first;
  D.79784 = __last.58 - __first.59;
  _Num = D.79784 /[ex] 8;
  if (_Num != 0) goto <D.79785>; else goto <D.79786>;
  <D.79785>:
  _Num.60 = (long unsigned int) _Num;
  D.79788 = _Num.60 * 8;
  _Num.60 = (long unsigned int) _Num;
  D.79788 = _Num.60 * 8;
  D.79789 = -D.79788;
  D.79790 = __result + D.79789;
  __builtin_memmove (D.79790, __first, D.79788);
  goto <D.79791>;
  <D.79786>:
  <D.79791>:
  _Num.60 = (long unsigned int) _Num;
  D.79788 = _Num.60 * 8;
  D.79789 = -D.79788;
  D.79792 = __result + D.79789;
  return D.79792;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::reference __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator*() const [with _Iterator = const Glib::Interface_Class**; _Container = std::vector<const Glib::Interface_Class*>; __gnu_cxx::__normal_iterator<_Iterator, _Container>::reference = const Glib::Interface_Class*&] (const struct __normal_iterator * const this)
{
  const struct Interface_Class * & D.79794;

  D.79794 = this->_M_current;
  return D.79794;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::_M_check_len(std::vector<_Tp, _Alloc>::size_type, const char*) const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n, const char * __s)
{
  bool retval.61;
  long unsigned int D.79797;
  long unsigned int D.79798;
  long unsigned int D.79799;
  long unsigned int __n.62;
  long unsigned int D.79803;
  const long unsigned int D.78087;
  long unsigned int D.79804;
  const long unsigned int & D.79805;
  long unsigned int D.79806;
  size_type D.79807;
  size_type iftmp.63;
  long unsigned int D.79812;
  long unsigned int D.79814;
  const size_type __len;

  D.79797 = std::vector<const Glib::Interface_Class*>::max_size (this);
  D.79798 = std::vector<const Glib::Interface_Class*>::size (this);
  D.79799 = D.79797 - D.79798;
  __n.62 = __n;
  retval.61 = D.79799 < __n.62;
  if (retval.61 != 0) goto <D.79801>; else goto <D.79802>;
  <D.79801>:
  std::__throw_length_error (__s);
  <D.79802>:
  D.79803 = std::vector<const Glib::Interface_Class*>::size (this);
  D.79804 = std::vector<const Glib::Interface_Class*>::size (this);
  D.78087 = D.79804;
  try
    {
      D.79805 = std::max<long unsigned int> (&D.78087, &__n);
      D.79806 = *D.79805;
      __len = D.79803 + D.79806;
    }
  finally
    {
      D.78087 = {CLOBBER};
    }
  D.79812 = std::vector<const Glib::Interface_Class*>::size (this);
  if (D.79812 > __len) goto <D.79809>; else goto <D.79813>;
  <D.79813>:
  D.79814 = std::vector<const Glib::Interface_Class*>::max_size (this);
  if (D.79814 < __len) goto <D.79809>; else goto <D.79810>;
  <D.79809>:
  iftmp.63 = std::vector<const Glib::Interface_Class*>::max_size (this);
  goto <D.79811>;
  <D.79810>:
  iftmp.63 = __len;
  <D.79811>:
  D.79807 = iftmp.63;
  return D.79807;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::max_size() const [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.79819;
  const struct _Vector_base * D.79820;
  const struct _Tp_alloc_type & D.79821;

  D.79820 = &this->D.67283;
  D.79821 = std::_Vector_base<const Glib::Interface_Class*, std::allocator<const Glib::Interface_Class*> >::_M_get_Tp_allocator (D.79820);
  D.79819 = __gnu_cxx::__alloc_traits<std::allocator<const Glib::Interface_Class*> >::max_size (D.79821);
  return D.79819;
}


static __gnu_cxx::__alloc_traits<_Alloc>::size_type __gnu_cxx::__alloc_traits<_Alloc>::max_size(const _Alloc&) [with _Alloc = std::allocator<const Glib::Interface_Class*>; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (const struct allocator & __a)
{
  size_type D.79823;

  D.79823 = __gnu_cxx::new_allocator<const Glib::Interface_Class*>::max_size (__a);
  return D.79823;
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::begin() [with _Tp = const Glib::Interface_Class*; _Alloc = std::allocator<const Glib::Interface_Class*>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = const Glib::Interface_Class**] (struct vector * const this)
{
  struct iterator D.79825;
  struct iterator D.78089;
  const struct Interface_Class * * * D.79826;

  D.79826 = &this->D.67283._M_impl._M_start;
  __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::__normal_iterator (&D.78089, D.79826);
  try
    {
      D.79825 = D.78089;
      return D.79825;
    }
  finally
    {
      D.78089 = {CLOBBER};
    }
}


typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type __gnu_cxx::operator-(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = const Glib::Interface_Class**; _Container = std::vector<const Glib::Interface_Class*>; typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type = long int] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  difference_type D.79829;
  const struct Interface_Class * * const & D.79830;
  const struct Interface_Class * * D.79831;
  long int D.79832;
  const struct Interface_Class * * const & D.79833;
  const struct Interface_Class * * D.79834;
  long int D.79835;
  long int D.79836;

  D.79830 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::base (__lhs);
  D.79831 = *D.79830;
  D.79832 = (long int) D.79831;
  D.79833 = __gnu_cxx::__normal_iterator<const Glib::Interface_Class**, std::vector<const Glib::Interface_Class*> >::base (__rhs);
  D.79834 = *D.79833;
  D.79835 = (long int) D.79834;
  D.79836 = D.79832 - D.79835;
  D.79829 = D.79836 /[ex] 8;
  return D.79829;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = const Glib::Interface_Class**; _Container = std::vector<const Glib::Interface_Class*>] (const struct __normal_iterator * const this)
{
  const struct Interface_Class * * const & D.79838;

  D.79838 = &this->_M_current;
  return D.79838;
}


_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = const Glib::Interface_Class**; _ForwardIterator = const Glib::Interface_Class**; _Allocator = std::allocator<const Glib::Interface_Class*>] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result, struct allocator & __alloc)
{
  const struct Interface_Class * * D.79840;

  D.79840 = std::__uninitialized_copy_a<const Glib::Interface_Class**, const Glib::Interface_Class**, const Glib::Interface_Class*> (__first, __last, __result, __alloc);
  return D.79840;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = const Glib::Interface_Class**; _ForwardIterator = const Glib::Interface_Class**; _Tp = const Glib::Interface_Class*] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result, struct allocator & D.78098)
{
  const struct Interface_Class * * D.79843;

  D.79843 = std::uninitialized_copy<const Glib::Interface_Class**, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79843;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = const Glib::Interface_Class**; _ForwardIterator = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79846;
  typedef const struct Interface_Class * _ValueType1;
  typedef const struct Interface_Class * _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.79846 = std::__uninitialized_copy<true>::__uninit_copy<const Glib::Interface_Class**, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79846;
}


static _ForwardIterator std::__uninitialized_copy<true>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = const Glib::Interface_Class**; _ForwardIterator = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79849;

  D.79849 = std::copy<const Glib::Interface_Class**, const Glib::Interface_Class**> (__first, __last, __result);
  return D.79849;
}


_OI std::copy(_II, _II, _OI) [with _II = const Glib::Interface_Class**; _OI = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79852;
  const struct Interface_Class * * D.79853;
  const struct Interface_Class * * D.79854;

  D.79853 = std::__miter_base<const Glib::Interface_Class**> (__last);
  D.79854 = std::__miter_base<const Glib::Interface_Class**> (__first);
  D.79852 = std::__copy_move_a2<false, const Glib::Interface_Class**, const Glib::Interface_Class**> (D.79854, D.79853, __result);
  return D.79852;
}


_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = const Glib::Interface_Class**; _OI = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79859;
  const struct Interface_Class * * D.79860;
  const struct Interface_Class * * D.79861;
  const struct Interface_Class * * D.79862;

  D.79860 = std::__niter_base<const Glib::Interface_Class**> (__result);
  D.79861 = std::__niter_base<const Glib::Interface_Class**> (__last);
  D.79862 = std::__niter_base<const Glib::Interface_Class**> (__first);
  D.79859 = std::__copy_move_a<false, const Glib::Interface_Class**, const Glib::Interface_Class**> (D.79862, D.79861, D.79860);
  return D.79859;
}


_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = const Glib::Interface_Class**; _OI = const Glib::Interface_Class**] (const struct Interface_Class * * __first, const struct Interface_Class * * __last, const struct Interface_Class * * __result)
{
  const struct Interface_Class * * D.79865;
  typedef const struct Interface_Class * _ValueTypeI;
  typedef const struct Interface_Class * _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.79865 = std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<const Glib::Interface_Class*> (__first, __last, __result);
  return D.79865;
}


static void __gnu_cxx::__alloc_traits<_Alloc>::destroy(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer) [with _Alloc = std::allocator<const Glib::Interface_Class*>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = const Glib::Interface_Class**] (struct allocator & __a, const struct Interface_Class * * __p)
{
  __gnu_cxx::new_allocator<const Glib::Interface_Class*>::destroy (__a, __p);
}


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


Glib::Threads::Mutex::Lock::~Lock() (struct Lock * const this)
{
  bool D.79867;
  struct Mutex & D.79870;

  {
    try
      {
        D.79867 = this->locked_;
        if (D.79867 != 0) goto <D.79868>; else goto <D.79869>;
        <D.79868>:
        D.79870 = this->mutex_;
        Glib::Threads::Mutex::unlock (D.79870);
        goto <D.79871>;
        <D.79869>:
        <D.79871>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.57933>:
}


Glib::Interface::Interface(const Glib::Interface_Class&) (struct Interface * const this, const struct Interface_Class & interface_class)
{
  struct trackable * D.79875;
  const void * * iftmp.64;
  struct ObjectBase * D.79883;
  int (*__vtbl_ptr_type) () * iftmp.65;
  const void * * D.79888;
  sizetype iftmp.66;
  int (*__vtbl_ptr_type) () * D.79893;
  int (*__vtbl_ptr_type) () * D.79894;
  long int D.79895;
  struct ObjectBase * D.79897;
  int (*__vtbl_ptr_type) () * iftmp.67;
  bool retval.68;
  bool iftmp.69;
  sizetype iftmp.70;
  struct ObjectBase * D.79910;
  const char * D.79911;
  sizetype iftmp.71;
  struct ObjectBase * D.79917;
  bool D.79918;
  bool D.79919;
  sizetype iftmp.72;
  struct ObjectBase * D.79927;
  struct GObject * D.79928;
  sizetype iftmp.73;
  struct ObjectBase * D.79935;
  struct GObject * D.79936;
  const struct Class * D.79937;
  bool retval.74;
  void * D.79939;
  unsigned int iface_properties_quark.75;
  void * props.76;
  long unsigned int D.79946;
  int D.79953;
  long unsigned int D.79956;
  long unsigned int D.79957;
  long unsigned int D.79958;
  long unsigned int D.79959;
  struct GParamSpec * * D.79960;
  struct GParamSpec * D.79961;
  long unsigned int D.79962;
  struct GValue * g_value.77;
  unsigned int D.79964;
  unsigned int D.79965;
  unsigned int n_iface_props.78;
  struct element_type & D.79969;
  const struct Interface_Class * const D.76401;
  const struct ObjectBase * const D.76400;
  sizetype iftmp.79;
  const struct ObjectBase * D.79974;
  struct mapped_type & D.79975;
  struct interface_class_vector_type * D.79976;
  const void * * iftmp.80;

  if (1 != 0) goto <D.79873>; else goto <D.79874>;
  <D.79873>:
  D.79875 = &this->D.74380;
  sigc::trackable::trackable (D.79875);
  goto <D.79876>;
  <D.79874>:
  <D.79876>:
  try
    {
      if (1 != 0) goto <D.79877>; else goto <D.79878>;
      <D.79877>:
      if (1 == 0) goto <D.79880>; else goto <D.79881>;
      <D.79880>:
      iftmp.64 = 16B;
      goto <D.79882>;
      <D.79881>:
      iftmp.64 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.79882>:
      D.79883 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.79883, iftmp.64);
      goto <D.79884>;
      <D.79878>:
      <D.79884>:
      try
        {
          if (1 == 0) goto <D.79886>; else goto <D.79887>;
          <D.79886>:
          D.79888 = 0B;
          iftmp.65 = *D.79888;
          goto <D.79889>;
          <D.79887>:
          iftmp.65 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.79889>:
          this->_vptr.Interface = iftmp.65;
          if (1 == 0) goto <D.79891>; else goto <D.79892>;
          <D.79891>:
          D.79893 = this->_vptr.Interface;
          D.79894 = D.79893 + 18446744073709551592;
          D.79895 = MEM[(long int *)D.79894];
          iftmp.66 = (sizetype) D.79895;
          goto <D.79896>;
          <D.79892>:
          iftmp.66 = 8;
          <D.79896>:
          D.79897 = this + iftmp.66;
          if (1 == 0) goto <D.79899>; else goto <D.79900>;
          <D.79899>:
          iftmp.67 = MEM[(const void * *)0B + 8B];
          goto <D.79901>;
          <D.79900>:
          iftmp.67 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.79901>:
          D.79897->_vptr.ObjectBase = iftmp.67;
          {
            {
              if (1 == 0) goto <D.79907>; else goto <D.79908>;
              <D.79907>:
              D.79893 = this->_vptr.Interface;
              D.79894 = D.79893 + 18446744073709551592;
              D.79895 = MEM[(long int *)D.79894];
              iftmp.70 = (sizetype) D.79895;
              goto <D.79909>;
              <D.79908>:
              iftmp.70 = 8;
              <D.79909>:
              D.79910 = this + iftmp.70;
              D.79911 = D.79910->custom_type_name_;
              if (D.79911 != 0B) goto <D.79912>; else goto <D.79904>;
              <D.79912>:
              if (1 == 0) goto <D.79914>; else goto <D.79915>;
              <D.79914>:
              D.79893 = this->_vptr.Interface;
              D.79894 = D.79893 + 18446744073709551592;
              D.79895 = MEM[(long int *)D.79894];
              iftmp.71 = (sizetype) D.79895;
              goto <D.79916>;
              <D.79915>:
              iftmp.71 = 8;
              <D.79916>:
              D.79917 = this + iftmp.71;
              D.79918 = Glib::ObjectBase::is_anonymous_custom_ (D.79917);
              D.79919 = ~D.79918;
              if (D.79919 != 0) goto <D.79920>; else goto <D.79904>;
              <D.79920>:
              iftmp.69 = 1;
              goto <D.79905>;
              <D.79904>:
              iftmp.69 = 0;
              <D.79905>:
              retval.68 = iftmp.69;
              if (retval.68 != 0) goto <D.79921>; else goto <D.79922>;
              <D.79921>:
              {
                {
                  if (1 == 0) goto <D.79924>; else goto <D.79925>;
                  <D.79924>:
                  D.79893 = this->_vptr.Interface;
                  D.79894 = D.79893 + 18446744073709551592;
                  D.79895 = MEM[(long int *)D.79894];
                  iftmp.72 = (sizetype) D.79895;
                  goto <D.79926>;
                  <D.79925>:
                  iftmp.72 = 8;
                  <D.79926>:
                  D.79927 = this + iftmp.72;
                  D.79928 = D.79927->gobject_;
                  if (D.79928 != 0B) goto <D.79929>; else goto <D.79930>;
                  <D.79929>:
                  {
                    struct GObjectClass * const instance_class;
                    const GType iface_type;

                    if (1 == 0) goto <D.79932>; else goto <D.79933>;
                    <D.79932>:
                    D.79893 = this->_vptr.Interface;
                    D.79894 = D.79893 + 18446744073709551592;
                    D.79895 = MEM[(long int *)D.79894];
                    iftmp.73 = (sizetype) D.79895;
                    goto <D.79934>;
                    <D.79933>:
                    iftmp.73 = 8;
                    <D.79934>:
                    D.79935 = this + iftmp.73;
                    D.79936 = D.79935->gobject_;
                    instance_class = MEM[(struct GTypeInstance *)D.79936].g_class;
                    D.79937 = &interface_class->D.74398;
                    iface_type = Glib::Class::get_type (D.79937);
                    {
                      D.79939 = g_type_interface_peek (instance_class, iface_type);
                      retval.74 = D.79939 == 0B;
                      if (retval.74 != 0) goto <D.79940>; else goto <D.79941>;
                      <D.79940>:
                      {
                        void * const g_iface;
                        const GType custom_type;
                        struct iface_properties_type * props;
                        const guint n_existing_props;
                        guint n_iface_props;
                        struct GParamSpec * * iface_props;

                        try
                          {
                            g_iface = g_type_default_interface_ref (iface_type);
                            custom_type = MEM[(struct GTypeClass *)instance_class].g_type;
                            iface_properties_quark.75 = iface_properties_quark;
                            props = g_type_get_qdata (custom_type, iface_properties_quark.75);
                            if (props == 0B) goto <D.79943>; else goto <D.79944>;
                            <D.79943>:
                            props.76 = operator new (24);
                            try
                              {
                                std::vector<_GValue*>::vector (props.76);
                              }
                            catch
                              {
                                operator delete (props.76);
                              }
                            props = props.76;
                            iface_properties_quark.75 = iface_properties_quark;
                            g_type_set_qdata (custom_type, iface_properties_quark.75, props);
                            goto <D.79945>;
                            <D.79944>:
                            <D.79945>:
                            D.79946 = std::vector<_GValue*>::size (props);
                            n_existing_props = (const guint) D.79946;
                            n_iface_props = 0;
                            iface_props = g_object_interface_list_properties (g_iface, &n_iface_props);
                            {
                              guint p;

                              p = 0;
                              goto <D.76390>;
                              <D.76391>:
                              {
                                struct GValue * g_value;
                                const gchar * prop_name;
                                struct GParamSpec * new_spec;

                                try
                                  {
                                    {
                                      gsize __n;
                                      gsize __s;
                                      void * __p;

                                      __n = 1;
                                      __s = 24;
                                      if (__s == 1) goto <D.79947>; else goto <D.79948>;
                                      <D.79947>:
                                      __p = g_malloc0 (__n);
                                      goto <D.79949>;
                                      <D.79948>:
                                      D.79953 = __builtin_constant_p (__n);
                                      if (D.79953 != 0) goto <D.79954>; else goto <D.79950>;
                                      <D.79954>:
                                      if (__s == 0) goto <D.79951>; else goto <D.79955>;
                                      <D.79955>:
                                      D.79956 = 18446744073709551615 / __s;
                                      if (D.79956 >= __n) goto <D.79951>; else goto <D.79950>;
                                      <D.79951>:
                                      D.79957 = __n * __s;
                                      __p = g_malloc0 (D.79957);
                                      goto <D.79952>;
                                      <D.79950>:
                                      __p = g_malloc0_n (__n, __s);
                                      <D.79952>:
                                      <D.79949>:
                                      g_value = __p;
                                    }
                                    D.79958 = (long unsigned int) p;
                                    D.79959 = D.79958 * 8;
                                    D.79960 = iface_props + D.79959;
                                    D.79961 = *D.79960;
                                    D.79962 = D.79961->value_type;
                                    g_value.77 = g_value;
                                    g_value_init (g_value.77, D.79962);
                                    g_value.77 = g_value;
                                    D.79958 = (long unsigned int) p;
                                    D.79959 = D.79958 * 8;
                                    D.79960 = iface_props + D.79959;
                                    D.79961 = *D.79960;
                                    g_param_value_set_default (D.79961, g_value.77);
                                    std::vector<_GValue*>::push_back (props, &g_value);
                                    D.79958 = (long unsigned int) p;
                                    D.79959 = D.79958 * 8;
                                    D.79960 = iface_props + D.79959;
                                    D.79961 = *D.79960;
                                    prop_name = g_param_spec_get_name (D.79961);
                                    D.79958 = (long unsigned int) p;
                                    D.79959 = D.79958 * 8;
                                    D.79960 = iface_props + D.79959;
                                    D.79961 = *D.79960;
                                    new_spec = g_param_spec_override (prop_name, D.79961);
                                    D.79964 = p + n_existing_props;
                                    D.79965 = D.79964 + 1;
                                    g_object_class_install_property (instance_class, D.79965, new_spec);
                                  }
                                finally
                                  {
                                    g_value = {CLOBBER};
                                  }
                              }
                              p = p + 1;
                              <D.76390>:
                              n_iface_props.78 = n_iface_props;
                              if (p < n_iface_props.78) goto <D.76391>; else goto <D.76398>;
                              <D.76398>:
                            }
                            Glib::Interface_Class::add_interface (interface_class, custom_type);
                            g_type_default_interface_unref (g_iface);
                            g_free (iface_props);
                          }
                        finally
                          {
                            n_iface_props = {CLOBBER};
                          }
                      }
                      goto <D.79967>;
                      <D.79941>:
                      <D.79967>:
                    }
                  }
                  goto <D.79968>;
                  <D.79930>:
                  {
                    struct Lock lock;

                    try
                      {
                        D.79969 = std::auto_ptr<Glib::Threads::Mutex>::operator* (&extra_object_base_data_mutex);
                        Glib::Threads::Mutex::Lock::Lock (&lock, D.79969);
                        try
                          {
                            D.76401 = interface_class;
                            try
                              {
                                if (1 == 0) goto <D.79971>; else goto <D.79972>;
                                <D.79971>:
                                D.79893 = this->_vptr.Interface;
                                D.79894 = D.79893 + 18446744073709551592;
                                D.79895 = MEM[(long int *)D.79894];
                                iftmp.79 = (sizetype) D.79895;
                                goto <D.79973>;
                                <D.79972>:
                                iftmp.79 = 8;
                                <D.79973>:
                                D.79974 = this + iftmp.79;
                                D.76400 = D.79974;
                                try
                                  {
                                    D.79975 = std::map<const Glib::ObjectBase*, Glib::ObjectBase::ExtraObjectBaseData>::operator[] (&extra_object_base_data, &D.76400);
                                    D.79976 = &D.79975->custom_interface_classes;
                                    std::vector<const Glib::Interface_Class*>::push_back (D.79976, &D.76401);
                                  }
                                finally
                                  {
                                    D.76400 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                D.76401 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            Glib::Threads::Mutex::Lock::~Lock (&lock);
                          }
                      }
                    finally
                      {
                        lock = {CLOBBER};
                      }
                  }
                  <D.79968>:
                }
              }
              goto <D.79977>;
              <D.79922>:
              <D.79977>:
            }
          }
        }
      catch
        {
          if (1 != 0) goto <D.79978>; else goto <D.79979>;
          <D.79978>:
          if (1 == 0) goto <D.79981>; else goto <D.79982>;
          <D.79981>:
          iftmp.80 = 16B;
          goto <D.79983>;
          <D.79982>:
          iftmp.80 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.79983>:
          D.79883 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.79883, iftmp.80);
          goto <D.79984>;
          <D.79979>:
          <D.79984>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.79985>; else goto <D.79986>;
      <D.79985>:
      D.79875 = &this->D.74380;
      sigc::trackable::~trackable (D.79875);
      goto <D.79987>;
      <D.79986>:
      <D.79987>:
    }
}


Glib::Interface::Interface(GObject*) (struct Interface * const this, const void * * __vtt_parm, struct GObject * castitem)
{
  struct trackable * D.80011;
  const void * * iftmp.81;
  struct ObjectBase * D.80019;
  int (*__vtbl_ptr_type) () * iftmp.82;
  sizetype iftmp.83;
  int (*__vtbl_ptr_type) () * D.80028;
  int (*__vtbl_ptr_type) () * D.80029;
  long int D.80030;
  struct ObjectBase * D.80032;
  int (*__vtbl_ptr_type) () * iftmp.84;
  sizetype iftmp.85;
  struct ObjectBase * D.80041;
  const void * * iftmp.86;

  if (0 != 0) goto <D.80009>; else goto <D.80010>;
  <D.80009>:
  D.80011 = &this->D.74380;
  sigc::trackable::trackable (D.80011);
  goto <D.80012>;
  <D.80010>:
  <D.80012>:
  try
    {
      if (0 != 0) goto <D.80013>; else goto <D.80014>;
      <D.80013>:
      if (0 == 0) goto <D.80016>; else goto <D.80017>;
      <D.80016>:
      iftmp.81 = __vtt_parm + 16;
      goto <D.80018>;
      <D.80017>:
      iftmp.81 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.80018>:
      D.80019 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.80019, iftmp.81);
      goto <D.80020>;
      <D.80014>:
      <D.80020>:
      try
        {
          if (0 == 0) goto <D.80022>; else goto <D.80023>;
          <D.80022>:
          iftmp.82 = *__vtt_parm;
          goto <D.80024>;
          <D.80023>:
          iftmp.82 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.80024>:
          this->_vptr.Interface = iftmp.82;
          if (0 == 0) goto <D.80026>; else goto <D.80027>;
          <D.80026>:
          D.80028 = this->_vptr.Interface;
          D.80029 = D.80028 + 18446744073709551592;
          D.80030 = MEM[(long int *)D.80029];
          iftmp.83 = (sizetype) D.80030;
          goto <D.80031>;
          <D.80027>:
          iftmp.83 = 8;
          <D.80031>:
          D.80032 = this + iftmp.83;
          if (0 == 0) goto <D.80034>; else goto <D.80035>;
          <D.80034>:
          iftmp.84 = MEM[(const void * *)__vtt_parm + 8B];
          goto <D.80036>;
          <D.80035>:
          iftmp.84 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.80036>:
          D.80032->_vptr.ObjectBase = iftmp.84;
          if (0 == 0) goto <D.80038>; else goto <D.80039>;
          <D.80038>:
          D.80028 = this->_vptr.Interface;
          D.80029 = D.80028 + 18446744073709551592;
          D.80030 = MEM[(long int *)D.80029];
          iftmp.85 = (sizetype) D.80030;
          goto <D.80040>;
          <D.80039>:
          iftmp.85 = 8;
          <D.80040>:
          D.80041 = this + iftmp.85;
          Glib::ObjectBase::initialize (D.80041, castitem);
        }
      catch
        {
          if (0 != 0) goto <D.80042>; else goto <D.80043>;
          <D.80042>:
          if (0 == 0) goto <D.80045>; else goto <D.80046>;
          <D.80045>:
          iftmp.86 = __vtt_parm + 16;
          goto <D.80047>;
          <D.80046>:
          iftmp.86 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.80047>:
          D.80019 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.80019, iftmp.86);
          goto <D.80048>;
          <D.80043>:
          <D.80048>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.80049>; else goto <D.80050>;
      <D.80049>:
      D.80011 = &this->D.74380;
      sigc::trackable::~trackable (D.80011);
      goto <D.80051>;
      <D.80050>:
      <D.80051>:
    }
}


Glib::Interface::Interface(GObject*) (struct Interface * const this, struct GObject * castitem)
{
  struct trackable * D.80056;
  const void * * iftmp.87;
  struct ObjectBase * D.80064;
  int (*__vtbl_ptr_type) () * iftmp.88;
  const void * * D.80069;
  sizetype iftmp.89;
  int (*__vtbl_ptr_type) () * D.80074;
  int (*__vtbl_ptr_type) () * D.80075;
  long int D.80076;
  struct ObjectBase * D.80078;
  int (*__vtbl_ptr_type) () * iftmp.90;
  sizetype iftmp.91;
  struct ObjectBase * D.80087;
  const void * * iftmp.92;

  if (1 != 0) goto <D.80054>; else goto <D.80055>;
  <D.80054>:
  D.80056 = &this->D.74380;
  sigc::trackable::trackable (D.80056);
  goto <D.80057>;
  <D.80055>:
  <D.80057>:
  try
    {
      if (1 != 0) goto <D.80058>; else goto <D.80059>;
      <D.80058>:
      if (1 == 0) goto <D.80061>; else goto <D.80062>;
      <D.80061>:
      iftmp.87 = 16B;
      goto <D.80063>;
      <D.80062>:
      iftmp.87 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.80063>:
      D.80064 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.80064, iftmp.87);
      goto <D.80065>;
      <D.80059>:
      <D.80065>:
      try
        {
          if (1 == 0) goto <D.80067>; else goto <D.80068>;
          <D.80067>:
          D.80069 = 0B;
          iftmp.88 = *D.80069;
          goto <D.80070>;
          <D.80068>:
          iftmp.88 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.80070>:
          this->_vptr.Interface = iftmp.88;
          if (1 == 0) goto <D.80072>; else goto <D.80073>;
          <D.80072>:
          D.80074 = this->_vptr.Interface;
          D.80075 = D.80074 + 18446744073709551592;
          D.80076 = MEM[(long int *)D.80075];
          iftmp.89 = (sizetype) D.80076;
          goto <D.80077>;
          <D.80073>:
          iftmp.89 = 8;
          <D.80077>:
          D.80078 = this + iftmp.89;
          if (1 == 0) goto <D.80080>; else goto <D.80081>;
          <D.80080>:
          iftmp.90 = MEM[(const void * *)0B + 8B];
          goto <D.80082>;
          <D.80081>:
          iftmp.90 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.80082>:
          D.80078->_vptr.ObjectBase = iftmp.90;
          if (1 == 0) goto <D.80084>; else goto <D.80085>;
          <D.80084>:
          D.80074 = this->_vptr.Interface;
          D.80075 = D.80074 + 18446744073709551592;
          D.80076 = MEM[(long int *)D.80075];
          iftmp.91 = (sizetype) D.80076;
          goto <D.80086>;
          <D.80085>:
          iftmp.91 = 8;
          <D.80086>:
          D.80087 = this + iftmp.91;
          Glib::ObjectBase::initialize (D.80087, castitem);
        }
      catch
        {
          if (1 != 0) goto <D.80088>; else goto <D.80089>;
          <D.80088>:
          if (1 == 0) goto <D.80091>; else goto <D.80092>;
          <D.80091>:
          iftmp.92 = 16B;
          goto <D.80093>;
          <D.80092>:
          iftmp.92 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.80093>:
          D.80064 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.80064, iftmp.92);
          goto <D.80094>;
          <D.80089>:
          <D.80094>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.80095>; else goto <D.80096>;
      <D.80095>:
      D.80056 = &this->D.74380;
      sigc::trackable::~trackable (D.80056);
      goto <D.80097>;
      <D.80096>:
      <D.80097>:
    }
}


Glib::Interface::Interface() (struct Interface * const this, const void * * __vtt_parm)
{
  struct trackable * D.80102;
  const void * * iftmp.93;
  struct ObjectBase * D.80110;
  int (*__vtbl_ptr_type) () * iftmp.94;
  sizetype iftmp.95;
  int (*__vtbl_ptr_type) () * D.80119;
  int (*__vtbl_ptr_type) () * D.80120;
  long int D.80121;
  struct ObjectBase * D.80123;
  int (*__vtbl_ptr_type) () * iftmp.96;
  const void * * iftmp.97;

  if (0 != 0) goto <D.80100>; else goto <D.80101>;
  <D.80100>:
  D.80102 = &this->D.74380;
  sigc::trackable::trackable (D.80102);
  goto <D.80103>;
  <D.80101>:
  <D.80103>:
  try
    {
      if (0 != 0) goto <D.80104>; else goto <D.80105>;
      <D.80104>:
      if (0 == 0) goto <D.80107>; else goto <D.80108>;
      <D.80107>:
      iftmp.93 = __vtt_parm + 16;
      goto <D.80109>;
      <D.80108>:
      iftmp.93 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.80109>:
      D.80110 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.80110, iftmp.93);
      goto <D.80111>;
      <D.80105>:
      <D.80111>:
      try
        {
          if (0 == 0) goto <D.80113>; else goto <D.80114>;
          <D.80113>:
          iftmp.94 = *__vtt_parm;
          goto <D.80115>;
          <D.80114>:
          iftmp.94 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.80115>:
          this->_vptr.Interface = iftmp.94;
          if (0 == 0) goto <D.80117>; else goto <D.80118>;
          <D.80117>:
          D.80119 = this->_vptr.Interface;
          D.80120 = D.80119 + 18446744073709551592;
          D.80121 = MEM[(long int *)D.80120];
          iftmp.95 = (sizetype) D.80121;
          goto <D.80122>;
          <D.80118>:
          iftmp.95 = 8;
          <D.80122>:
          D.80123 = this + iftmp.95;
          if (0 == 0) goto <D.80125>; else goto <D.80126>;
          <D.80125>:
          iftmp.96 = MEM[(const void * *)__vtt_parm + 8B];
          goto <D.80127>;
          <D.80126>:
          iftmp.96 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.80127>:
          D.80123->_vptr.ObjectBase = iftmp.96;
        }
      catch
        {
          if (0 != 0) goto <D.80128>; else goto <D.80129>;
          <D.80128>:
          if (0 == 0) goto <D.80131>; else goto <D.80132>;
          <D.80131>:
          iftmp.97 = __vtt_parm + 16;
          goto <D.80133>;
          <D.80132>:
          iftmp.97 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.80133>:
          D.80110 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.80110, iftmp.97);
          goto <D.80134>;
          <D.80129>:
          <D.80134>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.80135>; else goto <D.80136>;
      <D.80135>:
      D.80102 = &this->D.74380;
      sigc::trackable::~trackable (D.80102);
      goto <D.80137>;
      <D.80136>:
      <D.80137>:
    }
}


Glib::Interface::Interface() (struct Interface * const this)
{
  struct trackable * D.80141;
  const void * * iftmp.98;
  struct ObjectBase * D.80149;
  int (*__vtbl_ptr_type) () * iftmp.99;
  const void * * D.80154;
  sizetype iftmp.100;
  int (*__vtbl_ptr_type) () * D.80159;
  int (*__vtbl_ptr_type) () * D.80160;
  long int D.80161;
  struct ObjectBase * D.80163;
  int (*__vtbl_ptr_type) () * iftmp.101;
  const void * * iftmp.102;

  if (1 != 0) goto <D.80139>; else goto <D.80140>;
  <D.80139>:
  D.80141 = &this->D.74380;
  sigc::trackable::trackable (D.80141);
  goto <D.80142>;
  <D.80140>:
  <D.80142>:
  try
    {
      if (1 != 0) goto <D.80143>; else goto <D.80144>;
      <D.80143>:
      if (1 == 0) goto <D.80146>; else goto <D.80147>;
      <D.80146>:
      iftmp.98 = 16B;
      goto <D.80148>;
      <D.80147>:
      iftmp.98 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
      <D.80148>:
      D.80149 = &this->D.74379;
      Glib::ObjectBase::ObjectBase (D.80149, iftmp.98);
      goto <D.80150>;
      <D.80144>:
      <D.80150>:
      try
        {
          if (1 == 0) goto <D.80152>; else goto <D.80153>;
          <D.80152>:
          D.80154 = 0B;
          iftmp.99 = *D.80154;
          goto <D.80155>;
          <D.80153>:
          iftmp.99 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
          <D.80155>:
          this->_vptr.Interface = iftmp.99;
          if (1 == 0) goto <D.80157>; else goto <D.80158>;
          <D.80157>:
          D.80159 = this->_vptr.Interface;
          D.80160 = D.80159 + 18446744073709551592;
          D.80161 = MEM[(long int *)D.80160];
          iftmp.100 = (sizetype) D.80161;
          goto <D.80162>;
          <D.80158>:
          iftmp.100 = 8;
          <D.80162>:
          D.80163 = this + iftmp.100;
          if (1 == 0) goto <D.80165>; else goto <D.80166>;
          <D.80165>:
          iftmp.101 = MEM[(const void * *)0B + 8B];
          goto <D.80167>;
          <D.80166>:
          iftmp.101 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
          <D.80167>:
          D.80163->_vptr.ObjectBase = iftmp.101;
        }
      catch
        {
          if (1 != 0) goto <D.80168>; else goto <D.80169>;
          <D.80168>:
          if (1 == 0) goto <D.80171>; else goto <D.80172>;
          <D.80171>:
          iftmp.102 = 16B;
          goto <D.80173>;
          <D.80172>:
          iftmp.102 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
          <D.80173>:
          D.80149 = &this->D.74379;
          Glib::ObjectBase::~ObjectBase (D.80149, iftmp.102);
          goto <D.80174>;
          <D.80169>:
          <D.80174>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.80175>; else goto <D.80176>;
      <D.80175>:
      D.80141 = &this->D.74380;
      sigc::trackable::~trackable (D.80141);
      goto <D.80177>;
      <D.80176>:
      <D.80177>:
    }
}


Glib::Interface::~Interface() (struct Interface * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.103;
  sizetype iftmp.104;
  int (*__vtbl_ptr_type) () * D.80186;
  int (*__vtbl_ptr_type) () * D.80187;
  long int D.80188;
  struct ObjectBase * D.80190;
  int (*__vtbl_ptr_type) () * iftmp.105;
  int D.80195;
  const void * * iftmp.106;
  struct ObjectBase * D.80202;
  struct trackable * D.80206;
  int D.80208;

  {
    if (0 == 0) goto <D.80180>; else goto <D.80181>;
    <D.80180>:
    iftmp.103 = *__vtt_parm;
    goto <D.80182>;
    <D.80181>:
    iftmp.103 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
    <D.80182>:
    this->_vptr.Interface = iftmp.103;
    if (0 == 0) goto <D.80184>; else goto <D.80185>;
    <D.80184>:
    D.80186 = this->_vptr.Interface;
    D.80187 = D.80186 + 18446744073709551592;
    D.80188 = MEM[(long int *)D.80187];
    iftmp.104 = (sizetype) D.80188;
    goto <D.80189>;
    <D.80185>:
    iftmp.104 = 8;
    <D.80189>:
    D.80190 = this + iftmp.104;
    if (0 == 0) goto <D.80192>; else goto <D.80193>;
    <D.80192>:
    iftmp.105 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.80194>;
    <D.80193>:
    iftmp.105 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
    <D.80194>:
    D.80190->_vptr.ObjectBase = iftmp.105;
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.80195 = 0;
                if (D.80195 != 0) goto <D.80196>; else goto <D.80197>;
                <D.80196>:
                if (0 == 0) goto <D.80199>; else goto <D.80200>;
                <D.80199>:
                iftmp.106 = __vtt_parm + 16;
                goto <D.80201>;
                <D.80200>:
                iftmp.106 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
                <D.80201>:
                D.80202 = &this->D.74379;
                Glib::ObjectBase::~ObjectBase (D.80202, iftmp.106);
                goto <D.80203>;
                <D.80197>:
                <D.80203>:
              }
          }
        finally
          {
            D.80195 = 0;
            if (D.80195 != 0) goto <D.80204>; else goto <D.80205>;
            <D.80204>:
            D.80206 = &this->D.74380;
            sigc::trackable::~trackable (D.80206);
            goto <D.80207>;
            <D.80205>:
            <D.80207>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.76425>:
  D.80208 = 0;
  if (D.80208 != 0) goto <D.80209>; else goto <D.80210>;
  <D.80209>:
  operator delete (this);
  goto <D.80211>;
  <D.80210>:
  <D.80211>:
}


virtual Glib::Interface::~Interface() (struct Interface * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.107;
  const void * * D.80220;
  sizetype iftmp.108;
  int (*__vtbl_ptr_type) () * D.80225;
  int (*__vtbl_ptr_type) () * D.80226;
  long int D.80227;
  struct ObjectBase * D.80229;
  int (*__vtbl_ptr_type) () * iftmp.109;
  int D.80234;
  const void * * iftmp.110;
  struct ObjectBase * D.80241;
  struct trackable * D.80245;
  int D.80247;

  {
    if (2 == 0) goto <D.80218>; else goto <D.80219>;
    <D.80218>:
    D.80220 = 0B;
    iftmp.107 = *D.80220;
    goto <D.80221>;
    <D.80219>:
    iftmp.107 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 32B];
    <D.80221>:
    this->_vptr.Interface = iftmp.107;
    if (2 == 0) goto <D.80223>; else goto <D.80224>;
    <D.80223>:
    D.80225 = this->_vptr.Interface;
    D.80226 = D.80225 + 18446744073709551592;
    D.80227 = MEM[(long int *)D.80226];
    iftmp.108 = (sizetype) D.80227;
    goto <D.80228>;
    <D.80224>:
    iftmp.108 = 8;
    <D.80228>:
    D.80229 = this + iftmp.108;
    if (2 == 0) goto <D.80231>; else goto <D.80232>;
    <D.80231>:
    iftmp.109 = MEM[(const void * *)0B + 8B];
    goto <D.80233>;
    <D.80232>:
    iftmp.109 = &MEM[(void *)&_ZTVN4Glib9InterfaceE + 112B];
    <D.80233>:
    D.80229->_vptr.ObjectBase = iftmp.109;
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.80234 = 2;
                if (D.80234 != 0) goto <D.80235>; else goto <D.80236>;
                <D.80235>:
                if (2 == 0) goto <D.80238>; else goto <D.80239>;
                <D.80238>:
                iftmp.110 = 16B;
                goto <D.80240>;
                <D.80239>:
                iftmp.110 = &MEM[(void *)&_ZTTN4Glib9InterfaceE + 16B];
                <D.80240>:
                D.80241 = &this->D.74379;
                Glib::ObjectBase::~ObjectBase (D.80241, iftmp.110);
                goto <D.80242>;
                <D.80236>:
                <D.80242>:
              }
          }
        finally
          {
            D.80234 = 2;
            if (D.80234 != 0) goto <D.80243>; else goto <D.80244>;
            <D.80243>:
            D.80245 = &this->D.74380;
            sigc::trackable::~trackable (D.80245);
            goto <D.80246>;
            <D.80244>:
            <D.80246>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.76428>:
  D.80247 = 0;
  if (D.80247 != 0) goto <D.80248>; else goto <D.80249>;
  <D.80248>:
  operator delete (this);
  goto <D.80250>;
  <D.80249>:
  <D.80250>:
}


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


static GType Glib::Interface::get_type() ()
{
  GType D.80256;

  D.80256 = 8;
  return D.80256;
}


static GType Glib::Interface::get_base_type() ()
{
  GType D.80258;

  D.80258 = 8;
  return D.80258;
}


Glib::RefPtr<Glib::ObjectBase> Glib::wrap_interface(GObject*, bool) (struct GObject * object, bool take_copy)
{
  int D.80261;
  struct ObjectBase * D.80262;

  D.80261 = (int) take_copy;
  D.80262 = Glib::wrap_auto (object, D.80261);
  Glib::RefPtr<Glib::ObjectBase>::RefPtr (<retval>, D.80262);
  return <retval>;
}


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