void Glib::custom_get_property_callback(GObject*, unsigned int, GValue*, GParamSpec*) (struct GObject * object, unsigned int property_id, struct GValue * value, struct GParamSpec * param_spec)
{
  bool retval.0;
  int retval.1;
  long int D.75611;
  long int D.75612;
  struct GTypeClass * D.75616;
  unsigned int iface_properties_quark.2;
  long unsigned int D.75621;
  unsigned int D.75626;
  long unsigned int D.75627;
  struct _GValue * & D.75628;
  struct _GValue * D.75629;
  struct _GValue * & D.75631;
  struct _GValue * D.75632;
  unsigned int D.75636;
  unsigned int D.75637;
  struct ObjectBase * iftmp.3;
  struct Object * D.75641;
  int (*__vtbl_ptr_type) () * D.75644;
  int (*__vtbl_ptr_type) () * D.75645;
  long int D.75646;
  sizetype D.75647;
  struct GParamSpec * D.75650;
  struct ValueBase * D.75652;
  struct GValue * D.75653;
  struct GTypeClass * D.75654;
  long unsigned int D.75655;
  const gchar * D.75656;
  struct GTypeClass * D.75657;
  long unsigned int D.75658;
  const gchar * D.75659;
  const gchar * D.75660;
  static const char __PRETTY_FUNCTION__[86] = "void Glib::custom_get_property_callback(GObject*, unsigned int, GValue*, GParamSpec*)";
  GType custom_type;
  struct iface_properties_type * iface_props;
  size_type iface_props_size;

  {
    {
      {
        int _g_boolean_var_;

        if (property_id != 0) goto <D.75608>; else goto <D.75609>;
        <D.75608>:
        _g_boolean_var_ = 1;
        goto <D.75610>;
        <D.75609>:
        _g_boolean_var_ = 0;
        <D.75610>:
        retval.1 = _g_boolean_var_;
      }
      D.75611 = (long int) retval.1;
      D.75612 = __builtin_expect (D.75611, 1);
      retval.0 = D.75612 != 0;
      if (retval.0 != 0) goto <D.75613>; else goto <D.75614>;
      <D.75613>:
      goto <D.75615>;
      <D.75614>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "property_id != 0");
      return;
      <D.75615>:
    }
  }
  D.75616 = MEM[(struct GTypeInstance *)object].g_class;
  custom_type = D.75616->g_type;
  iface_properties_quark.2 = iface_properties_quark;
  iface_props = g_type_get_qdata (custom_type, iface_properties_quark.2);
  iface_props_size = 0;
  if (iface_props != 0B) goto <D.75618>; else goto <D.75619>;
  <D.75618>:
  iface_props_size = std::vector<_GValue*>::size (iface_props);
  goto <D.75620>;
  <D.75619>:
  <D.75620>:
  {
    D.75621 = (long unsigned int) property_id;
    if (D.75621 <= iface_props_size) goto <D.75622>; else goto <D.75623>;
    <D.75622>:
    {
      struct iface_properties_type * obj_iface_props;

      iface_properties_quark.2 = iface_properties_quark;
      obj_iface_props = g_object_get_qdata (object, iface_properties_quark.2);
      if (obj_iface_props != 0B) goto <D.75624>; else goto <D.75625>;
      <D.75624>:
      D.75626 = property_id + 4294967295;
      D.75627 = (long unsigned int) D.75626;
      D.75628 = std::vector<_GValue*>::operator[] (obj_iface_props, D.75627);
      D.75629 = *D.75628;
      g_value_copy (D.75629, value);
      goto <D.75630>;
      <D.75625>:
      D.75626 = property_id + 4294967295;
      D.75627 = (long unsigned int) D.75626;
      D.75631 = std::vector<_GValue*>::operator[] (iface_props, D.75627);
      D.75632 = *D.75631;
      g_value_copy (D.75632, value);
      <D.75630>:
    }
    goto <D.75633>;
    <D.75623>:
    {
      {
        struct ObjectBase * const wrapper;

        wrapper = Glib::ObjectBase::_get_current_wrapper (object);
        if (wrapper != 0B) goto <D.75634>; else goto <D.75635>;
        <D.75634>:
        {
          struct PropertyBase & property;

          D.75636 = (unsigned int) iface_props_size;
          D.75637 = property_id - D.75636;
          property = {anonymous}::property_from_id (wrapper, D.75637);
          {
            D.75641 = property->object_;
            if (D.75641 != 0B) goto <D.75642>; else goto <D.75643>;
            <D.75642>:
            D.75641 = property->object_;
            D.75641 = property->object_;
            D.75644 = D.75641->_vptr.Object;
            D.75645 = D.75644 + 18446744073709551592;
            D.75646 = MEM[(long int *)D.75645];
            D.75647 = (sizetype) D.75646;
            iftmp.3 = D.75641 + D.75647;
            goto <D.75648>;
            <D.75643>:
            iftmp.3 = 0B;
            <D.75648>:
            if (iftmp.3 == wrapper) goto <D.75649>; else goto <D.75638>;
            <D.75649>:
            D.75650 = property->param_spec_;
            if (D.75650 == param_spec) goto <D.75651>; else goto <D.75638>;
            <D.75651>:
            D.75652 = &property->value_;
            D.75653 = Glib::ValueBase::gobj (D.75652);
            g_value_copy (D.75653, value);
            goto <D.75639>;
            <D.75638>:
            {
              {
                struct GObject * _glib__object;
                struct GParamSpec * _glib__pspec;
                guint _glib__property_id;

                _glib__object = object;
                _glib__pspec = param_spec;
                _glib__property_id = property_id;
                D.75654 = MEM[(struct GTypeInstance *)_glib__object].g_class;
                D.75655 = D.75654->g_type;
                D.75656 = g_type_name (D.75655);
                D.75657 = MEM[(struct GTypeInstance *)_glib__pspec].g_class;
                D.75658 = D.75657->g_type;
                D.75659 = g_type_name (D.75658);
                D.75660 = _glib__pspec->name;
                g_log ("glibmm", 16, "%s: invalid %s id %u for \"%s\" of type \'%s\' in \'%s\'", "property.cc:160", "property", _glib__property_id, D.75660, D.75659, D.75656);
              }
            }
            <D.75639>:
          }
        }
        goto <D.75661>;
        <D.75635>:
        <D.75661>:
      }
    }
    <D.75633>:
  }
}


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.75668;
  struct _GValue * * D.75669;
  long int D.75670;
  struct _GValue * * D.75671;
  long int D.75672;
  long int D.75673;
  long int D.75674;

  D.75669 = this->D.74428._M_impl._M_finish;
  D.75670 = (long int) D.75669;
  D.75671 = this->D.74428._M_impl._M_start;
  D.75672 = (long int) D.75671;
  D.75673 = D.75670 - D.75672;
  D.75674 = D.75673 /[ex] 8;
  D.75668 = (size_type) D.75674;
  return D.75668;
}


std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::operator[](std::vector<_Tp, _Alloc>::size_type) [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>; std::vector<_Tp, _Alloc>::reference = _GValue*&; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (struct vector * const this, size_type __n)
{
  struct _GValue * & D.75676;
  struct _GValue * * D.75677;
  long unsigned int D.75678;

  D.75677 = this->D.74428._M_impl._M_start;
  D.75678 = __n * 8;
  D.75676 = D.75677 + D.75678;
  return D.75676;
}


Glib::PropertyBase& {anonymous}::property_from_id(Glib::ObjectBase&, unsigned int) (struct ObjectBase & object, unsigned int property_id)
{
  void * iftmp.4;
  int (*__vtbl_ptr_type) () * D.75684;
  int (*__vtbl_ptr_type) () * D.75685;
  int (*__vtbl_ptr_type) () D.75686;
  sizetype D.75687;
  sizetype D.75688;
  struct PropertyBase & D.75689;
  void * const base_ptr;
  void * const prop_ptr;

  if (object == 0B) goto <D.75681>; else goto <D.75682>;
  <D.75681>:
  iftmp.4 = 0B;
  goto <D.75683>;
  <D.75682>:
  D.75684 = object->_vptr.ObjectBase;
  D.75685 = D.75684 + 18446744073709551600;
  D.75686 = *D.75685;
  D.75687 = (sizetype) D.75686;
  iftmp.4 = object + D.75687;
  <D.75683>:
  base_ptr = iftmp.4;
  D.75688 = (sizetype) property_id;
  prop_ptr = base_ptr + D.75688;
  D.75689 = prop_ptr;
  return D.75689;
}


GValue* Glib::ValueBase::gobj() (struct ValueBase * const this)
{
  struct GValue * D.75691;

  D.75691 = &this->gobject_;
  return D.75691;
}


void Glib::custom_set_property_callback(GObject*, unsigned int, const GValue*, GParamSpec*) (struct GObject * object, unsigned int property_id, const struct GValue * value, struct GParamSpec * param_spec)
{
  bool retval.5;
  int retval.6;
  long int D.75698;
  long int D.75699;
  struct GTypeClass * D.75703;
  unsigned int iface_properties_quark.7;
  long unsigned int D.75708;
  void * obj_iface_props.8;
  int D.75719;
  long unsigned int D.75722;
  long unsigned int D.75723;
  struct _GValue * & D.75724;
  struct _GValue * D.75725;
  long unsigned int D.75726;
  struct GValue * g_value.9;
  struct _GValue * & D.75728;
  struct _GValue * D.75729;
  unsigned int D.75731;
  long unsigned int D.75732;
  struct _GValue * & D.75733;
  struct _GValue * D.75734;
  unsigned int D.75738;
  unsigned int D.75739;
  struct ObjectBase * iftmp.10;
  struct Object * D.75743;
  int (*__vtbl_ptr_type) () * D.75746;
  int (*__vtbl_ptr_type) () * D.75747;
  long int D.75748;
  sizetype D.75749;
  struct GParamSpec * D.75752;
  struct ValueBase * D.75754;
  struct GValue * D.75755;
  struct GTypeClass * D.75756;
  long unsigned int D.75757;
  const gchar * D.75758;
  struct GTypeClass * D.75759;
  long unsigned int D.75760;
  const gchar * D.75761;
  const gchar * D.75762;
  static const char __PRETTY_FUNCTION__[92] = "void Glib::custom_set_property_callback(GObject*, unsigned int, const GValue*, GParamSpec*)";
  GType custom_type;
  struct iface_properties_type * iface_props;
  size_type iface_props_size;

  {
    {
      {
        int _g_boolean_var_;

        if (property_id != 0) goto <D.75695>; else goto <D.75696>;
        <D.75695>:
        _g_boolean_var_ = 1;
        goto <D.75697>;
        <D.75696>:
        _g_boolean_var_ = 0;
        <D.75697>:
        retval.6 = _g_boolean_var_;
      }
      D.75698 = (long int) retval.6;
      D.75699 = __builtin_expect (D.75698, 1);
      retval.5 = D.75699 != 0;
      if (retval.5 != 0) goto <D.75700>; else goto <D.75701>;
      <D.75700>:
      goto <D.75702>;
      <D.75701>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "property_id != 0");
      return;
      <D.75702>:
    }
  }
  D.75703 = MEM[(struct GTypeInstance *)object].g_class;
  custom_type = D.75703->g_type;
  iface_properties_quark.7 = iface_properties_quark;
  iface_props = g_type_get_qdata (custom_type, iface_properties_quark.7);
  iface_props_size = 0;
  if (iface_props != 0B) goto <D.75705>; else goto <D.75706>;
  <D.75705>:
  iface_props_size = std::vector<_GValue*>::size (iface_props);
  goto <D.75707>;
  <D.75706>:
  <D.75707>:
  {
    D.75708 = (long unsigned int) property_id;
    if (D.75708 <= iface_props_size) goto <D.75709>; else goto <D.75710>;
    <D.75709>:
    {
      struct iface_properties_type * obj_iface_props;

      iface_properties_quark.7 = iface_properties_quark;
      obj_iface_props = g_object_get_qdata (object, iface_properties_quark.7);
      {
        if (obj_iface_props == 0B) goto <D.75711>; else goto <D.75712>;
        <D.75711>:
        {
          obj_iface_props.8 = operator new (24);
          try
            {
              std::vector<_GValue*>::vector (obj_iface_props.8);
            }
          catch
            {
              operator delete (obj_iface_props.8);
            }
          obj_iface_props = obj_iface_props.8;
          iface_properties_quark.7 = iface_properties_quark;
          g_object_set_qdata_full (object, iface_properties_quark.7, obj_iface_props, destroy_notify_obj_iface_props);
          {
            size_type p;

            p = 0;
            goto <D.74485>;
            <D.74484>:
            {
              struct GValue * g_value;

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

                    __n = 1;
                    __s = 24;
                    if (__s == 1) goto <D.75713>; else goto <D.75714>;
                    <D.75713>:
                    __p = g_malloc0 (__n);
                    goto <D.75715>;
                    <D.75714>:
                    D.75719 = __builtin_constant_p (__n);
                    if (D.75719 != 0) goto <D.75720>; else goto <D.75716>;
                    <D.75720>:
                    if (__s == 0) goto <D.75717>; else goto <D.75721>;
                    <D.75721>:
                    D.75722 = 18446744073709551615 / __s;
                    if (D.75722 >= __n) goto <D.75717>; else goto <D.75716>;
                    <D.75717>:
                    D.75723 = __n * __s;
                    __p = g_malloc0 (D.75723);
                    goto <D.75718>;
                    <D.75716>:
                    __p = g_malloc0_n (__n, __s);
                    <D.75718>:
                    <D.75715>:
                    g_value = __p;
                  }
                  D.75724 = std::vector<_GValue*>::operator[] (iface_props, p);
                  D.75725 = *D.75724;
                  D.75726 = MEM[(struct GValue *)D.75725].g_type;
                  g_value.9 = g_value;
                  g_value_init (g_value.9, D.75726);
                  g_value.9 = g_value;
                  D.75728 = std::vector<_GValue*>::operator[] (iface_props, p);
                  D.75729 = *D.75728;
                  g_value_copy (D.75729, g_value.9);
                  std::vector<_GValue*>::push_back (obj_iface_props, &g_value);
                }
              finally
                {
                  g_value = {CLOBBER};
                }
            }
            p = p + 1;
            <D.74485>:
            if (p < iface_props_size) goto <D.74484>; else goto <D.74482>;
            <D.74482>:
          }
        }
        goto <D.75730>;
        <D.75712>:
        <D.75730>:
      }
      D.75731 = property_id + 4294967295;
      D.75732 = (long unsigned int) D.75731;
      D.75733 = std::vector<_GValue*>::operator[] (obj_iface_props, D.75732);
      D.75734 = *D.75733;
      g_value_copy (value, D.75734);
      g_object_notify_by_pspec (object, param_spec);
    }
    goto <D.75735>;
    <D.75710>:
    {
      {
        struct ObjectBase * const wrapper;

        wrapper = Glib::ObjectBase::_get_current_wrapper (object);
        if (wrapper != 0B) goto <D.75736>; else goto <D.75737>;
        <D.75736>:
        {
          struct PropertyBase & property;

          D.75738 = (unsigned int) iface_props_size;
          D.75739 = property_id - D.75738;
          property = {anonymous}::property_from_id (wrapper, D.75739);
          {
            D.75743 = property->object_;
            if (D.75743 != 0B) goto <D.75744>; else goto <D.75745>;
            <D.75744>:
            D.75743 = property->object_;
            D.75743 = property->object_;
            D.75746 = D.75743->_vptr.Object;
            D.75747 = D.75746 + 18446744073709551592;
            D.75748 = MEM[(long int *)D.75747];
            D.75749 = (sizetype) D.75748;
            iftmp.10 = D.75743 + D.75749;
            goto <D.75750>;
            <D.75745>:
            iftmp.10 = 0B;
            <D.75750>:
            if (iftmp.10 == wrapper) goto <D.75751>; else goto <D.75740>;
            <D.75751>:
            D.75752 = property->param_spec_;
            if (D.75752 == param_spec) goto <D.75753>; else goto <D.75740>;
            <D.75753>:
            D.75754 = &property->value_;
            D.75755 = Glib::ValueBase::gobj (D.75754);
            g_value_copy (value, D.75755);
            g_object_notify_by_pspec (object, param_spec);
            goto <D.75741>;
            <D.75740>:
            {
              {
                struct GObject * _glib__object;
                struct GParamSpec * _glib__pspec;
                guint _glib__property_id;

                _glib__object = object;
                _glib__pspec = param_spec;
                _glib__property_id = property_id;
                D.75756 = MEM[(struct GTypeInstance *)_glib__object].g_class;
                D.75757 = D.75756->g_type;
                D.75758 = g_type_name (D.75757);
                D.75759 = MEM[(struct GTypeInstance *)_glib__pspec].g_class;
                D.75760 = D.75759->g_type;
                D.75761 = g_type_name (D.75760);
                D.75762 = _glib__pspec->name;
                g_log ("glibmm", 16, "%s: invalid %s id %u for \"%s\" of type \'%s\' in \'%s\'", "property.cc:217", "property", _glib__property_id, D.75762, D.75761, D.75758);
              }
            }
            <D.75741>:
          }
        }
        goto <D.75763>;
        <D.75737>:
        <D.75763>:
      }
    }
    <D.75735>:
  }
}


void {anonymous}::destroy_notify_obj_iface_props(void*) (void * data)
{
  struct _GValue * & D.75779;
  struct _GValue * D.75780;
  struct _GValue * & D.75781;
  struct _GValue * D.75782;
  bool retval.11;
  long unsigned int D.75784;
  struct iface_properties_type * obj_iface_props.12;
  struct iface_properties_type * obj_iface_props;

  obj_iface_props = data;
  {
    if (obj_iface_props != 0B) goto <D.75777>; else goto <D.75778>;
    <D.75777>:
    {
      {
        size_type i;

        i = 0;
        goto <D.74434>;
        <D.74433>:
        D.75779 = std::vector<_GValue*>::operator[] (obj_iface_props, i);
        D.75780 = *D.75779;
        g_value_unset (D.75780);
        D.75781 = std::vector<_GValue*>::operator[] (obj_iface_props, i);
        D.75782 = *D.75781;
        g_free (D.75782);
        i = i + 1;
        <D.74434>:
        D.75784 = std::vector<_GValue*>::size (obj_iface_props);
        retval.11 = D.75784 > i;
        if (retval.11 != 0) goto <D.74433>; else goto <D.74431>;
        <D.74431>:
      }
      obj_iface_props.12 = obj_iface_props;
      if (obj_iface_props.12 != 0B) goto <D.75786>; else goto <D.75787>;
      <D.75786>:
      std::vector<_GValue*>::~vector (obj_iface_props.12);
      operator delete (obj_iface_props.12);
      goto <D.75788>;
      <D.75787>:
      <D.75788>:
    }
    goto <D.75789>;
    <D.75778>:
    <D.75789>:
  }
}


std::vector<_Tp, _Alloc>::~vector() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>] (struct vector * const this)
{
  struct _Vector_base * D.75790;
  struct _Tp_alloc_type & D.75791;
  struct _GValue * * D.75792;
  struct _GValue * * D.75793;

  {
    try
      {
        try
          {
            D.75790 = &this->D.74428;
            D.75791 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75790);
            D.75792 = this->D.74428._M_impl._M_finish;
            D.75793 = this->D.74428._M_impl._M_start;
            std::_Destroy<_GValue**, _GValue*> (D.75793, D.75792, D.75791);
          }
        finally
          {
            D.75790 = &this->D.74428;
            std::_Vector_base<_GValue*, std::allocator<_GValue*> >::~_Vector_base (D.75790);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.74869>:
}


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

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


void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = _GValue**; _Tp = _GValue*] (struct _GValue * * __first, struct _GValue * * __last, struct allocator & D.74862)
{
  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.75318, struct _GValue * * D.75319)
{
  GIMPLE_NOP
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = _GValue*; _Alloc = std::allocator<_GValue*>] (struct _Vector_base * const this)
{
  struct _GValue * * D.75798;
  long int D.75799;
  struct _GValue * * D.75800;
  long int D.75801;
  long int D.75802;
  long int D.75803;
  long unsigned int D.75804;
  struct _Vector_impl * D.75805;

  {
    try
      {
        try
          {
            D.75798 = this->_M_impl._M_end_of_storage;
            D.75799 = (long int) D.75798;
            D.75800 = this->_M_impl._M_start;
            D.75801 = (long int) D.75800;
            D.75802 = D.75799 - D.75801;
            D.75803 = D.75802 /[ex] 8;
            D.75804 = (long unsigned int) D.75803;
            D.75800 = this->_M_impl._M_start;
            std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_deallocate (this, D.75800, D.75804);
          }
        finally
          {
            D.75805 = &this->_M_impl;
            std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_Vector_impl::~_Vector_impl (D.75805);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.75141>:
}


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.75810;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.75808>; else goto <D.75809>;
  <D.75808>:
  D.75810 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::deallocate (D.75810, __p, __n);
  goto <D.75811>;
  <D.75809>:
  <D.75811>:
}


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.73745)
{
  operator delete (__p);
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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

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


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

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

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


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

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

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


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

  try
    {
      {

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


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.75818;
  struct _GValue * * D.75819;
  struct _Vector_impl * D.75822;
  struct _GValue * * D.75823;
  struct __normal_iterator D.75825;

  D.75818 = this->D.74428._M_impl._M_finish;
  D.75819 = this->D.74428._M_impl._M_end_of_storage;
  if (D.75818 != D.75819) goto <D.75820>; else goto <D.75821>;
  <D.75820>:
  D.75818 = this->D.74428._M_impl._M_finish;
  D.75822 = &this->D.74428._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.75822, D.75818, __x);
  D.75818 = this->D.74428._M_impl._M_finish;
  D.75823 = D.75818 + 8;
  this->D.74428._M_impl._M_finish = D.75823;
  goto <D.75824>;
  <D.75821>:
  D.75825 = std::vector<_GValue*>::end (this);
  std::vector<_GValue*>::_M_insert_aux (this, D.75825, __x);
  <D.75824>:
}


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.75324;
  void * D.75325;
  struct _GValue * * iftmp.13;
  struct _GValue * D.75829;

  D.75324 = __p;
  D.75325 = operator new (8, D.75324);
  if (D.75325 != 0B) goto <D.75827>; else goto <D.75828>;
  <D.75827>:
  try
    {
      D.75829 = *__val;
      MEM[(struct _GValue * *)D.75325] = D.75829;
    }
  catch
    {
      operator delete (D.75325, D.75324);
    }
  iftmp.13 = D.75325;
  goto <D.75830>;
  <D.75828>:
  iftmp.13 = D.75325;
  <D.75830>:
}


void* operator new(std::size_t, void*) (size_t D.14920, void * __p)
{
  void * D.75831;
  void * D.75832;

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


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.75834;
  struct iterator D.75180;
  struct _GValue * * * D.75835;

  D.75835 = &this->D.74428._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::__normal_iterator (&D.75180, D.75835);
  try
    {
      D.75834 = D.75180;
      return D.75834;
    }
  finally
    {
      D.75180 = {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.75838;

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


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.75839;
  struct _GValue * * D.75840;
  struct _GValue * const * D.75843;
  struct _Vector_impl * D.75844;
  struct _GValue * * D.75845;
  struct _GValue * * D.75846;
  struct _GValue * * D.75847;
  struct _GValue * * const & D.75848;
  struct _GValue * * D.75849;
  struct _GValue * & D.75850;
  struct iterator D.75165;
  long int D.75852;
  struct _Vector_base * D.75853;
  long unsigned int D.75854;
  struct _GValue * * D.75855;
  struct _Tp_alloc_type & D.75856;
  struct _GValue * * const & D.75857;
  struct _GValue * * D.75858;
  struct _GValue * * D.75859;
  struct _Tp_alloc_type & D.75860;
  struct _GValue * * const & D.75861;
  struct _GValue * * D.75862;
  void * D.75863;
  struct _Tp_alloc_type & D.75867;
  struct _Tp_alloc_type & D.75868;
  long int D.75869;
  long int D.75870;
  long int D.75871;
  long int D.75872;
  long unsigned int D.75873;
  long unsigned int D.75874;
  struct _GValue * * D.75875;

  {
    D.75839 = this->D.74428._M_impl._M_finish;
    D.75840 = this->D.74428._M_impl._M_end_of_storage;
    if (D.75839 != D.75840) goto <D.75841>; else goto <D.75842>;
    <D.75841>:
    {
      struct _GValue * __x_copy;

      D.75839 = this->D.74428._M_impl._M_finish;
      D.75843 = D.75839 + 18446744073709551608;
      D.75839 = this->D.74428._M_impl._M_finish;
      D.75844 = &this->D.74428._M_impl;
      __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.75844, D.75839, D.75843);
      D.75839 = this->D.74428._M_impl._M_finish;
      D.75845 = D.75839 + 8;
      this->D.74428._M_impl._M_finish = D.75845;
      __x_copy = *__x;
      D.75839 = this->D.74428._M_impl._M_finish;
      D.75846 = D.75839 + 18446744073709551608;
      D.75839 = this->D.74428._M_impl._M_finish;
      D.75847 = D.75839 + 18446744073709551600;
      D.75848 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
      D.75849 = *D.75848;
      std::copy_backward<_GValue**, _GValue**> (D.75849, D.75847, D.75846);
      D.75850 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::operator* (&__position);
      *D.75850 = __x_copy;
    }
    goto <D.75851>;
    <D.75842>:
    {
      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.75165 = std::vector<_GValue*>::begin (this);
      try
        {
          D.75852 = __gnu_cxx::operator-<_GValue**, std::vector<_GValue*> > (&__position, &D.75165);
          __elems_before = (const size_type) D.75852;
        }
      finally
        {
          D.75165 = {CLOBBER};
        }
      D.75853 = &this->D.74428;
      __new_start = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_allocate (D.75853, __len);
      __new_finish = __new_start;
      try
        {
          D.75854 = __elems_before * 8;
          D.75855 = __new_start + D.75854;
          D.75844 = &this->D.74428._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::construct<_GValue*> (D.75844, D.75855, __x);
          __new_finish = 0B;
          D.75853 = &this->D.74428;
          D.75856 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75853);
          D.75857 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
          D.75858 = *D.75857;
          D.75859 = this->D.74428._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<_GValue**, _GValue**, std::allocator<_GValue*> > (D.75859, D.75858, __new_start, D.75856);
          __new_finish = __new_finish + 8;
          D.75853 = &this->D.74428;
          D.75860 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75853);
          D.75839 = this->D.74428._M_impl._M_finish;
          D.75861 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (&__position);
          D.75862 = *D.75861;
          __new_finish = std::__uninitialized_move_if_noexcept_a<_GValue**, _GValue**, std::allocator<_GValue*> > (D.75862, D.75839, __new_finish, D.75860);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.75863 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.75863);
                  if (__new_finish == 0B) goto <D.75864>; else goto <D.75865>;
                  <D.75864>:
                  D.75854 = __elems_before * 8;
                  D.75855 = __new_start + D.75854;
                  D.75844 = &this->D.74428._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::destroy (D.75844, D.75855);
                  goto <D.75866>;
                  <D.75865>:
                  D.75853 = &this->D.74428;
                  D.75867 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75853);
                  std::_Destroy<_GValue**, _GValue*> (__new_start, __new_finish, D.75867);
                  <D.75866>:
                  D.75853 = &this->D.74428;
                  std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_deallocate (D.75853, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.75853 = &this->D.74428;
      D.75868 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75853);
      D.75839 = this->D.74428._M_impl._M_finish;
      D.75859 = this->D.74428._M_impl._M_start;
      std::_Destroy<_GValue**, _GValue*> (D.75859, D.75839, D.75868);
      D.75840 = this->D.74428._M_impl._M_end_of_storage;
      D.75869 = (long int) D.75840;
      D.75859 = this->D.74428._M_impl._M_start;
      D.75870 = (long int) D.75859;
      D.75871 = D.75869 - D.75870;
      D.75872 = D.75871 /[ex] 8;
      D.75873 = (long unsigned int) D.75872;
      D.75859 = this->D.74428._M_impl._M_start;
      D.75853 = &this->D.74428;
      std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_deallocate (D.75853, D.75859, D.75873);
      this->D.74428._M_impl._M_start = __new_start;
      this->D.74428._M_impl._M_finish = __new_finish;
      D.75874 = __len * 8;
      D.75875 = __new_start + D.75874;
      this->D.74428._M_impl._M_end_of_storage = D.75875;
    }
    <D.75851>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = _GValue**; _BI2 = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.75883;
  struct _GValue * * D.75884;
  struct _GValue * * D.75885;

  D.75884 = std::__miter_base<_GValue**> (__last);
  D.75885 = std::__miter_base<_GValue**> (__first);
  D.75883 = std::__copy_move_backward_a2<false, _GValue**, _GValue**> (D.75885, D.75884, __result);
  return D.75883;
}


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

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


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

  D.75892 = __it;
  return D.75892;
}


_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.75894;
  struct _GValue * * D.75895;
  struct _GValue * * D.75896;
  struct _GValue * * D.75897;

  D.75895 = std::__niter_base<_GValue**> (__result);
  D.75896 = std::__niter_base<_GValue**> (__last);
  D.75897 = std::__niter_base<_GValue**> (__first);
  D.75894 = std::__copy_move_backward_a<false, _GValue**, _GValue**> (D.75897, D.75896, D.75895);
  return D.75894;
}


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

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


_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.75902;
  typedef struct _GValue * _ValueType1;
  typedef struct _GValue * _ValueType2;
  typedef struct _Category _Category;
  const bool __simple;

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


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.14;
  long int __first.15;
  long int D.75906;
  long unsigned int _Num.16;
  long unsigned int D.75910;
  sizetype D.75911;
  struct _GValue * * D.75912;
  struct _GValue * * D.75914;
  const ptrdiff_t _Num;

  __last.14 = (long int) __last;
  __first.15 = (long int) __first;
  D.75906 = __last.14 - __first.15;
  _Num = D.75906 /[ex] 8;
  if (_Num != 0) goto <D.75907>; else goto <D.75908>;
  <D.75907>:
  _Num.16 = (long unsigned int) _Num;
  D.75910 = _Num.16 * 8;
  _Num.16 = (long unsigned int) _Num;
  D.75910 = _Num.16 * 8;
  D.75911 = -D.75910;
  D.75912 = __result + D.75911;
  __builtin_memmove (D.75912, __first, D.75910);
  goto <D.75913>;
  <D.75908>:
  <D.75913>:
  _Num.16 = (long unsigned int) _Num;
  D.75910 = _Num.16 * 8;
  D.75911 = -D.75910;
  D.75914 = __result + D.75911;
  return D.75914;
}


__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.75916;

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


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.17;
  long unsigned int D.75919;
  long unsigned int D.75920;
  long unsigned int D.75921;
  long unsigned int __n.18;
  long unsigned int D.75925;
  const long unsigned int D.75351;
  long unsigned int D.75926;
  const long unsigned int & D.75927;
  long unsigned int D.75928;
  size_type D.75929;
  size_type iftmp.19;
  long unsigned int D.75934;
  long unsigned int D.75936;
  const size_type __len;

  D.75919 = std::vector<_GValue*>::max_size (this);
  D.75920 = std::vector<_GValue*>::size (this);
  D.75921 = D.75919 - D.75920;
  __n.18 = __n;
  retval.17 = D.75921 < __n.18;
  if (retval.17 != 0) goto <D.75923>; else goto <D.75924>;
  <D.75923>:
  std::__throw_length_error (__s);
  <D.75924>:
  D.75925 = std::vector<_GValue*>::size (this);
  D.75926 = std::vector<_GValue*>::size (this);
  D.75351 = D.75926;
  try
    {
      D.75927 = std::max<long unsigned int> (&D.75351, &__n);
      D.75928 = *D.75927;
      __len = D.75925 + D.75928;
    }
  finally
    {
      D.75351 = {CLOBBER};
    }
  D.75934 = std::vector<_GValue*>::size (this);
  if (D.75934 > __len) goto <D.75931>; else goto <D.75935>;
  <D.75935>:
  D.75936 = std::vector<_GValue*>::max_size (this);
  if (D.75936 < __len) goto <D.75931>; else goto <D.75932>;
  <D.75931>:
  iftmp.19 = std::vector<_GValue*>::max_size (this);
  goto <D.75933>;
  <D.75932>:
  iftmp.19 = __len;
  <D.75933>:
  D.75929 = iftmp.19;
  return D.75929;
}


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.75941;
  long unsigned int D.75942;
  const long unsigned int & D.75945;

  D.75941 = *__a;
  D.75942 = *__b;
  if (D.75941 < D.75942) goto <D.75943>; else goto <D.75944>;
  <D.75943>:
  D.75945 = __b;
  return D.75945;
  <D.75944>:
  D.75945 = __a;
  return D.75945;
}


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.75947;
  const struct _Vector_base * D.75948;
  const struct _Tp_alloc_type & D.75949;

  D.75948 = &this->D.74428;
  D.75949 = std::_Vector_base<_GValue*, std::allocator<_GValue*> >::_M_get_Tp_allocator (D.75948);
  D.75947 = __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::max_size (D.75949);
  return D.75947;
}


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

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


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

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


__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.75955;
  void * D.75956;

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


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.75958;
  struct iterator D.75353;
  struct _GValue * * * D.75959;

  D.75959 = &this->D.74428._M_impl._M_start;
  __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::__normal_iterator (&D.75353, D.75959);
  try
    {
      D.75958 = D.75353;
      return D.75958;
    }
  finally
    {
      D.75353 = {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.75962;
  struct _GValue * * const & D.75963;
  struct _GValue * * D.75964;
  long int D.75965;
  struct _GValue * * const & D.75966;
  struct _GValue * * D.75967;
  long int D.75968;
  long int D.75969;

  D.75963 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (__lhs);
  D.75964 = *D.75963;
  D.75965 = (long int) D.75964;
  D.75966 = __gnu_cxx::__normal_iterator<_GValue**, std::vector<_GValue*> >::base (__rhs);
  D.75967 = *D.75966;
  D.75968 = (long int) D.75967;
  D.75969 = D.75965 - D.75968;
  D.75962 = D.75969 /[ex] 8;
  return D.75962;
}


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.75971;
  struct _GValue * * iftmp.20;
  struct _Vector_impl * D.75975;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.75973>; else goto <D.75974>;
  <D.75973>:
  D.75975 = &this->_M_impl;
  iftmp.20 = __gnu_cxx::__alloc_traits<std::allocator<_GValue*> >::allocate (D.75975, __n);
  goto <D.75976>;
  <D.75974>:
  iftmp.20 = 0B;
  <D.75976>:
  D.75971 = iftmp.20;
  return D.75971;
}


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

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


_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.73741)
{
  bool retval.21;
  long unsigned int D.75983;
  struct _GValue * * D.75986;
  long unsigned int D.75987;

  D.75983 = __gnu_cxx::new_allocator<_GValue*>::max_size (this);
  retval.21 = D.75983 < __n;
  if (retval.21 != 0) goto <D.75984>; else goto <D.75985>;
  <D.75984>:
  std::__throw_bad_alloc ();
  <D.75985>:
  D.75987 = __n * 8;
  D.75986 = operator new (D.75987);
  return D.75986;
}


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

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


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

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


_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.75362)
{
  struct _GValue * * D.75995;

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


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

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


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

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


_OI std::copy(_II, _II, _OI) [with _II = _GValue**; _OI = _GValue**] (struct _GValue * * __first, struct _GValue * * __last, struct _GValue * * __result)
{
  struct _GValue * * D.76004;
  struct _GValue * * D.76005;
  struct _GValue * * D.76006;

  D.76005 = std::__miter_base<_GValue**> (__last);
  D.76006 = std::__miter_base<_GValue**> (__first);
  D.76004 = std::__copy_move_a2<false, _GValue**, _GValue**> (D.76006, D.76005, __result);
  return D.76004;
}


_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.76011;
  struct _GValue * * D.76012;
  struct _GValue * * D.76013;
  struct _GValue * * D.76014;

  D.76012 = std::__niter_base<_GValue**> (__result);
  D.76013 = std::__niter_base<_GValue**> (__last);
  D.76014 = std::__niter_base<_GValue**> (__first);
  D.76011 = std::__copy_move_a<false, _GValue**, _GValue**> (D.76014, D.76013, D.76012);
  return D.76011;
}


_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.76017;
  typedef struct _GValue * _ValueTypeI;
  typedef struct _GValue * _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

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


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.22;
  long int __first.23;
  long int D.76021;
  long unsigned int _Num.24;
  long unsigned int D.76025;
  struct _GValue * * D.76027;
  const ptrdiff_t _Num;

  __last.22 = (long int) __last;
  __first.23 = (long int) __first;
  D.76021 = __last.22 - __first.23;
  _Num = D.76021 /[ex] 8;
  if (_Num != 0) goto <D.76022>; else goto <D.76023>;
  <D.76022>:
  _Num.24 = (long unsigned int) _Num;
  D.76025 = _Num.24 * 8;
  __builtin_memmove (__result, __first, D.76025);
  goto <D.76026>;
  <D.76023>:
  <D.76026>:
  _Num.24 = (long unsigned int) _Num;
  D.76025 = _Num.24 * 8;
  D.76027 = __result + D.76025;
  return D.76027;
}


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
}


Glib::PropertyBase::PropertyBase(Glib::Object&, GType) (struct PropertyBase * const this, struct Object & object, GType value_type)
{
  struct ValueBase * D.76029;

  this->object_ = object;
  D.76029 = &this->value_;
  Glib::ValueBase::ValueBase (D.76029);
  try
    {
      this->param_spec_ = 0B;
      D.76029 = &this->value_;
      Glib::ValueBase::init (D.76029, value_type);
    }
  catch
    {
      D.76029 = &this->value_;
      Glib::ValueBase::~ValueBase (D.76029);
    }
}


Glib::PropertyBase::~PropertyBase() (struct PropertyBase * const this)
{
  struct GParamSpec * D.76031;
  struct ValueBase * D.76035;

  {
    try
      {
        try
          {
            D.76031 = this->param_spec_;
            if (D.76031 != 0B) goto <D.76032>; else goto <D.76033>;
            <D.76032>:
            D.76031 = this->param_spec_;
            g_param_spec_unref (D.76031);
            goto <D.76034>;
            <D.76033>:
            <D.76034>:
          }
        finally
          {
            D.76035 = &this->value_;
            Glib::ValueBase::~ValueBase (D.76035);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.74504>:
}


bool Glib::PropertyBase::lookup_property(const Glib::ustring&) (struct PropertyBase * const this, const struct ustring & name)
{
  bool retval.25;
  int retval.26;
  struct GParamSpec * D.76040;
  long int D.76044;
  long int D.76045;
  const char * D.76049;
  struct Object * D.76050;
  int (*__vtbl_ptr_type) () * D.76051;
  int (*__vtbl_ptr_type) () * D.76052;
  long int D.76053;
  sizetype D.76054;
  struct ObjectBase * D.76055;
  struct GObject * D.76056;
  struct GTypeClass * D.76057;
  struct GParamSpec * D.76058;
  bool retval.27;
  int retval.28;
  bool retval.29;
  struct GTypeInstance * D.76064;
  long unsigned int D.76065;
  struct ValueBase * D.76066;
  struct GValue * D.76067;
  long unsigned int D.76068;
  long int D.76072;
  long int D.76073;
  bool D.76078;
  static const char __PRETTY_FUNCTION__[63] = "bool Glib::PropertyBase::lookup_property(const Glib::ustring&)";

  {
    {
      {
        int _g_boolean_var_;

        D.76040 = this->param_spec_;
        if (D.76040 == 0B) goto <D.76041>; else goto <D.76042>;
        <D.76041>:
        _g_boolean_var_ = 1;
        goto <D.76043>;
        <D.76042>:
        _g_boolean_var_ = 0;
        <D.76043>:
        retval.26 = _g_boolean_var_;
      }
      D.76044 = (long int) retval.26;
      D.76045 = __builtin_expect (D.76044, 1);
      retval.25 = D.76045 != 0;
      if (retval.25 != 0) goto <D.76046>; else goto <D.76047>;
      <D.76046>:
      goto <D.76048>;
      <D.76047>:
      g_assertion_message_expr ("glibmm", "property.cc", 242, &__PRETTY_FUNCTION__, "param_spec_ == 0");
      <D.76048>:
    }
  }
  D.76049 = Glib::ustring::c_str (name);
  D.76050 = this->object_;
  D.76050 = this->object_;
  D.76051 = D.76050->_vptr.Object;
  D.76052 = D.76051 + 18446744073709551592;
  D.76053 = MEM[(long int *)D.76052];
  D.76054 = (sizetype) D.76053;
  D.76055 = D.76050 + D.76054;
  D.76056 = Glib::ObjectBase::gobj (D.76055);
  D.76057 = MEM[(struct GTypeInstance *)D.76056].g_class;
  D.76058 = g_object_class_find_property (D.76057, D.76049);
  this->param_spec_ = D.76058;
  {
    D.76040 = this->param_spec_;
    if (D.76040 != 0B) goto <D.76059>; else goto <D.76060>;
    <D.76059>:
    {
      {
        {
          {
            int _g_boolean_var_;

            D.76040 = this->param_spec_;
            D.76064 = g_type_check_instance_cast (D.76040, 76);
            D.76065 = MEM[(struct GParamSpec *)D.76064].value_type;
            D.76066 = &this->value_;
            D.76067 = Glib::ValueBase::gobj (D.76066);
            D.76068 = D.76067->g_type;
            retval.29 = D.76065 == D.76068;
            if (retval.29 != 0) goto <D.76069>; else goto <D.76070>;
            <D.76069>:
            _g_boolean_var_ = 1;
            goto <D.76071>;
            <D.76070>:
            _g_boolean_var_ = 0;
            <D.76071>:
            retval.28 = _g_boolean_var_;
          }
          D.76072 = (long int) retval.28;
          D.76073 = __builtin_expect (D.76072, 1);
          retval.27 = D.76073 != 0;
          if (retval.27 != 0) goto <D.76074>; else goto <D.76075>;
          <D.76074>:
          goto <D.76076>;
          <D.76075>:
          g_assertion_message_expr ("glibmm", "property.cc", 248, &__PRETTY_FUNCTION__, "G_PARAM_SPEC_VALUE_TYPE(param_spec_) == G_VALUE_TYPE(value_.gobj())");
          <D.76076>:
        }
      }
      D.76040 = this->param_spec_;
      g_param_spec_ref (D.76040);
    }
    goto <D.76077>;
    <D.76060>:
    <D.76077>:
  }
  D.76040 = this->param_spec_;
  D.76078 = D.76040 != 0B;
  return D.76078;
}


GObject* Glib::ObjectBase::gobj() (struct ObjectBase * const this)
{
  struct GObject * D.76083;

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


void Glib::PropertyBase::install_property(GParamSpec*) (struct PropertyBase * const this, struct GParamSpec * param_spec)
{
  bool retval.30;
  int retval.31;
  long int D.76090;
  long int D.76091;
  struct Object * D.76095;
  int (*__vtbl_ptr_type) () * D.76096;
  int (*__vtbl_ptr_type) () * D.76097;
  long int D.76098;
  sizetype D.76099;
  struct ObjectBase * D.76100;
  struct GObject * D.76101;
  struct GTypeClass * D.76102;
  unsigned int iface_properties_quark.32;
  unsigned int D.76107;
  unsigned int D.76108;
  struct GObject * D.76109;
  struct GTypeClass * D.76110;
  struct GParamSpec * D.76111;
  static const char __PRETTY_FUNCTION__[55] = "void Glib::PropertyBase::install_property(GParamSpec*)";
  GType gtype;
  struct iface_properties_type * iface_props;
  size_type iface_props_size;
  const unsigned int property_id;

  {
    {
      {
        int _g_boolean_var_;

        if (param_spec != 0B) goto <D.76087>; else goto <D.76088>;
        <D.76087>:
        _g_boolean_var_ = 1;
        goto <D.76089>;
        <D.76088>:
        _g_boolean_var_ = 0;
        <D.76089>:
        retval.31 = _g_boolean_var_;
      }
      D.76090 = (long int) retval.31;
      D.76091 = __builtin_expect (D.76090, 1);
      retval.30 = D.76091 != 0;
      if (retval.30 != 0) goto <D.76092>; else goto <D.76093>;
      <D.76092>:
      goto <D.76094>;
      <D.76093>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "param_spec != 0");
      return;
      <D.76094>:
    }
  }
  D.76095 = this->object_;
  D.76095 = this->object_;
  D.76096 = D.76095->_vptr.Object;
  D.76097 = D.76096 + 18446744073709551592;
  D.76098 = MEM[(long int *)D.76097];
  D.76099 = (sizetype) D.76098;
  D.76100 = D.76095 + D.76099;
  D.76101 = Glib::ObjectBase::gobj (D.76100);
  D.76102 = MEM[(struct GTypeInstance *)D.76101].g_class;
  gtype = D.76102->g_type;
  iface_properties_quark.32 = iface_properties_quark;
  iface_props = g_type_get_qdata (gtype, iface_properties_quark.32);
  iface_props_size = 0;
  if (iface_props != 0B) goto <D.76104>; else goto <D.76105>;
  <D.76104>:
  iface_props_size = std::vector<_GValue*>::size (iface_props);
  goto <D.76106>;
  <D.76105>:
  <D.76106>:
  D.76095 = this->object_;
  D.76095 = this->object_;
  D.76096 = D.76095->_vptr.Object;
  D.76097 = D.76096 + 18446744073709551592;
  D.76098 = MEM[(long int *)D.76097];
  D.76099 = (sizetype) D.76098;
  D.76100 = D.76095 + D.76099;
  D.76107 = {anonymous}::property_to_id (D.76100, this);
  D.76108 = (unsigned int) iface_props_size;
  property_id = D.76107 + D.76108;
  D.76095 = this->object_;
  D.76095 = this->object_;
  D.76096 = D.76095->_vptr.Object;
  D.76097 = D.76096 + 18446744073709551592;
  D.76098 = MEM[(long int *)D.76097];
  D.76099 = (sizetype) D.76098;
  D.76100 = D.76095 + D.76099;
  D.76109 = Glib::ObjectBase::gobj (D.76100);
  D.76110 = MEM[(struct GTypeInstance *)D.76109].g_class;
  g_object_class_install_property (D.76110, property_id, param_spec);
  this->param_spec_ = param_spec;
  D.76111 = this->param_spec_;
  g_param_spec_ref (D.76111);
}


unsigned int {anonymous}::property_to_id(Glib::ObjectBase&, Glib::PropertyBase&) (struct ObjectBase & object, struct PropertyBase & property)
{
  void * iftmp.33;
  int (*__vtbl_ptr_type) () * D.76119;
  int (*__vtbl_ptr_type) () * D.76120;
  int (*__vtbl_ptr_type) () D.76121;
  sizetype D.76122;
  long int prop_ptr.34;
  long int base_ptr.35;
  bool retval.36;
  int retval.37;
  unsigned long offset.38;
  unsigned long D.76128;
  long int D.76132;
  long int D.76133;
  unsigned int D.76137;
  void * const base_ptr;
  void * const prop_ptr;
  const ptrdiff_t offset;
  static const char __PRETTY_FUNCTION__[81] = "unsigned int {anonymous}::property_to_id(Glib::ObjectBase&, Glib::PropertyBase&)";

  if (object == 0B) goto <D.76116>; else goto <D.76117>;
  <D.76116>:
  iftmp.33 = 0B;
  goto <D.76118>;
  <D.76117>:
  D.76119 = object->_vptr.ObjectBase;
  D.76120 = D.76119 + 18446744073709551600;
  D.76121 = *D.76120;
  D.76122 = (sizetype) D.76121;
  iftmp.33 = object + D.76122;
  <D.76118>:
  base_ptr = iftmp.33;
  prop_ptr = property;
  prop_ptr.34 = (long int) prop_ptr;
  base_ptr.35 = (long int) base_ptr;
  offset = prop_ptr.34 - base_ptr.35;
  {
    {
      {
        int _g_boolean_var_;

        offset.38 = (unsigned long) offset;
        D.76128 = offset.38 + 18446744073709551615;
        if (D.76128 <= 2147483645) goto <D.76129>; else goto <D.76130>;
        <D.76129>:
        _g_boolean_var_ = 1;
        goto <D.76131>;
        <D.76130>:
        _g_boolean_var_ = 0;
        <D.76131>:
        retval.37 = _g_boolean_var_;
      }
      D.76132 = (long int) retval.37;
      D.76133 = __builtin_expect (D.76132, 1);
      retval.36 = D.76133 != 0;
      if (retval.36 != 0) goto <D.76134>; else goto <D.76135>;
      <D.76134>:
      goto <D.76136>;
      <D.76135>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "offset > 0 && offset < G_MAXINT");
      D.76137 = 0;
      return D.76137;
      <D.76136>:
    }
  }
  D.76137 = (unsigned int) offset;
  return D.76137;
}


const char* Glib::PropertyBase::get_name_internal() const (const struct PropertyBase * const this)
{
  struct GParamSpec * D.76139;
  bool retval.39;
  int retval.40;
  long int D.76145;
  long int D.76146;
  const char * D.76150;
  const char * const name;
  static const char __PRETTY_FUNCTION__[58] = "const char* Glib::PropertyBase::get_name_internal() const";

  D.76139 = this->param_spec_;
  name = g_param_spec_get_name (D.76139);
  {
    {
      {
        int _g_boolean_var_;

        if (name != 0B) goto <D.76142>; else goto <D.76143>;
        <D.76142>:
        _g_boolean_var_ = 1;
        goto <D.76144>;
        <D.76143>:
        _g_boolean_var_ = 0;
        <D.76144>:
        retval.40 = _g_boolean_var_;
      }
      D.76145 = (long int) retval.40;
      D.76146 = __builtin_expect (D.76145, 1);
      retval.39 = D.76146 != 0;
      if (retval.39 != 0) goto <D.76147>; else goto <D.76148>;
      <D.76147>:
      goto <D.76149>;
      <D.76148>:
      g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "name != 0");
      D.76150 = "";
      return D.76150;
      <D.76149>:
    }
  }
  D.76150 = name;
  return D.76150;
}


Glib::ustring Glib::PropertyBase::get_name() const (const struct PropertyBase * const this)
{
  const char * D.76154;

  D.76154 = Glib::PropertyBase::get_name_internal (this);
  Glib::ustring::ustring (<retval>, D.76154);
  return <retval>;
}


void Glib::PropertyBase::notify() (struct PropertyBase * const this)
{
  struct GParamSpec * D.76157;
  struct Object * D.76158;
  int (*__vtbl_ptr_type) () * D.76159;
  int (*__vtbl_ptr_type) () * D.76160;
  long int D.76161;
  sizetype D.76162;
  struct ObjectBase * D.76163;
  struct GObject * D.76164;

  D.76157 = this->param_spec_;
  D.76158 = this->object_;
  D.76158 = this->object_;
  D.76159 = D.76158->_vptr.Object;
  D.76160 = D.76159 + 18446744073709551592;
  D.76161 = MEM[(long int *)D.76160];
  D.76162 = (sizetype) D.76161;
  D.76163 = D.76158 + D.76162;
  D.76164 = Glib::ObjectBase::gobj (D.76163);
  g_object_notify_by_pspec (D.76164, D.76157);
}