void Gio::Settings::get_value(const Glib::ustring&, Glib::VariantBase&) const (const struct Settings * const this, const struct ustring & key, struct VariantBase & value)
{
  const char * D.100746;
  const struct GSettings * D.100747;
  struct GVariant * const g_value;

  D.100746 = Glib::ustring::c_str (key);
  D.100747 = Gio::Settings::gobj (this);
  g_value = g_settings_get_value (D.100747, D.100746);
  if (g_value == 0B) goto <D.100748>; else goto <D.100749>;
  <D.100748>:
  return;
  <D.100749>:
  Glib::VariantBase::init (value, g_value, 0);
}


const GSettings* Gio::Settings::gobj() const (const struct Settings * const this)
{
  const struct GSettings * D.100753;
  int (*__vtbl_ptr_type) () * D.100754;
  int (*__vtbl_ptr_type) () * D.100755;
  long int D.100756;
  sizetype D.100757;
  const struct ObjectBase * D.100758;

  D.100754 = this->D.96969._vptr.Object;
  D.100755 = D.100754 + 18446744073709551592;
  D.100756 = MEM[(long int *)D.100755];
  D.100757 = (sizetype) D.100756;
  D.100758 = this + D.100757;
  D.100753 = D.100758->gobject_;
  return D.100753;
}


bool Gio::Settings::get_user_value(const Glib::ustring&, Glib::VariantBase&) const (const struct Settings * const this, const struct ustring & key, struct VariantBase & value)
{
  const char * D.100760;
  const struct GSettings * D.100761;
  bool D.100764;
  struct GVariant * const g_value;

  D.100760 = Glib::ustring::c_str (key);
  D.100761 = Gio::Settings::gobj (this);
  g_value = g_settings_get_user_value (D.100761, D.100760);
  if (g_value == 0B) goto <D.100762>; else goto <D.100763>;
  <D.100762>:
  D.100764 = 0;
  return D.100764;
  <D.100763>:
  Glib::VariantBase::init (value, g_value, 0);
  D.100764 = 1;
  return D.100764;
}


void Gio::Settings::get_default_value(const Glib::ustring&, Glib::VariantBase&) const (const struct Settings * const this, const struct ustring & key, struct VariantBase & value)
{
  const char * D.100768;
  const struct GSettings * D.100769;
  struct GVariant * const g_value;

  D.100768 = Glib::ustring::c_str (key);
  D.100769 = Gio::Settings::gobj (this);
  g_value = g_settings_get_default_value (D.100769, D.100768);
  if (g_value == 0B) goto <D.100770>; else goto <D.100771>;
  <D.100770>:
  return;
  <D.100771>:
  Glib::VariantBase::init (value, g_value, 0);
}


void Gio::Settings::bind(const Glib::ustring&, const Glib::PropertyProxy_Base&, Gio::SettingsBindFlags) (struct Settings * const this, const struct ustring & key, const struct PropertyProxy_Base & property_proxy, SettingsBindFlags flags)
{
  const struct ustring D.97046;
  const char * D.100775;
  struct ObjectBase * D.100776;

  D.100775 = Glib::PropertyProxy_Base::get_name (property_proxy);
  Glib::ustring::ustring (&D.97046, D.100775);
  try
    {
      D.100776 = Glib::PropertyProxy_Base::get_object (property_proxy);
      Gio::Settings::bind (this, key, D.100776, &D.97046, flags);
    }
  finally
    {
      Glib::ustring::~ustring (&D.97046);
      D.97046 = {CLOBBER};
    }
}


const char* Glib::PropertyProxy_Base::get_name() const (const struct PropertyProxy_Base * const this)
{
  const char * D.100779;

  D.100779 = this->property_name_;
  return D.100779;
}


Glib::ObjectBase* Glib::PropertyProxy_Base::get_object() const (const struct PropertyProxy_Base * const this)
{
  struct ObjectBase * D.100781;

  D.100781 = this->obj_;
  return D.100781;
}


void Gio::Settings::bind_writable(const Glib::ustring&, const Glib::PropertyProxy_Base&, bool) (struct Settings * const this, const struct ustring & key, const struct PropertyProxy_Base & property_proxy, bool inverted)
{
  int D.100783;
  const struct ustring D.97053;
  const char * D.100784;
  struct ObjectBase * D.100785;

  D.100783 = (int) inverted;
  D.100784 = Glib::PropertyProxy_Base::get_name (property_proxy);
  Glib::ustring::ustring (&D.97053, D.100784);
  try
    {
      D.100785 = Glib::PropertyProxy_Base::get_object (property_proxy);
      Gio::Settings::bind_writable (this, key, D.100785, &D.97053, D.100783);
    }
  finally
    {
      Glib::ustring::~ustring (&D.97053);
      D.97053 = {CLOBBER};
    }
}


static std::vector<Glib::ustring> Gio::Settings::list_schemas() ()
{
  const gchar * const * D.100788;

  D.100788 = g_settings_list_schemas ();
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (D.100788, 0); [return slot optimization]
  return <retval>;
}


static Glib::ArrayHandler<T, Tr>::VectorType Glib::ArrayHandler<T, Tr>::array_to_vector(const CType*, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::ustring>; Glib::ArrayHandler<T, Tr>::CType = const char*] (const char * const * array, OwnershipType ownership)
{
  long unsigned int D.100792;

  D.100792 = Glib::Container_Helpers::compute_array_size2<const char*> (array);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (array, D.100792, ownership); [return slot optimization]
  return <retval>;
}


std::size_t Glib::Container_Helpers::compute_array_size2(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.100796;
  size_t D.100797;
  long int pend.0;
  long int array.1;
  long int D.100800;
  long int D.100801;

  {
    if (array != 0B) goto <D.100794>; else goto <D.100795>;
    <D.100794>:
    {
      const char * const * pend;

      pend = array;
      goto <D.99961>;
      <D.99962>:
      pend = pend + 8;
      <D.99961>:
      D.100796 = *pend;
      if (D.100796 != 0B) goto <D.99962>; else goto <D.99960>;
      <D.99960>:
      pend.0 = (long int) pend;
      array.1 = (long int) array;
      D.100800 = pend.0 - array.1;
      D.100801 = D.100800 /[ex] 8;
      D.100797 = (size_t) D.100801;
      return D.100797;
    }
    <D.100795>:
  }
  D.100797 = 0;
  return D.100797;
}


static Glib::ArrayHandler<T, Tr>::VectorType Glib::ArrayHandler<T, Tr>::array_to_vector(const CType*, std::size_t, Glib::OwnershipType) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::ustring>; Glib::ArrayHandler<T, Tr>::CType = const char*; std::size_t = long unsigned int] (const char * const * array, size_t array_size, OwnershipType ownership)
{
  struct allocator_type D.100098;
  struct ArrayIteratorType D.100081;
  long unsigned int D.100806;
  const char * const * D.100807;
  struct ArrayIteratorType D.100080;

  {
    if (array != 0B) goto <D.100804>; else goto <D.100805>;
    <D.100804>:
    {
      struct ArrayKeeperType keeper;

      try
        {
          Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayKeeper (&keeper, array, array_size, ownership);
          try
            {
              std::allocator<Glib::ustring>::allocator (&D.100098);
              try
                {
                  D.100806 = array_size * 8;
                  D.100807 = array + D.100806;
                  Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.100081, D.100807);
                  try
                    {
                      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.100080, array);
                      try
                        {
                          std::vector<Glib::ustring>::vector<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (<retval>, D.100080, D.100081, &D.100098);
                          return <retval>;
                        }
                      finally
                        {
                          D.100080 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.100081 = {CLOBBER};
                    }
                }
              finally
                {
                  std::allocator<Glib::ustring>::~allocator (&D.100098);
                  D.100098 = {CLOBBER};
                }
            }
          finally
            {
              Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::~ArrayKeeper (&keeper);
            }
        }
      finally
        {
          keeper = {CLOBBER};
        }
    }
    <D.100805>:
  }
  std::vector<Glib::ustring>::vector (<retval>);
  return <retval>;
}


Glib::Container_Helpers::ArrayKeeper<Tr>::ArrayKeeper(const CType*, std::size_t, Glib::OwnershipType) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayKeeper<Tr>::CType = const char*; std::size_t = long unsigned int] (struct ArrayKeeper * const this, const char * const * array, size_t array_size, OwnershipType ownership)
{
  this->array_ = array;
  this->array_size_ = array_size;
  this->ownership_ = ownership;
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<Glib::ustring>::new_allocator (this);
        try
          {

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


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

  try
    {
      {

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


Glib::Container_Helpers::ArrayIterator<Tr>::ArrayIterator(const CType*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::CType = const char*] (struct ArrayIterator * const this, const char * const * pos)
{
  this->pos_ = pos;
}


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.100821;
  struct _Integral D.100363;
  struct __false_type D.100822;

  D.100821 = &this->D.97798;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_base (D.100821, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<Glib::ustring>::_M_initialize_dispatch<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (this, __first, __last, D.100822);
          }
        finally
          {
            D.100363 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.100821 = &this->D.97798;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.100821);
    }
}


std::_Vector_base<_Tp, _Alloc>::_Vector_base(const allocator_type&) [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::_Vector_base<_Tp, _Alloc>::allocator_type = std::allocator<Glib::ustring>] (struct _Vector_base * const this, const struct allocator_type & __a)
{
  struct _Vector_impl * D.100825;

  D.100825 = &this->_M_impl;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::_Vector_impl (D.100825, __a);
  try
    {

    }
  catch
    {
      D.100825 = &this->_M_impl;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.100825);
    }
}


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


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

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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct __false_type D.100317)
{
  struct forward_iterator_tag D.100562;
  struct _IterCategory D.100534;
  struct _IterCategory * D.100828;
  struct forward_iterator_tag D.100829;
  typedef struct _IterCategory _IterCategory;

  try
    {
      D.100828 = &D.100534;
      std::vector<Glib::ustring>::_M_range_initialize<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (this, __first, __last, D.100829);
    }
  finally
    {
      D.100534 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct forward_iterator_tag D.100539)
{
  long int D.100831;
  struct _Vector_base * D.100832;
  struct ustring * D.100833;
  struct ustring * D.100834;
  long unsigned int D.100835;
  struct ustring * D.100836;
  struct _Tp_alloc_type & D.100837;
  struct ustring * D.100838;
  const size_type __n;

  D.100831 = std::distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (__first, __last);
  __n = (const size_type) D.100831;
  D.100832 = &this->D.97798;
  D.100833 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_allocate (D.100832, __n);
  this->D.97798._M_impl._M_start = D.100833;
  D.100834 = this->D.97798._M_impl._M_start;
  D.100835 = __n * 8;
  D.100836 = D.100834 + D.100835;
  this->D.97798._M_impl._M_end_of_storage = D.100836;
  D.100832 = &this->D.97798;
  D.100837 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.100832);
  D.100834 = this->D.97798._M_impl._M_start;
  D.100838 = std::__uninitialized_copy_a<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*, Glib::ustring> (__first, __last, D.100834, D.100837);
  this->D.97798._M_impl._M_finish = D.100838;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last)
{
  difference_type D.100842;
  struct iterator_category D.100676;
  struct random_access_iterator_tag D.100843;

  std::__iterator_category<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (&__first);
  try
    {
      D.100842 = std::__distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (__first, __last, D.100843);
      return D.100842;
    }
  finally
    {
      D.100676 = {CLOBBER};
    }
}


typename std::iterator_traits<_Iterator>::iterator_category std::__iterator_category(const _Iter&) [with _Iter = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::iterator_category = std::random_access_iterator_tag] (const struct ArrayIterator & D.100675)
{
  struct iterator_category D.100848;

  return D.100848;
}


typename std::iterator_traits<_Iterator>::difference_type std::__distance(_RandomAccessIterator, _RandomAccessIterator, std::random_access_iterator_tag) [with _RandomAccessIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; typename std::iterator_traits<_Iterator>::difference_type = long int] (struct ArrayIterator __first, struct ArrayIterator __last, struct random_access_iterator_tag D.100680)
{
  difference_type D.100850;

  D.100850 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator- (&__last, &__first);
  return D.100850;
}


Glib::Container_Helpers::ArrayIterator<Tr>::difference_type Glib::Container_Helpers::ArrayIterator<Tr>::operator-(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::difference_type = long int] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  difference_type D.100852;
  const char * const * D.100853;
  long int D.100854;
  const char * const * D.100855;
  long int D.100856;
  long int D.100857;

  D.100853 = this->pos_;
  D.100854 = (long int) D.100853;
  D.100855 = rhs->pos_;
  D.100856 = (long int) D.100855;
  D.100857 = D.100854 - D.100856;
  D.100852 = D.100857 /[ex] 8;
  return D.100852;
}


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

  if (__n != 0) goto <D.100861>; else goto <D.100862>;
  <D.100861>:
  D.100863 = &this->_M_impl;
  iftmp.2 = __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::allocate (D.100863, __n);
  goto <D.100864>;
  <D.100862>:
  iftmp.2 = 0B;
  <D.100864>:
  D.100859 = iftmp.2;
  return D.100859;
}


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

  D.100867 = __gnu_cxx::new_allocator<Glib::ustring>::allocate (__a, __n, 0B);
  return D.100867;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::ustring; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::ustring*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.97111)
{
  bool retval.3;
  long unsigned int D.100871;
  struct ustring * D.100874;
  long unsigned int D.100875;

  D.100871 = __gnu_cxx::new_allocator<Glib::ustring>::max_size (this);
  retval.3 = D.100871 < __n;
  if (retval.3 != 0) goto <D.100872>; else goto <D.100873>;
  <D.100872>:
  std::__throw_bad_alloc ();
  <D.100873>:
  D.100875 = __n * 8;
  D.100874 = operator new (D.100875);
  return D.100874;
}


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

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


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

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


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*; _Tp = Glib::ustring] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result, struct allocator & D.100646)
{
  struct ustring * D.100883;

  D.100883 = std::uninitialized_copy<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*> (__first, __last, __result);
  return D.100883;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result)
{
  struct ustring * D.100886;
  typedef struct _ValueType1 _ValueType1;
  typedef struct _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.100886 = std::__uninitialized_copy<false>::__uninit_copy<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*> (__first, __last, __result);
  return D.100886;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*; bool _TrivialValueTypes = false] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result)
{
  struct value_type D.100728;
  struct ustring * D.100889;
  bool retval.4;
  struct ustring * D.100891;
  void * D.100892;
  struct ustring * __cur;

  __cur = __result;
  try
    {
      goto <D.100732>;
      <D.100731>:
      D.100728 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator* (&__first); [return slot optimization]
      try
        {
          D.100889 = std::__addressof<Glib::ustring> (__cur);
          std::_Construct<Glib::ustring, Glib::ustring> (D.100889, &D.100728);
        }
      finally
        {
          Glib::ustring::~ustring (&D.100728);
          D.100728 = {CLOBBER};
        }
      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator++ (&__first);
      __cur = __cur + 8;
      <D.100732>:
      retval.4 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator!= (&__first, &__last);
      if (retval.4 != 0) goto <D.100731>; else goto <D.100729>;
      <D.100729>:
      D.100891 = __cur;
      return D.100891;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.100892 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.100892);
              std::_Destroy<Glib::ustring*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


Glib::Container_Helpers::ArrayIterator<Tr>::value_type Glib::Container_Helpers::ArrayIterator<Tr>::operator*() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::value_type = Glib::ustring] (const struct ArrayIterator * const this)
{
  const char * const * D.100899;
  const char * D.100900;

  D.100899 = this->pos_;
  D.100900 = *D.100899;
  *<retval> = Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_cpp_type (D.100900); [return slot optimization]
  return <retval>;
}


static Glib::Container_Helpers::TypeTraits<Glib::ustring>::CppType Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_cpp_type(Glib::Container_Helpers::TypeTraits<Glib::ustring>::CType) (const char * str)
{
  struct CppType * D.100905;

  if (str != 0B) goto <D.100903>; else goto <D.100904>;
  <D.100903>:
  D.100905 = <retval>;
  Glib::ustring::ustring (D.100905, str);
  goto <D.100906>;
  <D.100904>:
  D.100905 = <retval>;
  Glib::ustring::ustring (D.100905);
  <D.100906>:
  return <retval>;
}


_Tp* std::__addressof(_Tp&) [with _Tp = Glib::ustring] (struct ustring & __r)
{
  struct ustring * D.100908;

  D.100908 = __r;
  return D.100908;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::ustring; _T2 = Glib::ustring] (struct ustring * __p, const struct ustring & __value)
{
  void * D.100671;
  void * D.100672;
  struct ustring * iftmp.5;

  D.100671 = __p;
  D.100672 = operator new (8, D.100671);
  if (D.100672 != 0B) goto <D.100911>; else goto <D.100912>;
  <D.100911>:
  try
    {
      Glib::ustring::ustring (D.100672, __value);
    }
  catch
    {
      operator delete (D.100672, D.100671);
    }
  iftmp.5 = D.100672;
  goto <D.100913>;
  <D.100912>:
  iftmp.5 = D.100672;
  <D.100913>:
}


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

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


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

  try
    {

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


Glib::Container_Helpers::ArrayIterator<Tr>& Glib::Container_Helpers::ArrayIterator<Tr>::operator++() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayIterator * const this)
{
  const char * const * D.100919;
  const char * const * D.100920;
  struct ArrayIterator & D.100921;

  D.100919 = this->pos_;
  D.100920 = D.100919 + 8;
  this->pos_ = D.100920;
  D.100921 = this;
  return D.100921;
}


bool Glib::Container_Helpers::ArrayIterator<Tr>::operator!=(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  bool D.100923;
  const char * const * D.100924;
  const char * const * D.100925;

  D.100924 = this->pos_;
  D.100925 = rhs->pos_;
  D.100923 = D.100924 != D.100925;
  return D.100923;
}


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

  std::_Destroy_aux<false>::__destroy<Glib::ustring*> (__first, __last);
}


static void std::_Destroy_aux<<anonymous> >::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = Glib::ustring*; bool <anonymous> = false] (struct ustring * __first, struct ustring * __last)
{
  struct ustring * D.100927;

  goto <D.100580>;
  <D.100579>:
  D.100927 = std::__addressof<Glib::ustring> (__first);
  std::_Destroy<Glib::ustring> (D.100927);
  __first = __first + 8;
  <D.100580>:
  if (__first != __last) goto <D.100579>; else goto <D.100577>;
  <D.100577>:
}


void std::_Destroy(_Tp*) [with _Tp = Glib::ustring] (struct ustring * __pointer)
{
  Glib::ustring::~ustring (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct _Vector_base * const this)
{
  struct ustring * D.100928;
  long int D.100929;
  struct ustring * D.100930;
  long int D.100931;
  long int D.100932;
  long int D.100933;
  long unsigned int D.100934;
  struct _Vector_impl * D.100935;

  {
    try
      {
        try
          {
            D.100928 = this->_M_impl._M_end_of_storage;
            D.100929 = (long int) D.100928;
            D.100930 = this->_M_impl._M_start;
            D.100931 = (long int) D.100930;
            D.100932 = D.100929 - D.100931;
            D.100933 = D.100932 /[ex] 8;
            D.100934 = (long unsigned int) D.100933;
            D.100930 = this->_M_impl._M_start;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_deallocate (this, D.100930, D.100934);
          }
        finally
          {
            D.100935 = &this->_M_impl;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.100935);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100112>:
}


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

  if (__p != 0B) goto <D.100938>; else goto <D.100939>;
  <D.100938>:
  D.100940 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::deallocate (D.100940, __p, __n);
  goto <D.100941>;
  <D.100939>:
  <D.100941>:
}


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<Glib::ustring>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Glib::ustring*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, struct ustring * __p, size_type __n)
{
  __gnu_cxx::new_allocator<Glib::ustring>::deallocate (__a, __p, __n);
}


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


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

          }
        finally
          {
            std::allocator<Glib::ustring>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100107>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<Glib::ustring>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.100301>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.100942 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.100942);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


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

  D.100944 = &this->D.97798;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_base (D.100944);
  try
    {

    }
  catch
    {
      D.100944 = &this->D.97798;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.100944);
    }
}


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

  D.100945 = &this->_M_impl;
  std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::_Vector_impl (D.100945);
  try
    {

    }
  catch
    {
      D.100945 = &this->_M_impl;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.100945);
    }
}


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


Glib::Container_Helpers::ArrayKeeper<Tr>::~ArrayKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayKeeper * const this)
{
  const char * * D.100946;
  OwnershipType D.100949;
  long unsigned int D.100954;
  long unsigned int D.100955;
  const char * D.100956;

  {
    try
      {
        {
          {
            D.100946 = this->array_;
            if (D.100946 != 0B) goto <D.100947>; else goto <D.100948>;
            <D.100947>:
            D.100949 = this->ownership_;
            if (D.100949 != 0) goto <D.100950>; else goto <D.100951>;
            <D.100950>:
            {
              {
                D.100949 = this->ownership_;
                if (D.100949 != 1) goto <D.100952>; else goto <D.100953>;
                <D.100952>:
                {
                  const char * const * const array_end;

                  D.100946 = this->array_;
                  D.100954 = this->array_size_;
                  D.100955 = D.100954 * 8;
                  array_end = D.100946 + D.100955;
                  {
                    const char * const * p;

                    p = this->array_;
                    goto <D.100285>;
                    <D.100286>:
                    D.100956 = *p;
                    Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type (D.100956);
                    p = p + 8;
                    <D.100285>:
                    if (p != array_end) goto <D.100286>; else goto <D.100287>;
                    <D.100287>:
                  }
                }
                goto <D.100957>;
                <D.100953>:
                <D.100957>:
              }
              D.100946 = this->array_;
              g_free (D.100946);
            }
            goto <D.100958>;
            <D.100951>:
            <D.100958>:
            <D.100948>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.100288>:
}


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


static GType Glib::Value<Gio::SettingsBindFlags>::value_type() ()
{
  GType D.100960;

  D.100960 = g_settings_bind_flags_get_type ();
  return D.100960;
}


Glib::RefPtr<Gio::Settings> Glib::wrap(GSettings*, bool) (struct GSettings * object, bool take_copy)
{
  struct Settings * iftmp.6;
  int D.100965;
  struct ObjectBase * D.100966;

  D.100965 = (int) take_copy;
  D.100966 = Glib::wrap_auto (object, D.100965);
  if (D.100966 == 0B) goto <D.100967>; else goto <D.100968>;
  <D.100967>:
  iftmp.6 = 0B;
  goto <D.100969>;
  <D.100968>:
  iftmp.6 = __dynamic_cast (D.100966, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
  <D.100969>:
  Glib::RefPtr<Gio::Settings>::RefPtr (<retval>, iftmp.6);
  return <retval>;
}


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


const Glib::Class& Gio::Settings_Class::init() (struct Settings_Class * const this)
{
  long unsigned int D.100972;
  long unsigned int D.100975;
  struct Class * D.100976;
  const struct Class & D.100978;

  D.100972 = this->D.97020.gtype_;
  if (D.100972 == 0) goto <D.100973>; else goto <D.100974>;
  <D.100973>:
  this->D.97020.class_init_func_ = class_init_function;
  D.100975 = g_settings_get_type ();
  D.100976 = &this->D.97020;
  Glib::Class::register_derived_type (D.100976, D.100975);
  goto <D.100977>;
  <D.100974>:
  <D.100977>:
  D.100978 = &this->D.97020;
  return D.100978;
}


static void Gio::Settings_Class::class_init_function(void*, void*) (void * g_class, void * class_data)
{
  struct BaseClassType * const klass;

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
  klass->changed = changed_callback;
  klass->writable_change_event = writable_change_event_callback;
  klass->writable_changed = writable_changed_callback;
}


static void Gio::Settings_Class::changed_callback(GSettings*, const gchar*) (struct GSettings * self, const gchar * p0)
{
  bool retval.7;
  bool iftmp.8;
  bool D.100986;
  struct CppObjectType * const iftmp.9;
  int (*__vtbl_ptr_type) () * D.100996;
  int (*__vtbl_ptr_type) () * D.100997;
  int (*__vtbl_ptr_type) () D.100998;
  struct ustring D.98322;
  void * D.100999;
  struct GTypeClass * D.101002;
  void (*<T10ca4>) (struct GSettings *, const gchar *) D.101005;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.100985>; else goto <D.100983>;
    <D.100985>:
    D.100986 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.100986 != 0) goto <D.100987>; else goto <D.100983>;
    <D.100987>:
    iftmp.8 = 1;
    goto <D.100984>;
    <D.100983>:
    iftmp.8 = 0;
    <D.100984>:
    retval.7 = iftmp.8;
    if (retval.7 != 0) goto <D.100988>; else goto <D.100989>;
    <D.100988>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.100991>; else goto <D.100992>;
      <D.100991>:
      iftmp.9 = 0B;
      goto <D.100993>;
      <D.100992>:
      iftmp.9 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
      <D.100993>:
      obj = iftmp.9;
      if (obj != 0B) goto <D.100994>; else goto <D.100995>;
      <D.100994>:
      try
        {
          D.100996 = obj->D.96969._vptr.Object;
          D.100997 = D.100996 + 16;
          D.100998 = *D.100997;
          D.98322 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.100998;(struct Settings)obj->2) (obj, &D.98322);
            }
          finally
            {
              Glib::ustring::~ustring (&D.98322);
              D.98322 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.100999 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.100999);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.101000>;
      <D.100995>:
      <D.101000>:
    }
    goto <D.101001>;
    <D.100989>:
    <D.101001>:
  }
  D.101002 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.101002);
  if (base != 0B) goto <D.101003>; else goto <D.101004>;
  <D.101003>:
  D.101005 = base->changed;
  if (D.101005 != 0B) goto <D.101006>; else goto <D.101007>;
  <D.101006>:
  D.101005 = base->changed;
  D.101005 (self, p0);
  goto <D.101008>;
  <D.101007>:
  <D.101008>:
  <D.101004>:
}


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

  if (str != 0B) goto <D.101018>; else goto <D.101019>;
  <D.101018>:
  D.101020 = <retval>;
  Glib::ustring::ustring (D.101020, str);
  goto <D.101021>;
  <D.101019>:
  D.101020 = <retval>;
  Glib::ustring::ustring (D.101020);
  <D.101021>:
  return <retval>;
}


static gboolean Gio::Settings_Class::writable_change_event_callback(GSettings*, guint) (struct GSettings * self, guint p0)
{
  bool retval.10;
  bool iftmp.11;
  bool D.101028;
  struct CppObjectType * const iftmp.12;
  gboolean D.101038;
  int (*__vtbl_ptr_type) () * D.101039;
  int (*__vtbl_ptr_type) () * D.101040;
  int (*__vtbl_ptr_type) () D.101041;
  bool D.101042;
  void * D.101043;
  struct GTypeClass * D.101046;
  gboolean (*<T10caa>) (struct GSettings *, GQuark) D.101049;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;
  typedef RType RType;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.101027>; else goto <D.101025>;
    <D.101027>:
    D.101028 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.101028 != 0) goto <D.101029>; else goto <D.101025>;
    <D.101029>:
    iftmp.11 = 1;
    goto <D.101026>;
    <D.101025>:
    iftmp.11 = 0;
    <D.101026>:
    retval.10 = iftmp.11;
    if (retval.10 != 0) goto <D.101030>; else goto <D.101031>;
    <D.101030>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.101033>; else goto <D.101034>;
      <D.101033>:
      iftmp.12 = 0B;
      goto <D.101035>;
      <D.101034>:
      iftmp.12 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
      <D.101035>:
      obj = iftmp.12;
      if (obj != 0B) goto <D.101036>; else goto <D.101037>;
      <D.101036>:
      try
        {
          D.101039 = obj->D.96969._vptr.Object;
          D.101040 = D.101039 + 24;
          D.101041 = *D.101040;
          D.101042 = OBJ_TYPE_REF(D.101041;(struct Settings)obj->3) (obj, p0);
          D.101038 = (gboolean) D.101042;
          return D.101038;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101043 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101043);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.101044>;
      <D.101037>:
      <D.101044>:
    }
    goto <D.101045>;
    <D.101031>:
    <D.101045>:
  }
  D.101046 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.101046);
  if (base != 0B) goto <D.101047>; else goto <D.101048>;
  <D.101047>:
  D.101049 = base->writable_change_event;
  if (D.101049 != 0B) goto <D.101050>; else goto <D.101051>;
  <D.101050>:
  D.101049 = base->writable_change_event;
  D.101038 = D.101049 (self, p0);
  return D.101038;
  <D.101051>:
  <D.101048>:
  D.101038 = 0;
  return D.101038;
}


static void Gio::Settings_Class::writable_changed_callback(GSettings*, const gchar*) (struct GSettings * self, const gchar * p0)
{
  bool retval.13;
  bool iftmp.14;
  bool D.101066;
  struct CppObjectType * const iftmp.15;
  int (*__vtbl_ptr_type) () * D.101076;
  int (*__vtbl_ptr_type) () * D.101077;
  int (*__vtbl_ptr_type) () D.101078;
  struct ustring D.98340;
  void * D.101079;
  struct GTypeClass * D.101082;
  void (*<T10ca4>) (struct GSettings *, const gchar *) D.101085;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.101065>; else goto <D.101063>;
    <D.101065>:
    D.101066 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.101066 != 0) goto <D.101067>; else goto <D.101063>;
    <D.101067>:
    iftmp.14 = 1;
    goto <D.101064>;
    <D.101063>:
    iftmp.14 = 0;
    <D.101064>:
    retval.13 = iftmp.14;
    if (retval.13 != 0) goto <D.101068>; else goto <D.101069>;
    <D.101068>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.101071>; else goto <D.101072>;
      <D.101071>:
      iftmp.15 = 0B;
      goto <D.101073>;
      <D.101072>:
      iftmp.15 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
      <D.101073>:
      obj = iftmp.15;
      if (obj != 0B) goto <D.101074>; else goto <D.101075>;
      <D.101074>:
      try
        {
          D.101076 = obj->D.96969._vptr.Object;
          D.101077 = D.101076 + 32;
          D.101078 = *D.101077;
          D.98340 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
          try
            {
              OBJ_TYPE_REF(D.101078;(struct Settings)obj->4) (obj, &D.98340);
            }
          finally
            {
              Glib::ustring::~ustring (&D.98340);
              D.98340 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101079 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101079);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.101080>;
      <D.101075>:
      <D.101080>:
    }
    goto <D.101081>;
    <D.101069>:
    <D.101081>:
  }
  D.101082 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.101082);
  if (base != 0B) goto <D.101083>; else goto <D.101084>;
  <D.101083>:
  D.101085 = base->writable_changed;
  if (D.101085 != 0B) goto <D.101086>; else goto <D.101087>;
  <D.101086>:
  D.101085 = base->writable_changed;
  D.101085 (self, p0);
  goto <D.101088>;
  <D.101087>:
  <D.101088>:
  <D.101084>:
}


static Glib::ObjectBase* Gio::Settings_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.101097;
  struct ObjectBase * iftmp.16;
  void * D.98346;
  void * D.101099;
  int (*__vtbl_ptr_type) () * D.101102;
  int (*__vtbl_ptr_type) () * D.101103;
  long int D.101104;
  sizetype D.101105;

  D.98346 = operator new (48);
  try
    {
      Gio::Settings::Settings (D.98346, object);
    }
  catch
    {
      operator delete (D.98346);
    }
  D.101099 = D.98346;
  if (D.101099 != 0B) goto <D.101100>; else goto <D.101101>;
  <D.101100>:
  D.101102 = MEM[(struct Settings *)D.101099].D.96969._vptr.Object;
  D.101103 = D.101102 + 18446744073709551592;
  D.101104 = MEM[(long int *)D.101103];
  D.101105 = (sizetype) D.101104;
  iftmp.16 = D.101099 + D.101105;
  goto <D.101106>;
  <D.101101>:
  iftmp.16 = 0B;
  <D.101106>:
  D.101097 = iftmp.16;
  return D.101097;
}


GSettings* Gio::Settings::gobj_copy() (struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.101110;
  int (*__vtbl_ptr_type) () * D.101111;
  long int D.101112;
  sizetype D.101113;
  struct ObjectBase * D.101114;
  int (*__vtbl_ptr_type) () * D.101115;
  int (*__vtbl_ptr_type) () * D.101116;
  int (*__vtbl_ptr_type) () D.101117;
  struct GSettings * D.101118;

  D.101110 = this->D.96969._vptr.Object;
  D.101111 = D.101110 + 18446744073709551592;
  D.101112 = MEM[(long int *)D.101111];
  D.101113 = (sizetype) D.101112;
  D.101114 = this + D.101113;
  D.101110 = this->D.96969._vptr.Object;
  D.101111 = D.101110 + 18446744073709551592;
  D.101112 = MEM[(long int *)D.101111];
  D.101113 = (sizetype) D.101112;
  D.101114 = this + D.101113;
  D.101115 = D.101114->_vptr.ObjectBase;
  D.101116 = D.101115 + 16;
  D.101117 = *D.101116;
  D.101110 = this->D.96969._vptr.Object;
  D.101111 = D.101110 + 18446744073709551592;
  D.101112 = MEM[(long int *)D.101111];
  D.101113 = (sizetype) D.101112;
  D.101114 = this + D.101113;
  OBJ_TYPE_REF(D.101117;(const struct ObjectBase)D.101114->2) (D.101114);
  D.101118 = Gio::Settings::gobj (this);
  return D.101118;
}


GSettings* Gio::Settings::gobj() (struct Settings * const this)
{
  struct GSettings * D.101120;
  int (*__vtbl_ptr_type) () * D.101121;
  int (*__vtbl_ptr_type) () * D.101122;
  long int D.101123;
  sizetype D.101124;
  struct ObjectBase * D.101125;

  D.101121 = this->D.96969._vptr.Object;
  D.101122 = D.101121 + 18446744073709551592;
  D.101123 = MEM[(long int *)D.101122];
  D.101124 = (sizetype) D.101123;
  D.101125 = this + D.101124;
  D.101120 = D.101125->gobject_;
  return D.101120;
}


Gio::Settings::Settings(const Glib::ConstructParams&) (struct Settings * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.101129;
  const void * * iftmp.17;
  struct ObjectBase * D.101137;
  const void * * iftmp.18;
  struct Object * D.101143;
  int (*__vtbl_ptr_type) () * iftmp.19;
  sizetype iftmp.20;
  int (*__vtbl_ptr_type) () * D.101151;
  int (*__vtbl_ptr_type) () * D.101152;
  long int D.101153;
  struct ObjectBase * D.101155;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * iftmp.22;
  const void * * iftmp.23;

  if (0 != 0) goto <D.101127>; else goto <D.101128>;
  <D.101127>:
  D.101129 = &this->D.96972;
  sigc::trackable::trackable (D.101129);
  goto <D.101130>;
  <D.101128>:
  <D.101130>:
  try
    {
      if (0 != 0) goto <D.101131>; else goto <D.101132>;
      <D.101131>:
      if (0 == 0) goto <D.101134>; else goto <D.101135>;
      <D.101134>:
      iftmp.17 = __vtt_parm + 32;
      goto <D.101136>;
      <D.101135>:
      iftmp.17 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101136>:
      D.101137 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101137, iftmp.17);
      goto <D.101138>;
      <D.101132>:
      <D.101138>:
      try
        {
          if (0 == 0) goto <D.101140>; else goto <D.101141>;
          <D.101140>:
          iftmp.18 = __vtt_parm + 8;
          goto <D.101142>;
          <D.101141>:
          iftmp.18 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
          <D.101142>:
          D.101143 = &this->D.96969;
          Glib::Object::Object (D.101143, iftmp.18, construct_params);
          try
            {
              if (0 == 0) goto <D.101145>; else goto <D.101146>;
              <D.101145>:
              iftmp.19 = *__vtt_parm;
              goto <D.101147>;
              <D.101146>:
              iftmp.19 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101147>:
              this->D.96969._vptr.Object = iftmp.19;
              if (0 == 0) goto <D.101149>; else goto <D.101150>;
              <D.101149>:
              D.101151 = this->D.96969._vptr.Object;
              D.101152 = D.101151 + 18446744073709551592;
              D.101153 = MEM[(long int *)D.101152];
              iftmp.20 = (sizetype) D.101153;
              goto <D.101154>;
              <D.101150>:
              iftmp.20 = 8;
              <D.101154>:
              D.101155 = this + iftmp.20;
              if (0 == 0) goto <D.101157>; else goto <D.101158>;
              <D.101157>:
              iftmp.21 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.101159>;
              <D.101158>:
              iftmp.21 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101159>:
              D.101155->_vptr.ObjectBase = iftmp.21;
            }
          catch
            {
              if (0 == 0) goto <D.101161>; else goto <D.101162>;
              <D.101161>:
              iftmp.22 = __vtt_parm + 8;
              goto <D.101163>;
              <D.101162>:
              iftmp.22 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101163>:
              D.101143 = &this->D.96969;
              Glib::Object::~Object (D.101143, iftmp.22);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101164>; else goto <D.101165>;
          <D.101164>:
          if (0 == 0) goto <D.101167>; else goto <D.101168>;
          <D.101167>:
          iftmp.23 = __vtt_parm + 32;
          goto <D.101169>;
          <D.101168>:
          iftmp.23 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101169>:
          D.101137 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101137, iftmp.23);
          goto <D.101170>;
          <D.101165>:
          <D.101170>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101171>; else goto <D.101172>;
      <D.101171>:
      D.101129 = &this->D.96972;
      sigc::trackable::~trackable (D.101129);
      goto <D.101173>;
      <D.101172>:
      <D.101173>:
    }
}


Gio::Settings::Settings(const Glib::ConstructParams&) (struct Settings * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.101178;
  const void * * iftmp.24;
  struct ObjectBase * D.101186;
  const void * * iftmp.25;
  struct Object * D.101192;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * D.101196;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.101201;
  int (*__vtbl_ptr_type) () * D.101202;
  long int D.101203;
  struct ObjectBase * D.101205;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * iftmp.29;
  const void * * iftmp.30;

  if (1 != 0) goto <D.101176>; else goto <D.101177>;
  <D.101176>:
  D.101178 = &this->D.96972;
  sigc::trackable::trackable (D.101178);
  goto <D.101179>;
  <D.101177>:
  <D.101179>:
  try
    {
      if (1 != 0) goto <D.101180>; else goto <D.101181>;
      <D.101180>:
      if (1 == 0) goto <D.101183>; else goto <D.101184>;
      <D.101183>:
      iftmp.24 = 32B;
      goto <D.101185>;
      <D.101184>:
      iftmp.24 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101185>:
      D.101186 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101186, iftmp.24);
      goto <D.101187>;
      <D.101181>:
      <D.101187>:
      try
        {
          if (1 == 0) goto <D.101189>; else goto <D.101190>;
          <D.101189>:
          iftmp.25 = 8B;
          goto <D.101191>;
          <D.101190>:
          iftmp.25 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
          <D.101191>:
          D.101192 = &this->D.96969;
          Glib::Object::Object (D.101192, iftmp.25, construct_params);
          try
            {
              if (1 == 0) goto <D.101194>; else goto <D.101195>;
              <D.101194>:
              D.101196 = 0B;
              iftmp.26 = *D.101196;
              goto <D.101197>;
              <D.101195>:
              iftmp.26 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101197>:
              this->D.96969._vptr.Object = iftmp.26;
              if (1 == 0) goto <D.101199>; else goto <D.101200>;
              <D.101199>:
              D.101201 = this->D.96969._vptr.Object;
              D.101202 = D.101201 + 18446744073709551592;
              D.101203 = MEM[(long int *)D.101202];
              iftmp.27 = (sizetype) D.101203;
              goto <D.101204>;
              <D.101200>:
              iftmp.27 = 8;
              <D.101204>:
              D.101205 = this + iftmp.27;
              if (1 == 0) goto <D.101207>; else goto <D.101208>;
              <D.101207>:
              iftmp.28 = MEM[(const void * *)0B + 24B];
              goto <D.101209>;
              <D.101208>:
              iftmp.28 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101209>:
              D.101205->_vptr.ObjectBase = iftmp.28;
            }
          catch
            {
              if (1 == 0) goto <D.101211>; else goto <D.101212>;
              <D.101211>:
              iftmp.29 = 8B;
              goto <D.101213>;
              <D.101212>:
              iftmp.29 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101213>:
              D.101192 = &this->D.96969;
              Glib::Object::~Object (D.101192, iftmp.29);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101214>; else goto <D.101215>;
          <D.101214>:
          if (1 == 0) goto <D.101217>; else goto <D.101218>;
          <D.101217>:
          iftmp.30 = 32B;
          goto <D.101219>;
          <D.101218>:
          iftmp.30 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101219>:
          D.101186 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101186, iftmp.30);
          goto <D.101220>;
          <D.101215>:
          <D.101220>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101221>; else goto <D.101222>;
      <D.101221>:
      D.101178 = &this->D.96972;
      sigc::trackable::~trackable (D.101178);
      goto <D.101223>;
      <D.101222>:
      <D.101223>:
    }
}


Gio::Settings::Settings(GSettings*) (struct Settings * const this, const void * * __vtt_parm, struct GSettings * castitem)
{
  struct trackable * D.101228;
  const void * * iftmp.31;
  struct ObjectBase * D.101236;
  const void * * iftmp.32;
  struct Object * D.101242;
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.101250;
  int (*__vtbl_ptr_type) () * D.101251;
  long int D.101252;
  struct ObjectBase * D.101254;
  int (*__vtbl_ptr_type) () * iftmp.35;
  const void * * iftmp.36;
  const void * * iftmp.37;

  if (0 != 0) goto <D.101226>; else goto <D.101227>;
  <D.101226>:
  D.101228 = &this->D.96972;
  sigc::trackable::trackable (D.101228);
  goto <D.101229>;
  <D.101227>:
  <D.101229>:
  try
    {
      if (0 != 0) goto <D.101230>; else goto <D.101231>;
      <D.101230>:
      if (0 == 0) goto <D.101233>; else goto <D.101234>;
      <D.101233>:
      iftmp.31 = __vtt_parm + 32;
      goto <D.101235>;
      <D.101234>:
      iftmp.31 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101235>:
      D.101236 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101236, iftmp.31);
      goto <D.101237>;
      <D.101231>:
      <D.101237>:
      try
        {
          if (0 == 0) goto <D.101239>; else goto <D.101240>;
          <D.101239>:
          iftmp.32 = __vtt_parm + 8;
          goto <D.101241>;
          <D.101240>:
          iftmp.32 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
          <D.101241>:
          D.101242 = &this->D.96969;
          Glib::Object::Object (D.101242, iftmp.32, castitem);
          try
            {
              if (0 == 0) goto <D.101244>; else goto <D.101245>;
              <D.101244>:
              iftmp.33 = *__vtt_parm;
              goto <D.101246>;
              <D.101245>:
              iftmp.33 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101246>:
              this->D.96969._vptr.Object = iftmp.33;
              if (0 == 0) goto <D.101248>; else goto <D.101249>;
              <D.101248>:
              D.101250 = this->D.96969._vptr.Object;
              D.101251 = D.101250 + 18446744073709551592;
              D.101252 = MEM[(long int *)D.101251];
              iftmp.34 = (sizetype) D.101252;
              goto <D.101253>;
              <D.101249>:
              iftmp.34 = 8;
              <D.101253>:
              D.101254 = this + iftmp.34;
              if (0 == 0) goto <D.101256>; else goto <D.101257>;
              <D.101256>:
              iftmp.35 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.101258>;
              <D.101257>:
              iftmp.35 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101258>:
              D.101254->_vptr.ObjectBase = iftmp.35;
            }
          catch
            {
              if (0 == 0) goto <D.101260>; else goto <D.101261>;
              <D.101260>:
              iftmp.36 = __vtt_parm + 8;
              goto <D.101262>;
              <D.101261>:
              iftmp.36 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101262>:
              D.101242 = &this->D.96969;
              Glib::Object::~Object (D.101242, iftmp.36);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101263>; else goto <D.101264>;
          <D.101263>:
          if (0 == 0) goto <D.101266>; else goto <D.101267>;
          <D.101266>:
          iftmp.37 = __vtt_parm + 32;
          goto <D.101268>;
          <D.101267>:
          iftmp.37 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101268>:
          D.101236 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101236, iftmp.37);
          goto <D.101269>;
          <D.101264>:
          <D.101269>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101270>; else goto <D.101271>;
      <D.101270>:
      D.101228 = &this->D.96972;
      sigc::trackable::~trackable (D.101228);
      goto <D.101272>;
      <D.101271>:
      <D.101272>:
    }
}


Gio::Settings::Settings(GSettings*) (struct Settings * const this, struct GSettings * castitem)
{
  struct trackable * D.101277;
  const void * * iftmp.38;
  struct ObjectBase * D.101285;
  const void * * iftmp.39;
  struct Object * D.101291;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * D.101295;
  sizetype iftmp.41;
  int (*__vtbl_ptr_type) () * D.101300;
  int (*__vtbl_ptr_type) () * D.101301;
  long int D.101302;
  struct ObjectBase * D.101304;
  int (*__vtbl_ptr_type) () * iftmp.42;
  const void * * iftmp.43;
  const void * * iftmp.44;

  if (1 != 0) goto <D.101275>; else goto <D.101276>;
  <D.101275>:
  D.101277 = &this->D.96972;
  sigc::trackable::trackable (D.101277);
  goto <D.101278>;
  <D.101276>:
  <D.101278>:
  try
    {
      if (1 != 0) goto <D.101279>; else goto <D.101280>;
      <D.101279>:
      if (1 == 0) goto <D.101282>; else goto <D.101283>;
      <D.101282>:
      iftmp.38 = 32B;
      goto <D.101284>;
      <D.101283>:
      iftmp.38 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101284>:
      D.101285 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101285, iftmp.38);
      goto <D.101286>;
      <D.101280>:
      <D.101286>:
      try
        {
          if (1 == 0) goto <D.101288>; else goto <D.101289>;
          <D.101288>:
          iftmp.39 = 8B;
          goto <D.101290>;
          <D.101289>:
          iftmp.39 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
          <D.101290>:
          D.101291 = &this->D.96969;
          Glib::Object::Object (D.101291, iftmp.39, castitem);
          try
            {
              if (1 == 0) goto <D.101293>; else goto <D.101294>;
              <D.101293>:
              D.101295 = 0B;
              iftmp.40 = *D.101295;
              goto <D.101296>;
              <D.101294>:
              iftmp.40 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101296>:
              this->D.96969._vptr.Object = iftmp.40;
              if (1 == 0) goto <D.101298>; else goto <D.101299>;
              <D.101298>:
              D.101300 = this->D.96969._vptr.Object;
              D.101301 = D.101300 + 18446744073709551592;
              D.101302 = MEM[(long int *)D.101301];
              iftmp.41 = (sizetype) D.101302;
              goto <D.101303>;
              <D.101299>:
              iftmp.41 = 8;
              <D.101303>:
              D.101304 = this + iftmp.41;
              if (1 == 0) goto <D.101306>; else goto <D.101307>;
              <D.101306>:
              iftmp.42 = MEM[(const void * *)0B + 24B];
              goto <D.101308>;
              <D.101307>:
              iftmp.42 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101308>:
              D.101304->_vptr.ObjectBase = iftmp.42;
            }
          catch
            {
              if (1 == 0) goto <D.101310>; else goto <D.101311>;
              <D.101310>:
              iftmp.43 = 8B;
              goto <D.101312>;
              <D.101311>:
              iftmp.43 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101312>:
              D.101291 = &this->D.96969;
              Glib::Object::~Object (D.101291, iftmp.43);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101313>; else goto <D.101314>;
          <D.101313>:
          if (1 == 0) goto <D.101316>; else goto <D.101317>;
          <D.101316>:
          iftmp.44 = 32B;
          goto <D.101318>;
          <D.101317>:
          iftmp.44 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101318>:
          D.101285 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101285, iftmp.44);
          goto <D.101319>;
          <D.101314>:
          <D.101319>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101320>; else goto <D.101321>;
      <D.101320>:
      D.101277 = &this->D.96972;
      sigc::trackable::~trackable (D.101277);
      goto <D.101322>;
      <D.101321>:
      <D.101322>:
    }
}


Gio::Settings::~Settings() (struct Settings * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.45;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.101332;
  int (*__vtbl_ptr_type) () * D.101333;
  long int D.101334;
  struct ObjectBase * D.101336;
  int (*__vtbl_ptr_type) () * iftmp.47;
  const void * * iftmp.48;
  struct Object * D.101345;
  int D.101346;
  const void * * iftmp.49;
  struct ObjectBase * D.101353;
  struct trackable * D.101357;
  int D.101359;

  {
    if (0 == 0) goto <D.101326>; else goto <D.101327>;
    <D.101326>:
    iftmp.45 = *__vtt_parm;
    goto <D.101328>;
    <D.101327>:
    iftmp.45 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
    <D.101328>:
    this->D.96969._vptr.Object = iftmp.45;
    if (0 == 0) goto <D.101330>; else goto <D.101331>;
    <D.101330>:
    D.101332 = this->D.96969._vptr.Object;
    D.101333 = D.101332 + 18446744073709551592;
    D.101334 = MEM[(long int *)D.101333];
    iftmp.46 = (sizetype) D.101334;
    goto <D.101335>;
    <D.101331>:
    iftmp.46 = 8;
    <D.101335>:
    D.101336 = this + iftmp.46;
    if (0 == 0) goto <D.101338>; else goto <D.101339>;
    <D.101338>:
    iftmp.47 = MEM[(const void * *)__vtt_parm + 24B];
    goto <D.101340>;
    <D.101339>:
    iftmp.47 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
    <D.101340>:
    D.101336->_vptr.ObjectBase = iftmp.47;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (0 == 0) goto <D.101342>; else goto <D.101343>;
                    <D.101342>:
                    iftmp.48 = __vtt_parm + 8;
                    goto <D.101344>;
                    <D.101343>:
                    iftmp.48 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
                    <D.101344>:
                    D.101345 = &this->D.96969;
                    Glib::Object::~Object (D.101345, iftmp.48);
                  }
              }
            finally
              {
                D.101346 = 0;
                if (D.101346 != 0) goto <D.101347>; else goto <D.101348>;
                <D.101347>:
                if (0 == 0) goto <D.101350>; else goto <D.101351>;
                <D.101350>:
                iftmp.49 = __vtt_parm + 32;
                goto <D.101352>;
                <D.101351>:
                iftmp.49 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
                <D.101352>:
                D.101353 = &this->D.96971;
                Glib::ObjectBase::~ObjectBase (D.101353, iftmp.49);
                goto <D.101354>;
                <D.101348>:
                <D.101354>:
              }
          }
        finally
          {
            D.101346 = 0;
            if (D.101346 != 0) goto <D.101355>; else goto <D.101356>;
            <D.101355>:
            D.101357 = &this->D.96972;
            sigc::trackable::~trackable (D.101357);
            goto <D.101358>;
            <D.101356>:
            <D.101358>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98374>:
  D.101359 = 0;
  if (D.101359 != 0) goto <D.101360>; else goto <D.101361>;
  <D.101360>:
  operator delete (this);
  goto <D.101362>;
  <D.101361>:
  <D.101362>:
}


virtual Gio::Settings::~Settings() (struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.50;
  const void * * D.101378;
  sizetype iftmp.51;
  int (*__vtbl_ptr_type) () * D.101383;
  int (*__vtbl_ptr_type) () * D.101384;
  long int D.101385;
  struct ObjectBase * D.101387;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * iftmp.53;
  struct Object * D.101396;
  int D.101397;
  const void * * iftmp.54;
  struct ObjectBase * D.101404;
  struct trackable * D.101408;
  int D.101410;

  {
    if (2 == 0) goto <D.101376>; else goto <D.101377>;
    <D.101376>:
    D.101378 = 0B;
    iftmp.50 = *D.101378;
    goto <D.101379>;
    <D.101377>:
    iftmp.50 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
    <D.101379>:
    this->D.96969._vptr.Object = iftmp.50;
    if (2 == 0) goto <D.101381>; else goto <D.101382>;
    <D.101381>:
    D.101383 = this->D.96969._vptr.Object;
    D.101384 = D.101383 + 18446744073709551592;
    D.101385 = MEM[(long int *)D.101384];
    iftmp.51 = (sizetype) D.101385;
    goto <D.101386>;
    <D.101382>:
    iftmp.51 = 8;
    <D.101386>:
    D.101387 = this + iftmp.51;
    if (2 == 0) goto <D.101389>; else goto <D.101390>;
    <D.101389>:
    iftmp.52 = MEM[(const void * *)0B + 24B];
    goto <D.101391>;
    <D.101390>:
    iftmp.52 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
    <D.101391>:
    D.101387->_vptr.ObjectBase = iftmp.52;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    if (2 == 0) goto <D.101393>; else goto <D.101394>;
                    <D.101393>:
                    iftmp.53 = 8B;
                    goto <D.101395>;
                    <D.101394>:
                    iftmp.53 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
                    <D.101395>:
                    D.101396 = &this->D.96969;
                    Glib::Object::~Object (D.101396, iftmp.53);
                  }
              }
            finally
              {
                D.101397 = 2;
                if (D.101397 != 0) goto <D.101398>; else goto <D.101399>;
                <D.101398>:
                if (2 == 0) goto <D.101401>; else goto <D.101402>;
                <D.101401>:
                iftmp.54 = 32B;
                goto <D.101403>;
                <D.101402>:
                iftmp.54 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
                <D.101403>:
                D.101404 = &this->D.96971;
                Glib::ObjectBase::~ObjectBase (D.101404, iftmp.54);
                goto <D.101405>;
                <D.101399>:
                <D.101405>:
              }
          }
        finally
          {
            D.101397 = 2;
            if (D.101397 != 0) goto <D.101406>; else goto <D.101407>;
            <D.101406>:
            D.101408 = &this->D.96972;
            sigc::trackable::~trackable (D.101408);
            goto <D.101409>;
            <D.101407>:
            <D.101409>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.98377>:
  D.101410 = 0;
  if (D.101410 != 0) goto <D.101411>; else goto <D.101412>;
  <D.101411>:
  operator delete (this);
  goto <D.101413>;
  <D.101412>:
  <D.101413>:
}


virtual Gio::Settings::~Settings() (struct Settings * const this)
{
  Gio::Settings::~Settings (this);
  <D.98382>:
  operator delete (this);
}


static GType Gio::Settings::get_type() ()
{
  GType D.101426;
  const struct Class & D.101427;

  D.101427 = Gio::Settings_Class::init (&settings_class_);
  D.101426 = Glib::Class::get_type (D.101427);
  return D.101426;
}


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

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


static GType Gio::Settings::get_base_type() ()
{
  GType D.101432;

  D.101432 = g_settings_get_type ();
  return D.101432;
}


Gio::Settings::Settings(const Glib::ustring&) (struct Settings * const this, const void * * __vtt_parm, const struct ustring & schema)
{
  struct trackable * D.101437;
  const void * * iftmp.55;
  struct ObjectBase * D.101445;
  struct ConstructParams D.98401;
  const char * D.101447;
  const struct Class & D.101448;
  const void * * iftmp.56;
  struct Object * D.101453;
  int (*__vtbl_ptr_type) () * iftmp.57;
  sizetype iftmp.58;
  int (*__vtbl_ptr_type) () * D.101461;
  int (*__vtbl_ptr_type) () * D.101462;
  long int D.101463;
  struct ObjectBase * D.101465;
  int (*__vtbl_ptr_type) () * iftmp.59;
  const void * * iftmp.60;
  const void * * iftmp.61;

  if (0 != 0) goto <D.101435>; else goto <D.101436>;
  <D.101435>:
  D.101437 = &this->D.96972;
  sigc::trackable::trackable (D.101437);
  goto <D.101438>;
  <D.101436>:
  <D.101438>:
  try
    {
      if (0 != 0) goto <D.101439>; else goto <D.101440>;
      <D.101439>:
      if (0 == 0) goto <D.101442>; else goto <D.101443>;
      <D.101442>:
      iftmp.55 = __vtt_parm + 32;
      goto <D.101444>;
      <D.101443>:
      iftmp.55 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101444>:
      D.101445 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101445, iftmp.55, 0B);
      goto <D.101446>;
      <D.101440>:
      <D.101446>:
      try
        {
          D.101447 = Glib::ustring::c_str (schema);
          D.101448 = Gio::Settings_Class::init (&settings_class_);
          Glib::ConstructParams::ConstructParams (&D.98401, D.101448, "schema", D.101447, 0B);
          try
            {
              if (0 == 0) goto <D.101450>; else goto <D.101451>;
              <D.101450>:
              iftmp.56 = __vtt_parm + 8;
              goto <D.101452>;
              <D.101451>:
              iftmp.56 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101452>:
              D.101453 = &this->D.96969;
              Glib::Object::Object (D.101453, iftmp.56, &D.98401);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98401);
              D.98401 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.101455>; else goto <D.101456>;
              <D.101455>:
              iftmp.57 = *__vtt_parm;
              goto <D.101457>;
              <D.101456>:
              iftmp.57 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101457>:
              this->D.96969._vptr.Object = iftmp.57;
              if (0 == 0) goto <D.101459>; else goto <D.101460>;
              <D.101459>:
              D.101461 = this->D.96969._vptr.Object;
              D.101462 = D.101461 + 18446744073709551592;
              D.101463 = MEM[(long int *)D.101462];
              iftmp.58 = (sizetype) D.101463;
              goto <D.101464>;
              <D.101460>:
              iftmp.58 = 8;
              <D.101464>:
              D.101465 = this + iftmp.58;
              if (0 == 0) goto <D.101467>; else goto <D.101468>;
              <D.101467>:
              iftmp.59 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.101469>;
              <D.101468>:
              iftmp.59 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101469>:
              D.101465->_vptr.ObjectBase = iftmp.59;
            }
          catch
            {
              if (0 == 0) goto <D.101471>; else goto <D.101472>;
              <D.101471>:
              iftmp.60 = __vtt_parm + 8;
              goto <D.101473>;
              <D.101472>:
              iftmp.60 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101473>:
              D.101453 = &this->D.96969;
              Glib::Object::~Object (D.101453, iftmp.60);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101474>; else goto <D.101475>;
          <D.101474>:
          if (0 == 0) goto <D.101477>; else goto <D.101478>;
          <D.101477>:
          iftmp.61 = __vtt_parm + 32;
          goto <D.101479>;
          <D.101478>:
          iftmp.61 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101479>:
          D.101445 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101445, iftmp.61);
          goto <D.101480>;
          <D.101475>:
          <D.101480>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101481>; else goto <D.101482>;
      <D.101481>:
      D.101437 = &this->D.96972;
      sigc::trackable::~trackable (D.101437);
      goto <D.101483>;
      <D.101482>:
      <D.101483>:
    }
}


Gio::Settings::Settings(const Glib::ustring&) (struct Settings * const this, const struct ustring & schema)
{
  struct trackable * D.101491;
  const void * * iftmp.62;
  struct ObjectBase * D.101499;
  struct ConstructParams D.98403;
  const char * D.101501;
  const struct Class & D.101502;
  const void * * iftmp.63;
  struct Object * D.101507;
  int (*__vtbl_ptr_type) () * iftmp.64;
  const void * * D.101511;
  sizetype iftmp.65;
  int (*__vtbl_ptr_type) () * D.101516;
  int (*__vtbl_ptr_type) () * D.101517;
  long int D.101518;
  struct ObjectBase * D.101520;
  int (*__vtbl_ptr_type) () * iftmp.66;
  const void * * iftmp.67;
  const void * * iftmp.68;

  if (1 != 0) goto <D.101489>; else goto <D.101490>;
  <D.101489>:
  D.101491 = &this->D.96972;
  sigc::trackable::trackable (D.101491);
  goto <D.101492>;
  <D.101490>:
  <D.101492>:
  try
    {
      if (1 != 0) goto <D.101493>; else goto <D.101494>;
      <D.101493>:
      if (1 == 0) goto <D.101496>; else goto <D.101497>;
      <D.101496>:
      iftmp.62 = 32B;
      goto <D.101498>;
      <D.101497>:
      iftmp.62 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101498>:
      D.101499 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101499, iftmp.62, 0B);
      goto <D.101500>;
      <D.101494>:
      <D.101500>:
      try
        {
          D.101501 = Glib::ustring::c_str (schema);
          D.101502 = Gio::Settings_Class::init (&settings_class_);
          Glib::ConstructParams::ConstructParams (&D.98403, D.101502, "schema", D.101501, 0B);
          try
            {
              if (1 == 0) goto <D.101504>; else goto <D.101505>;
              <D.101504>:
              iftmp.63 = 8B;
              goto <D.101506>;
              <D.101505>:
              iftmp.63 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101506>:
              D.101507 = &this->D.96969;
              Glib::Object::Object (D.101507, iftmp.63, &D.98403);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98403);
              D.98403 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.101509>; else goto <D.101510>;
              <D.101509>:
              D.101511 = 0B;
              iftmp.64 = *D.101511;
              goto <D.101512>;
              <D.101510>:
              iftmp.64 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101512>:
              this->D.96969._vptr.Object = iftmp.64;
              if (1 == 0) goto <D.101514>; else goto <D.101515>;
              <D.101514>:
              D.101516 = this->D.96969._vptr.Object;
              D.101517 = D.101516 + 18446744073709551592;
              D.101518 = MEM[(long int *)D.101517];
              iftmp.65 = (sizetype) D.101518;
              goto <D.101519>;
              <D.101515>:
              iftmp.65 = 8;
              <D.101519>:
              D.101520 = this + iftmp.65;
              if (1 == 0) goto <D.101522>; else goto <D.101523>;
              <D.101522>:
              iftmp.66 = MEM[(const void * *)0B + 24B];
              goto <D.101524>;
              <D.101523>:
              iftmp.66 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101524>:
              D.101520->_vptr.ObjectBase = iftmp.66;
            }
          catch
            {
              if (1 == 0) goto <D.101526>; else goto <D.101527>;
              <D.101526>:
              iftmp.67 = 8B;
              goto <D.101528>;
              <D.101527>:
              iftmp.67 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101528>:
              D.101507 = &this->D.96969;
              Glib::Object::~Object (D.101507, iftmp.67);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101529>; else goto <D.101530>;
          <D.101529>:
          if (1 == 0) goto <D.101532>; else goto <D.101533>;
          <D.101532>:
          iftmp.68 = 32B;
          goto <D.101534>;
          <D.101533>:
          iftmp.68 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101534>:
          D.101499 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101499, iftmp.68);
          goto <D.101535>;
          <D.101530>:
          <D.101535>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101536>; else goto <D.101537>;
      <D.101536>:
      D.101491 = &this->D.96972;
      sigc::trackable::~trackable (D.101491);
      goto <D.101538>;
      <D.101537>:
      <D.101538>:
    }
}


Gio::Settings::Settings(const Glib::ustring&, const Glib::ustring&) (struct Settings * const this, const void * * __vtt_parm, const struct ustring & schema, const struct ustring & path)
{
  struct trackable * D.101546;
  const void * * iftmp.69;
  struct ObjectBase * D.101554;
  struct ConstructParams D.98413;
  const char * D.101556;
  const char * D.101557;
  const struct Class & D.101558;
  const void * * iftmp.70;
  struct Object * D.101563;
  int (*__vtbl_ptr_type) () * iftmp.71;
  sizetype iftmp.72;
  int (*__vtbl_ptr_type) () * D.101571;
  int (*__vtbl_ptr_type) () * D.101572;
  long int D.101573;
  struct ObjectBase * D.101575;
  int (*__vtbl_ptr_type) () * iftmp.73;
  const void * * iftmp.74;
  const void * * iftmp.75;

  if (0 != 0) goto <D.101544>; else goto <D.101545>;
  <D.101544>:
  D.101546 = &this->D.96972;
  sigc::trackable::trackable (D.101546);
  goto <D.101547>;
  <D.101545>:
  <D.101547>:
  try
    {
      if (0 != 0) goto <D.101548>; else goto <D.101549>;
      <D.101548>:
      if (0 == 0) goto <D.101551>; else goto <D.101552>;
      <D.101551>:
      iftmp.69 = __vtt_parm + 32;
      goto <D.101553>;
      <D.101552>:
      iftmp.69 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101553>:
      D.101554 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101554, iftmp.69, 0B);
      goto <D.101555>;
      <D.101549>:
      <D.101555>:
      try
        {
          D.101556 = Glib::ustring::c_str (path);
          D.101557 = Glib::ustring::c_str (schema);
          D.101558 = Gio::Settings_Class::init (&settings_class_);
          Glib::ConstructParams::ConstructParams (&D.98413, D.101558, "schema", D.101557, "path", D.101556, 0B);
          try
            {
              if (0 == 0) goto <D.101560>; else goto <D.101561>;
              <D.101560>:
              iftmp.70 = __vtt_parm + 8;
              goto <D.101562>;
              <D.101561>:
              iftmp.70 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101562>:
              D.101563 = &this->D.96969;
              Glib::Object::Object (D.101563, iftmp.70, &D.98413);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98413);
              D.98413 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.101565>; else goto <D.101566>;
              <D.101565>:
              iftmp.71 = *__vtt_parm;
              goto <D.101567>;
              <D.101566>:
              iftmp.71 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101567>:
              this->D.96969._vptr.Object = iftmp.71;
              if (0 == 0) goto <D.101569>; else goto <D.101570>;
              <D.101569>:
              D.101571 = this->D.96969._vptr.Object;
              D.101572 = D.101571 + 18446744073709551592;
              D.101573 = MEM[(long int *)D.101572];
              iftmp.72 = (sizetype) D.101573;
              goto <D.101574>;
              <D.101570>:
              iftmp.72 = 8;
              <D.101574>:
              D.101575 = this + iftmp.72;
              if (0 == 0) goto <D.101577>; else goto <D.101578>;
              <D.101577>:
              iftmp.73 = MEM[(const void * *)__vtt_parm + 24B];
              goto <D.101579>;
              <D.101578>:
              iftmp.73 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101579>:
              D.101575->_vptr.ObjectBase = iftmp.73;
            }
          catch
            {
              if (0 == 0) goto <D.101581>; else goto <D.101582>;
              <D.101581>:
              iftmp.74 = __vtt_parm + 8;
              goto <D.101583>;
              <D.101582>:
              iftmp.74 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101583>:
              D.101563 = &this->D.96969;
              Glib::Object::~Object (D.101563, iftmp.74);
            }
        }
      catch
        {
          if (0 != 0) goto <D.101584>; else goto <D.101585>;
          <D.101584>:
          if (0 == 0) goto <D.101587>; else goto <D.101588>;
          <D.101587>:
          iftmp.75 = __vtt_parm + 32;
          goto <D.101589>;
          <D.101588>:
          iftmp.75 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101589>:
          D.101554 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101554, iftmp.75);
          goto <D.101590>;
          <D.101585>:
          <D.101590>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.101591>; else goto <D.101592>;
      <D.101591>:
      D.101546 = &this->D.96972;
      sigc::trackable::~trackable (D.101546);
      goto <D.101593>;
      <D.101592>:
      <D.101593>:
    }
}


Gio::Settings::Settings(const Glib::ustring&, const Glib::ustring&) (struct Settings * const this, const struct ustring & schema, const struct ustring & path)
{
  struct trackable * D.101602;
  const void * * iftmp.76;
  struct ObjectBase * D.101610;
  struct ConstructParams D.98415;
  const char * D.101612;
  const char * D.101613;
  const struct Class & D.101614;
  const void * * iftmp.77;
  struct Object * D.101619;
  int (*__vtbl_ptr_type) () * iftmp.78;
  const void * * D.101623;
  sizetype iftmp.79;
  int (*__vtbl_ptr_type) () * D.101628;
  int (*__vtbl_ptr_type) () * D.101629;
  long int D.101630;
  struct ObjectBase * D.101632;
  int (*__vtbl_ptr_type) () * iftmp.80;
  const void * * iftmp.81;
  const void * * iftmp.82;

  if (1 != 0) goto <D.101600>; else goto <D.101601>;
  <D.101600>:
  D.101602 = &this->D.96972;
  sigc::trackable::trackable (D.101602);
  goto <D.101603>;
  <D.101601>:
  <D.101603>:
  try
    {
      if (1 != 0) goto <D.101604>; else goto <D.101605>;
      <D.101604>:
      if (1 == 0) goto <D.101607>; else goto <D.101608>;
      <D.101607>:
      iftmp.76 = 32B;
      goto <D.101609>;
      <D.101608>:
      iftmp.76 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
      <D.101609>:
      D.101610 = &this->D.96971;
      Glib::ObjectBase::ObjectBase (D.101610, iftmp.76, 0B);
      goto <D.101611>;
      <D.101605>:
      <D.101611>:
      try
        {
          D.101612 = Glib::ustring::c_str (path);
          D.101613 = Glib::ustring::c_str (schema);
          D.101614 = Gio::Settings_Class::init (&settings_class_);
          Glib::ConstructParams::ConstructParams (&D.98415, D.101614, "schema", D.101613, "path", D.101612, 0B);
          try
            {
              if (1 == 0) goto <D.101616>; else goto <D.101617>;
              <D.101616>:
              iftmp.77 = 8B;
              goto <D.101618>;
              <D.101617>:
              iftmp.77 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101618>:
              D.101619 = &this->D.96969;
              Glib::Object::Object (D.101619, iftmp.77, &D.98415);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.98415);
              D.98415 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.101621>; else goto <D.101622>;
              <D.101621>:
              D.101623 = 0B;
              iftmp.78 = *D.101623;
              goto <D.101624>;
              <D.101622>:
              iftmp.78 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 32B];
              <D.101624>:
              this->D.96969._vptr.Object = iftmp.78;
              if (1 == 0) goto <D.101626>; else goto <D.101627>;
              <D.101626>:
              D.101628 = this->D.96969._vptr.Object;
              D.101629 = D.101628 + 18446744073709551592;
              D.101630 = MEM[(long int *)D.101629];
              iftmp.79 = (sizetype) D.101630;
              goto <D.101631>;
              <D.101627>:
              iftmp.79 = 8;
              <D.101631>:
              D.101632 = this + iftmp.79;
              if (1 == 0) goto <D.101634>; else goto <D.101635>;
              <D.101634>:
              iftmp.80 = MEM[(const void * *)0B + 24B];
              goto <D.101636>;
              <D.101635>:
              iftmp.80 = &MEM[(void *)&_ZTVN3Gio8SettingsE + 136B];
              <D.101636>:
              D.101632->_vptr.ObjectBase = iftmp.80;
            }
          catch
            {
              if (1 == 0) goto <D.101638>; else goto <D.101639>;
              <D.101638>:
              iftmp.81 = 8B;
              goto <D.101640>;
              <D.101639>:
              iftmp.81 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 8B];
              <D.101640>:
              D.101619 = &this->D.96969;
              Glib::Object::~Object (D.101619, iftmp.81);
            }
        }
      catch
        {
          if (1 != 0) goto <D.101641>; else goto <D.101642>;
          <D.101641>:
          if (1 == 0) goto <D.101644>; else goto <D.101645>;
          <D.101644>:
          iftmp.82 = 32B;
          goto <D.101646>;
          <D.101645>:
          iftmp.82 = &MEM[(void *)&_ZTTN3Gio8SettingsE + 32B];
          <D.101646>:
          D.101610 = &this->D.96971;
          Glib::ObjectBase::~ObjectBase (D.101610, iftmp.82);
          goto <D.101647>;
          <D.101642>:
          <D.101647>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.101648>; else goto <D.101649>;
      <D.101648>:
      D.101602 = &this->D.96972;
      sigc::trackable::~trackable (D.101602);
      goto <D.101650>;
      <D.101649>:
      <D.101650>:
    }
}


static Glib::RefPtr<Gio::Settings> Gio::Settings::create(const Glib::ustring&) (const struct ustring & schema)
{
  void * D.98420;

  D.98420 = operator new (48);
  try
    {
      Gio::Settings::Settings (D.98420, schema);
    }
  catch
    {
      operator delete (D.98420);
    }
  Glib::RefPtr<Gio::Settings>::RefPtr (<retval>, D.98420);
  return <retval>;
}


static Glib::RefPtr<Gio::Settings> Gio::Settings::create(const Glib::ustring&, const Glib::ustring&) (const struct ustring & schema, const struct ustring & path)
{
  void * D.98427;

  D.98427 = operator new (48);
  try
    {
      Gio::Settings::Settings (D.98427, schema, path);
    }
  catch
    {
      operator delete (D.98427);
    }
  Glib::RefPtr<Gio::Settings>::RefPtr (<retval>, D.98427);
  return <retval>;
}


bool Gio::Settings::set_value(const Glib::ustring&, const Glib::VariantBase&) (struct Settings * const this, const struct ustring & key, const struct VariantBase & value)
{
  bool D.101665;
  const struct GVariant * D.101666;
  const char * D.101667;
  struct GSettings * D.101668;
  int D.101669;

  D.101666 = Glib::VariantBase::gobj (value);
  D.101667 = Glib::ustring::c_str (key);
  D.101668 = Gio::Settings::gobj (this);
  D.101669 = g_settings_set_value (D.101668, D.101667, D.101666);
  D.101665 = D.101669 != 0;
  return D.101665;
}


const GVariant* Glib::VariantBase::gobj() const (const struct VariantBase * const this)
{
  const struct GVariant * D.101673;

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


int Gio::Settings::get_int(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  int D.101675;
  const char * D.101676;
  const struct GSettings * D.101677;

  D.101676 = Glib::ustring::c_str (key);
  D.101677 = Gio::Settings::gobj (this);
  D.101675 = g_settings_get_int (D.101677, D.101676);
  return D.101675;
}


void Gio::Settings::set_int(const Glib::ustring&, int) (struct Settings * const this, const struct ustring & key, int value)
{
  const char * D.101681;
  struct GSettings * D.101682;

  D.101681 = Glib::ustring::c_str (key);
  D.101682 = Gio::Settings::gobj (this);
  g_settings_set_int (D.101682, D.101681, value);
}


guint Gio::Settings::get_uint(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  guint D.101684;
  const char * D.101685;
  const struct GSettings * D.101686;

  D.101685 = Glib::ustring::c_str (key);
  D.101686 = Gio::Settings::gobj (this);
  D.101684 = g_settings_get_uint (D.101686, D.101685);
  return D.101684;
}


void Gio::Settings::set_uiint(const Glib::ustring&, guint) (struct Settings * const this, const struct ustring & key, guint value)
{
  const char * D.101690;
  struct GSettings * D.101691;

  D.101690 = Glib::ustring::c_str (key);
  D.101691 = Gio::Settings::gobj (this);
  g_settings_set_uint (D.101691, D.101690, value);
}


bool Gio::Settings::get_boolean(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  bool D.101693;
  const char * D.101694;
  const struct GSettings * D.101695;
  int D.101696;

  D.101694 = Glib::ustring::c_str (key);
  D.101695 = Gio::Settings::gobj (this);
  D.101696 = g_settings_get_boolean (D.101695, D.101694);
  D.101693 = D.101696 != 0;
  return D.101693;
}


void Gio::Settings::set_boolean(const Glib::ustring&, bool) (struct Settings * const this, const struct ustring & key, bool value)
{
  int D.101700;
  const char * D.101701;
  struct GSettings * D.101702;

  D.101700 = (int) value;
  D.101701 = Glib::ustring::c_str (key);
  D.101702 = Gio::Settings::gobj (this);
  g_settings_set_boolean (D.101702, D.101701, D.101700);
}


Glib::ustring Gio::Settings::get_string(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  const char * D.101705;
  const struct GSettings * D.101706;
  gchar * D.101707;

  D.101705 = Glib::ustring::c_str (key);
  D.101706 = Gio::Settings::gobj (this);
  D.101707 = g_settings_get_string (D.101706, D.101705);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.101707); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.83;
  char * D.101717;
  struct ustring * D.101718;

  cleanup.83 = 0;
  try
    {
      if (str != 0B) goto <D.101712>; else goto <D.101713>;
      <D.101712>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.83 = 1;
      D.101717 = Glib::ScopedPtr<char>::get (&D.78974);
      D.101718 = <retval>;
      Glib::ustring::ustring (D.101718, D.101717);
      goto <D.101719>;
      <D.101713>:
      D.101718 = <retval>;
      Glib::ustring::ustring (D.101718);
      <D.101719>:
      return <retval>;
    }
  finally
    {
      if (cleanup.83 != 0) goto <D.101715>; else goto <D.101716>;
      <D.101715>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.101716>:
    }
}


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


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

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


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

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


void Gio::Settings::set_string(const Glib::ustring&, const Glib::ustring&) (struct Settings * const this, const struct ustring & key, const struct ustring & value)
{
  const char * D.101729;
  const char * D.101730;
  struct GSettings * D.101731;

  D.101729 = Glib::ustring::c_str (value);
  D.101730 = Glib::ustring::c_str (key);
  D.101731 = Gio::Settings::gobj (this);
  g_settings_set_string (D.101731, D.101730, D.101729);
}


double Gio::Settings::get_double(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  double D.101734;
  const char * D.101735;
  const struct GSettings * D.101736;

  D.101735 = Glib::ustring::c_str (key);
  D.101736 = Gio::Settings::gobj (this);
  D.101734 = g_settings_get_double (D.101736, D.101735);
  return D.101734;
}


void Gio::Settings::set_double(const Glib::ustring&, double) (struct Settings * const this, const struct ustring & key, double value)
{
  const char * D.101740;
  struct GSettings * D.101741;

  D.101740 = Glib::ustring::c_str (key);
  D.101741 = Gio::Settings::gobj (this);
  g_settings_set_double (D.101741, D.101740, value);
}


Glib::StringArrayHandle Gio::Settings::get_string_array(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  const char * D.101744;
  const struct GSettings * D.101745;
  gchar * * D.101746;

  D.101744 = Glib::ustring::c_str (key);
  D.101745 = Gio::Settings::gobj (this);
  D.101746 = g_settings_get_strv (D.101745, D.101744);
  Glib::ArrayHandle<Glib::ustring>::ArrayHandle (<retval>, D.101746, 2);
  return <retval>;
}


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

  if (array != 0B) goto <D.101751>; else goto <D.101752>;
  <D.101751>:
  iftmp.84 = Glib::Container_Helpers::compute_array_size<const char*> (array);
  goto <D.101753>;
  <D.101752>:
  iftmp.84 = 0;
  <D.101753>:
  this->size_ = iftmp.84;
  this->parray_ = array;
  this->ownership_ = ownership;
}


std::size_t Glib::Container_Helpers::compute_array_size(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.101754;
  size_t D.101755;
  long int pend.85;
  long int array.86;
  long int D.101758;
  long int D.101759;
  const char * const * pend;

  pend = array;
  goto <D.100142>;
  <D.100143>:
  pend = pend + 8;
  <D.100142>:
  D.101754 = *pend;
  if (D.101754 != 0B) goto <D.100143>; else goto <D.100141>;
  <D.100141>:
  pend.85 = (long int) pend;
  array.86 = (long int) array;
  D.101758 = pend.85 - array.86;
  D.101759 = D.101758 /[ex] 8;
  D.101755 = (size_t) D.101759;
  return D.101755;
}


bool Gio::Settings::set_string_array(const Glib::ustring&, const StringArrayHandle&) (struct Settings * const this, const struct ustring & key, const struct StringArrayHandle & value)
{
  bool D.101761;
  const char * const * D.101762;
  const char * D.101763;
  struct GSettings * D.101764;
  int D.101765;

  D.101762 = Glib::ArrayHandle<Glib::ustring>::data (value);
  D.101763 = Glib::ustring::c_str (key);
  D.101764 = Gio::Settings::gobj (this);
  D.101765 = g_settings_set_strv (D.101764, D.101763, D.101762);
  D.101761 = D.101765 != 0;
  return D.101761;
}


const CType* Glib::ArrayHandle<T, Tr>::data() const [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandle<T, Tr>::CType = const char*] (const struct ArrayHandle * const this)
{
  const char * const * D.101769;

  D.101769 = this->parray_;
  return D.101769;
}


int Gio::Settings::get_enum(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  int D.101771;
  const char * D.101772;
  const struct GSettings * D.101773;

  D.101772 = Glib::ustring::c_str (key);
  D.101773 = Gio::Settings::gobj (this);
  D.101771 = g_settings_get_enum (D.101773, D.101772);
  return D.101771;
}


bool Gio::Settings::get_enum(const Glib::ustring&, int) (struct Settings * const this, const struct ustring & key, int value)
{
  bool D.101777;
  const char * D.101778;
  struct GSettings * D.101779;
  int D.101780;

  D.101778 = Glib::ustring::c_str (key);
  D.101779 = Gio::Settings::gobj (this);
  D.101780 = g_settings_set_enum (D.101779, D.101778, value);
  D.101777 = D.101780 != 0;
  return D.101777;
}


guint Gio::Settings::get_flags(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & key)
{
  guint D.101784;
  const char * D.101785;
  const struct GSettings * D.101786;

  D.101785 = Glib::ustring::c_str (key);
  D.101786 = Gio::Settings::gobj (this);
  D.101784 = g_settings_get_flags (D.101786, D.101785);
  return D.101784;
}


bool Gio::Settings::get_flags(const Glib::ustring&, guint) (struct Settings * const this, const struct ustring & key, guint value)
{
  bool D.101790;
  const char * D.101791;
  struct GSettings * D.101792;
  int D.101793;

  D.101791 = Glib::ustring::c_str (key);
  D.101792 = Gio::Settings::gobj (this);
  D.101793 = g_settings_set_flags (D.101792, D.101791, value);
  D.101790 = D.101793 != 0;
  return D.101790;
}


Glib::RefPtr<Gio::Settings> Gio::Settings::get_child(const Glib::ustring&) (struct Settings * const this, const struct ustring & name)
{
  const char * D.101798;
  struct GSettings * D.101799;
  struct GSettings * D.101800;

  D.101798 = Glib::ustring::c_str (name);
  D.101799 = Gio::Settings::gobj (this);
  D.101800 = g_settings_get_child (D.101799, D.101798);
  *<retval> = Glib::wrap (D.101800, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::Settings> Gio::Settings::get_child(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & name)
{
  struct RefPtr D.98788;

  D.98788 = Gio::Settings::get_child (this, name); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::Settings>::RefPtr<Gio::Settings> (<retval>, &D.98788);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::Settings>::~RefPtr (&D.98788);
      D.98788 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::Settings; T_CppObject = const Gio::Settings] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Settings * D.101808;
  const struct Settings * D.101809;
  int (*__vtbl_ptr_type) () * D.101812;
  int (*__vtbl_ptr_type) () * D.101813;
  long int D.101814;
  sizetype D.101815;
  const struct ObjectBase * D.101816;
  int (*__vtbl_ptr_type) () * D.101817;
  int (*__vtbl_ptr_type) () * D.101818;
  int (*__vtbl_ptr_type) () D.101819;

  D.101808 = Glib::RefPtr<Gio::Settings>::operator-> (src);
  this->pCppObject_ = D.101808;
  D.101809 = this->pCppObject_;
  if (D.101809 != 0B) goto <D.101810>; else goto <D.101811>;
  <D.101810>:
  D.101809 = this->pCppObject_;
  D.101809 = this->pCppObject_;
  D.101812 = D.101809->D.96969._vptr.Object;
  D.101813 = D.101812 + 18446744073709551592;
  D.101814 = MEM[(long int *)D.101813];
  D.101815 = (sizetype) D.101814;
  D.101816 = D.101809 + D.101815;
  D.101809 = this->pCppObject_;
  D.101809 = this->pCppObject_;
  D.101812 = D.101809->D.96969._vptr.Object;
  D.101813 = D.101812 + 18446744073709551592;
  D.101814 = MEM[(long int *)D.101813];
  D.101815 = (sizetype) D.101814;
  D.101816 = D.101809 + D.101815;
  D.101817 = D.101816->_vptr.ObjectBase;
  D.101818 = D.101817 + 16;
  D.101819 = *D.101818;
  D.101809 = this->pCppObject_;
  D.101809 = this->pCppObject_;
  D.101812 = D.101809->D.96969._vptr.Object;
  D.101813 = D.101812 + 18446744073709551592;
  D.101814 = MEM[(long int *)D.101813];
  D.101815 = (sizetype) D.101814;
  D.101816 = D.101809 + D.101815;
  OBJ_TYPE_REF(D.101819;(const struct ObjectBase)D.101816->2) (D.101816);
  goto <D.101820>;
  <D.101811>:
  <D.101820>:
}


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

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


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::Settings] (struct RefPtr * const this)
{
  struct Settings * D.101823;
  int (*__vtbl_ptr_type) () * D.101826;
  int (*__vtbl_ptr_type) () * D.101827;
  long int D.101828;
  sizetype D.101829;
  struct ObjectBase * D.101830;
  int (*__vtbl_ptr_type) () * D.101831;
  int (*__vtbl_ptr_type) () * D.101832;
  int (*__vtbl_ptr_type) () D.101833;

  {
    try
      {
        D.101823 = this->pCppObject_;
        if (D.101823 != 0B) goto <D.101824>; else goto <D.101825>;
        <D.101824>:
        D.101823 = this->pCppObject_;
        D.101823 = this->pCppObject_;
        D.101826 = D.101823->D.96969._vptr.Object;
        D.101827 = D.101826 + 18446744073709551592;
        D.101828 = MEM[(long int *)D.101827];
        D.101829 = (sizetype) D.101828;
        D.101830 = D.101823 + D.101829;
        D.101823 = this->pCppObject_;
        D.101823 = this->pCppObject_;
        D.101826 = D.101823->D.96969._vptr.Object;
        D.101827 = D.101826 + 18446744073709551592;
        D.101828 = MEM[(long int *)D.101827];
        D.101829 = (sizetype) D.101828;
        D.101830 = D.101823 + D.101829;
        D.101831 = D.101830->_vptr.ObjectBase;
        D.101832 = D.101831 + 24;
        D.101833 = *D.101832;
        D.101823 = this->pCppObject_;
        D.101823 = this->pCppObject_;
        D.101826 = D.101823->D.96969._vptr.Object;
        D.101827 = D.101826 + 18446744073709551592;
        D.101828 = MEM[(long int *)D.101827];
        D.101829 = (sizetype) D.101828;
        D.101830 = D.101823 + D.101829;
        OBJ_TYPE_REF(D.101833;(const struct ObjectBase)D.101830->3) (D.101830);
        goto <D.101834>;
        <D.101825>:
        <D.101834>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.99774>:
}


bool Gio::Settings::is_writable(const Glib::ustring&) const (const struct Settings * const this, const struct ustring & name)
{
  bool D.101836;
  const char * D.101837;
  const struct GSettings * D.101838;
  int D.101839;

  D.101837 = Glib::ustring::c_str (name);
  D.101838 = Gio::Settings::gobj (this);
  D.101839 = g_settings_is_writable (D.101838, D.101837);
  D.101836 = D.101839 != 0;
  return D.101836;
}


void Gio::Settings::delay() (struct Settings * const this)
{
  struct GSettings * D.101843;

  D.101843 = Gio::Settings::gobj (this);
  g_settings_delay (D.101843);
}


void Gio::Settings::apply() (struct Settings * const this)
{
  struct GSettings * D.101844;

  D.101844 = Gio::Settings::gobj (this);
  g_settings_apply (D.101844);
}


void Gio::Settings::revert() (struct Settings * const this)
{
  struct GSettings * D.101845;

  D.101845 = Gio::Settings::gobj (this);
  g_settings_revert (D.101845);
}


bool Gio::Settings::get_has_unapplied() const (const struct Settings * const this)
{
  bool D.101846;
  const struct GSettings * D.101847;
  int D.101848;

  D.101847 = Gio::Settings::gobj (this);
  D.101848 = g_settings_get_has_unapplied (D.101847);
  D.101846 = D.101848 != 0;
  return D.101846;
}


void Gio::Settings::reset(const Glib::ustring&) (struct Settings * const this, const struct ustring & key)
{
  const char * D.101851;
  struct GSettings * D.101852;

  D.101851 = Glib::ustring::c_str (key);
  D.101852 = Gio::Settings::gobj (this);
  g_settings_reset (D.101852, D.101851);
}


std::vector<Glib::ustring> Gio::Settings::list_children() const (const struct Settings * const this)
{
  const struct GSettings * D.101855;
  gchar * * D.101856;

  D.101855 = Gio::Settings::gobj (this);
  D.101856 = g_settings_list_children (D.101855);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (D.101856, 2); [return slot optimization]
  return <retval>;
}


std::vector<Glib::ustring> Gio::Settings::list_keys() const (const struct Settings * const this)
{
  const struct GSettings * D.101860;
  gchar * * D.101861;

  D.101860 = Gio::Settings::gobj (this);
  D.101861 = g_settings_list_keys (D.101860);
  *<retval> = Glib::ArrayHandler<Glib::ustring>::array_to_vector (D.101861, 2); [return slot optimization]
  return <retval>;
}


bool Gio::Settings::range_check(const Glib::ustring&, const Glib::VariantBase&) const (const struct Settings * const this, const struct ustring & key, const struct VariantBase & value)
{
  bool D.101864;
  const struct GVariant * D.101865;
  const char * D.101866;
  const struct GSettings * D.101867;
  int D.101868;

  D.101865 = Glib::VariantBase::gobj (value);
  D.101866 = Glib::ustring::c_str (key);
  D.101867 = Gio::Settings::gobj (this);
  D.101868 = g_settings_range_check (D.101867, D.101866, D.101865);
  D.101864 = D.101868 != 0;
  return D.101864;
}


void Gio::Settings::bind(const Glib::ustring&, Glib::ObjectBase*, const Glib::ustring&, Gio::SettingsBindFlags) (struct Settings * const this, const struct ustring & key, struct ObjectBase * object, const struct ustring & property, SettingsBindFlags flags)
{
  const char * D.101872;
  struct GObject * D.101873;
  const char * D.101874;
  struct GSettings * D.101875;

  D.101872 = Glib::ustring::c_str (property);
  D.101873 = Glib::ObjectBase::gobj (object);
  D.101874 = Glib::ustring::c_str (key);
  D.101875 = Gio::Settings::gobj (this);
  g_settings_bind (D.101875, D.101874, D.101873, D.101872, flags);
}


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

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


void Gio::Settings::bind_writable(const Glib::ustring&, Glib::ObjectBase*, const Glib::ustring&, bool) (struct Settings * const this, const struct ustring & key, struct ObjectBase * object, const struct ustring & property, bool inverted)
{
  int D.101880;
  const char * D.101881;
  struct GObject * D.101882;
  const char * D.101883;
  struct GSettings * D.101884;

  D.101880 = (int) inverted;
  D.101881 = Glib::ustring::c_str (property);
  D.101882 = Glib::ObjectBase::gobj (object);
  D.101883 = Glib::ustring::c_str (key);
  D.101884 = Gio::Settings::gobj (this);
  g_settings_bind_writable (D.101884, D.101883, D.101882, D.101881, D.101880);
}


Glib::RefPtr<Gio::Action> Gio::Settings::create_action(const Glib::ustring&) (struct Settings * const this, const struct ustring & key)
{
  const char * D.101888;
  struct GSettings * D.101889;
  struct GAction * D.101890;

  D.101888 = Glib::ustring::c_str (key);
  D.101889 = Gio::Settings::gobj (this);
  D.101890 = g_settings_create_action (D.101889, D.101888);
  *<retval> = Glib::wrap (D.101890, 0); [return slot optimization]
  return <retval>;
}


Glib::SignalProxy1<void, const Glib::ustring&> Gio::Settings::signal_changed() (struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.101895;
  int (*__vtbl_ptr_type) () * D.101896;
  long int D.101897;
  sizetype D.101898;
  struct ObjectBase * D.101899;

  D.101895 = this->D.96969._vptr.Object;
  D.101896 = D.101895 + 18446744073709551592;
  D.101897 = MEM[(long int *)D.101896];
  D.101898 = (sizetype) D.101897;
  D.101899 = this + D.101898;
  Glib::SignalProxy1<void, const Glib::ustring&>::SignalProxy1 (<retval>, D.101899, &Settings_signal_changed_info);
  return <retval>;
}


void {anonymous}::Settings_signal_changed_callback(GSettings*, const gchar*, void*) (struct GSettings * self, const gchar * p0, void * data)
{
  struct Settings * iftmp.87;
  struct ObjectBase * D.101902;
  struct ustring D.97933;
  struct slot1 * D.101910;
  void * D.101912;
  typedef struct SlotType SlotType;
  struct Settings * obj;

  D.101902 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.101902 == 0B) goto <D.101903>; else goto <D.101904>;
  <D.101903>:
  iftmp.87 = 0B;
  goto <D.101905>;
  <D.101904>:
  iftmp.87 = __dynamic_cast (D.101902, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
  <D.101905>:
  obj = iftmp.87;
  {
    if (obj != 0B) goto <D.101906>; else goto <D.101907>;
    <D.101906>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.101908>; else goto <D.101909>;
              <D.101908>:
              D.97933 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
              try
                {
                  D.101910 = &MEM[(struct SlotType *)slot].D.97931;
                  sigc::slot1<void, const Glib::ustring&>::operator() (D.101910, &D.97933);
                }
              finally
                {
                  Glib::ustring::~ustring (&D.97933);
                  D.97933 = {CLOBBER};
                }
              goto <D.101911>;
              <D.101909>:
              <D.101911>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101912 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101912);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.101913>;
    <D.101907>:
    <D.101913>:
  }
}


static sigc::slot_base* Glib::SignalProxyBase::data_to_slot(void*) (void * data)
{
  struct slot_base * D.101919;
  struct slot_base * iftmp.88;
  struct slot_base * D.101921;
  bool D.101922;
  bool D.101923;
  struct SignalProxyConnectionNode * const pConnectionNode;

  pConnectionNode = data;
  D.101921 = &pConnectionNode->slot_;
  D.101922 = sigc::slot_base::blocked (D.101921);
  D.101923 = ~D.101922;
  if (D.101923 != 0) goto <D.101924>; else goto <D.101925>;
  <D.101924>:
  iftmp.88 = &pConnectionNode->slot_;
  goto <D.101926>;
  <D.101925>:
  iftmp.88 = 0B;
  <D.101926>:
  D.101919 = iftmp.88;
  return D.101919;
}


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

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


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = const Glib::ustring&; sigc::slot1<T_return, T_arg1>::arg1_type_ = const Glib::ustring&] (const struct slot1 * const this, const struct ustring & _A_a1)
{
  bool retval.89;
  bool iftmp.90;
  const struct slot_base * D.101934;
  bool D.101935;
  bool D.101936;
  bool D.101938;
  bool D.101939;
  struct rep_type * D.101943;
  void * (*<T605>) (void *) D.101944;

  D.101934 = &this->D.97889;
  D.101935 = sigc::slot_base::empty (D.101934);
  D.101936 = ~D.101935;
  if (D.101936 != 0) goto <D.101937>; else goto <D.101932>;
  <D.101937>:
  D.101934 = &this->D.97889;
  D.101938 = sigc::slot_base::blocked (D.101934);
  D.101939 = ~D.101938;
  if (D.101939 != 0) goto <D.101940>; else goto <D.101932>;
  <D.101940>:
  iftmp.90 = 1;
  goto <D.101933>;
  <D.101932>:
  iftmp.90 = 0;
  <D.101933>:
  retval.89 = iftmp.90;
  if (retval.89 != 0) goto <D.101941>; else goto <D.101942>;
  <D.101941>:
  D.101943 = this->D.97889.rep_;
  D.101944 = D.101943->call_;
  D.101943 = this->D.97889.rep_;
  D.101944 (D.101943, _A_a1);
  return;
  <D.101942>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.101946;
  bool iftmp.91;
  struct rep_type * D.101951;
  void * (*<T605>) (void *) D.101953;

  D.101951 = this->rep_;
  if (D.101951 == 0B) goto <D.101948>; else goto <D.101952>;
  <D.101952>:
  D.101951 = this->rep_;
  D.101953 = D.101951->call_;
  if (D.101953 == 0B) goto <D.101948>; else goto <D.101949>;
  <D.101948>:
  iftmp.91 = 1;
  goto <D.101950>;
  <D.101949>:
  iftmp.91 = 0;
  <D.101950>:
  D.101946 = iftmp.91;
  return D.101946;
}


Glib::SignalProxy1<R, P1>::SignalProxy1(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void; P1 = const Glib::ustring&] (struct SignalProxy1 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.101955;

  D.101955 = &this->D.99018;
  Glib::SignalProxyNormal::SignalProxyNormal (D.101955, obj, info);
  try
    {

    }
  catch
    {
      D.101955 = &this->D.99018;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.101955);
    }
}


Glib::SignalProxy1<bool, unsigned int> Gio::Settings::signal_writable_change_event() (struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.101957;
  int (*__vtbl_ptr_type) () * D.101958;
  long int D.101959;
  sizetype D.101960;
  struct ObjectBase * D.101961;

  D.101957 = this->D.96969._vptr.Object;
  D.101958 = D.101957 + 18446744073709551592;
  D.101959 = MEM[(long int *)D.101958];
  D.101960 = (sizetype) D.101959;
  D.101961 = this + D.101960;
  Glib::SignalProxy1<bool, unsigned int>::SignalProxy1 (<retval>, D.101961, &Settings_signal_writable_change_event_info);
  return <retval>;
}


gboolean {anonymous}::Settings_signal_writable_change_event_notify_callback(GSettings*, guint, void*) (struct GSettings * self, guint p0, void * data)
{
  struct Settings * iftmp.92;
  struct ObjectBase * D.101964;
  struct slot1 * D.101972;
  void * D.101974;
  gboolean D.101976;
  typedef struct SlotType SlotType;
  struct Settings * obj;
  typedef RType RType;

  D.101964 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.101964 == 0B) goto <D.101965>; else goto <D.101966>;
  <D.101965>:
  iftmp.92 = 0B;
  goto <D.101967>;
  <D.101966>:
  iftmp.92 = __dynamic_cast (D.101964, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
  <D.101967>:
  obj = iftmp.92;
  {
    if (obj != 0B) goto <D.101968>; else goto <D.101969>;
    <D.101968>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.101970>; else goto <D.101971>;
              <D.101970>:
              D.101972 = &MEM[(struct SlotType *)slot].D.98149;
              sigc::slot1<void, unsigned int>::operator() (D.101972, &p0);
              goto <D.101973>;
              <D.101971>:
              <D.101973>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.101974 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.101974);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.101975>;
    <D.101969>:
    <D.101975>:
  }
  D.101976 = 0;
  return D.101976;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = unsigned int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const unsigned int&] (const struct slot1 * const this, const unsigned int & _A_a1)
{
  bool retval.93;
  bool iftmp.94;
  const struct slot_base * D.101986;
  bool D.101987;
  bool D.101988;
  bool D.101990;
  bool D.101991;
  struct rep_type * D.101995;
  void * (*<T605>) (void *) D.101996;

  D.101986 = &this->D.98107;
  D.101987 = sigc::slot_base::empty (D.101986);
  D.101988 = ~D.101987;
  if (D.101988 != 0) goto <D.101989>; else goto <D.101984>;
  <D.101989>:
  D.101986 = &this->D.98107;
  D.101990 = sigc::slot_base::blocked (D.101986);
  D.101991 = ~D.101990;
  if (D.101991 != 0) goto <D.101992>; else goto <D.101984>;
  <D.101992>:
  iftmp.94 = 1;
  goto <D.101985>;
  <D.101984>:
  iftmp.94 = 0;
  <D.101985>:
  retval.93 = iftmp.94;
  if (retval.93 != 0) goto <D.101993>; else goto <D.101994>;
  <D.101993>:
  D.101995 = this->D.98107.rep_;
  D.101996 = D.101995->call_;
  D.101995 = this->D.98107.rep_;
  D.101996 (D.101995, _A_a1);
  return;
  <D.101994>:
  return;
}


gboolean {anonymous}::Settings_signal_writable_change_event_callback(GSettings*, guint, void*) (struct GSettings * self, guint p0, void * data)
{
  struct Settings * iftmp.95;
  struct ObjectBase * D.101999;
  gboolean D.102007;
  struct slot1 * D.102008;
  bool D.102009;
  void * D.102010;
  typedef struct SlotType SlotType;
  struct Settings * obj;
  typedef RType RType;

  D.101999 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.101999 == 0B) goto <D.102000>; else goto <D.102001>;
  <D.102000>:
  iftmp.95 = 0B;
  goto <D.102002>;
  <D.102001>:
  iftmp.95 = __dynamic_cast (D.101999, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
  <D.102002>:
  obj = iftmp.95;
  {
    if (obj != 0B) goto <D.102003>; else goto <D.102004>;
    <D.102003>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.102005>; else goto <D.102006>;
              <D.102005>:
              D.102008 = &MEM[(struct SlotType *)slot].D.98044;
              D.102009 = sigc::slot1<bool, unsigned int>::operator() (D.102008, &p0);
              D.102007 = (gboolean) D.102009;
              return D.102007;
              <D.102006>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.102010 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.102010);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.102011>;
    <D.102004>:
    <D.102011>:
  }
  D.102007 = 0;
  return D.102007;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = bool; T_arg1 = unsigned int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const unsigned int&] (const struct slot1 * const this, const unsigned int & _A_a1)
{
  bool retval.96;
  bool iftmp.97;
  const struct slot_base * D.102022;
  bool D.102023;
  bool D.102024;
  bool D.102026;
  bool D.102027;
  bool D.102031;
  struct rep_type * D.102032;
  void * (*<T605>) (void *) D.102033;

  D.102022 = &this->D.98002;
  D.102023 = sigc::slot_base::empty (D.102022);
  D.102024 = ~D.102023;
  if (D.102024 != 0) goto <D.102025>; else goto <D.102020>;
  <D.102025>:
  D.102022 = &this->D.98002;
  D.102026 = sigc::slot_base::blocked (D.102022);
  D.102027 = ~D.102026;
  if (D.102027 != 0) goto <D.102028>; else goto <D.102020>;
  <D.102028>:
  iftmp.97 = 1;
  goto <D.102021>;
  <D.102020>:
  iftmp.97 = 0;
  <D.102021>:
  retval.96 = iftmp.97;
  if (retval.96 != 0) goto <D.102029>; else goto <D.102030>;
  <D.102029>:
  D.102032 = this->D.98002.rep_;
  D.102033 = D.102032->call_;
  D.102032 = this->D.98002.rep_;
  D.102031 = D.102033 (D.102032, _A_a1);
  return D.102031;
  <D.102030>:
  D.102031 = 0;
  return D.102031;
}


Glib::SignalProxy1<R, P1>::SignalProxy1(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = bool; P1 = unsigned int] (struct SignalProxy1 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.102036;

  D.102036 = &this->D.99072;
  Glib::SignalProxyNormal::SignalProxyNormal (D.102036, obj, info);
  try
    {

    }
  catch
    {
      D.102036 = &this->D.99072;
      Glib::SignalProxyNormal::~SignalProxyNormal (D.102036);
    }
}


Glib::SignalProxy1<void, const Glib::ustring&> Gio::Settings::signal_writable_changed() (struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102038;
  int (*__vtbl_ptr_type) () * D.102039;
  long int D.102040;
  sizetype D.102041;
  struct ObjectBase * D.102042;

  D.102038 = this->D.96969._vptr.Object;
  D.102039 = D.102038 + 18446744073709551592;
  D.102040 = MEM[(long int *)D.102039];
  D.102041 = (sizetype) D.102040;
  D.102042 = this + D.102041;
  Glib::SignalProxy1<void, const Glib::ustring&>::SignalProxy1 (<retval>, D.102042, &Settings_signal_writable_changed_info);
  return <retval>;
}


void {anonymous}::Settings_signal_writable_changed_callback(GSettings*, const gchar*, void*) (struct GSettings * self, const gchar * p0, void * data)
{
  struct Settings * iftmp.98;
  struct ObjectBase * D.102045;
  struct ustring D.98162;
  struct slot1 * D.102053;
  void * D.102055;
  typedef struct SlotType SlotType;
  struct Settings * obj;

  D.102045 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.102045 == 0B) goto <D.102046>; else goto <D.102047>;
  <D.102046>:
  iftmp.98 = 0B;
  goto <D.102048>;
  <D.102047>:
  iftmp.98 = __dynamic_cast (D.102045, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio8SettingsE, -1);
  <D.102048>:
  obj = iftmp.98;
  {
    if (obj != 0B) goto <D.102049>; else goto <D.102050>;
    <D.102049>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.102051>; else goto <D.102052>;
              <D.102051>:
              D.98162 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
              try
                {
                  D.102053 = &MEM[(struct SlotType *)slot].D.97931;
                  sigc::slot1<void, const Glib::ustring&>::operator() (D.102053, &D.98162);
                }
              finally
                {
                  Glib::ustring::~ustring (&D.98162);
                  D.98162 = {CLOBBER};
                }
              goto <D.102054>;
              <D.102052>:
              <D.102054>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.102055 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.102055);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.102056>;
    <D.102050>:
    <D.102056>:
  }
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Settings::property_delay_apply() const (const struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102063;
  int (*__vtbl_ptr_type) () * D.102064;
  long int D.102065;
  sizetype D.102066;
  const struct ObjectBase * D.102067;

  D.102063 = this->D.96969._vptr.Object;
  D.102064 = D.102063 + 18446744073709551592;
  D.102065 = MEM[(long int *)D.102064];
  D.102066 = (sizetype) D.102065;
  D.102067 = this + D.102066;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102067, "delay-apply");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = bool] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.102069;

  D.102069 = &this->D.99125;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.102069, obj, name);
}


Glib::PropertyProxy_ReadOnly<bool> Gio::Settings::property_has_unapplied() const (const struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102071;
  int (*__vtbl_ptr_type) () * D.102072;
  long int D.102073;
  sizetype D.102074;
  const struct ObjectBase * D.102075;

  D.102071 = this->D.96969._vptr.Object;
  D.102072 = D.102071 + 18446744073709551592;
  D.102073 = MEM[(long int *)D.102072];
  D.102074 = (sizetype) D.102073;
  D.102075 = this + D.102074;
  Glib::PropertyProxy_ReadOnly<bool>::PropertyProxy_ReadOnly (<retval>, D.102075, "has-unapplied");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<std::basic_string<char> > Gio::Settings::property_path() const (const struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102078;
  int (*__vtbl_ptr_type) () * D.102079;
  long int D.102080;
  sizetype D.102081;
  const struct ObjectBase * D.102082;

  D.102078 = this->D.96969._vptr.Object;
  D.102079 = D.102078 + 18446744073709551592;
  D.102080 = MEM[(long int *)D.102079];
  D.102081 = (sizetype) D.102080;
  D.102082 = this + D.102081;
  Glib::PropertyProxy_ReadOnly<std::basic_string<char> >::PropertyProxy_ReadOnly (<retval>, D.102082, "path");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = std::basic_string<char>] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.102084;

  D.102084 = &this->D.99174;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.102084, obj, name);
}


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::Settings::property_schema() const (const struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102086;
  int (*__vtbl_ptr_type) () * D.102087;
  long int D.102088;
  sizetype D.102089;
  const struct ObjectBase * D.102090;

  D.102086 = this->D.96969._vptr.Object;
  D.102087 = D.102086 + 18446744073709551592;
  D.102088 = MEM[(long int *)D.102087];
  D.102089 = (sizetype) D.102088;
  D.102090 = this + D.102089;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.102090, "schema");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Glib::ustring] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.102092;

  D.102092 = &this->D.99210;
  Glib::PropertyProxy_Base::PropertyProxy_Base (D.102092, obj, name);
}


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::Settings::property_schema_id() const (const struct Settings * const this)
{
  int (*__vtbl_ptr_type) () * D.102094;
  int (*__vtbl_ptr_type) () * D.102095;
  long int D.102096;
  sizetype D.102097;
  const struct ObjectBase * D.102098;

  D.102094 = this->D.96969._vptr.Object;
  D.102095 = D.102094 + 18446744073709551592;
  D.102096 = MEM[(long int *)D.102095];
  D.102097 = (sizetype) D.102096;
  D.102098 = this + D.102097;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.102098, "schema-id");
  return <retval>;
}


virtual void Gio::Settings::on_changed(const Glib::ustring&) (struct Settings * const this, const struct ustring & key)
{
  int (*__vtbl_ptr_type) () * D.102100;
  int (*__vtbl_ptr_type) () * D.102101;
  long int D.102102;
  sizetype D.102103;
  struct ObjectBase * D.102104;
  struct GObject * D.102105;
  struct GTypeClass * D.102106;
  void (*<T10ca4>) (struct GSettings *, const gchar *) D.102109;
  const char * D.102112;
  struct GSettings * D.102113;
  struct BaseClassType * const base;

  D.102100 = this->D.96969._vptr.Object;
  D.102101 = D.102100 + 18446744073709551592;
  D.102102 = MEM[(long int *)D.102101];
  D.102103 = (sizetype) D.102102;
  D.102104 = this + D.102103;
  D.102105 = D.102104->gobject_;
  D.102106 = MEM[(struct GTypeInstance *)D.102105].g_class;
  base = g_type_class_peek_parent (D.102106);
  if (base != 0B) goto <D.102107>; else goto <D.102108>;
  <D.102107>:
  D.102109 = base->changed;
  if (D.102109 != 0B) goto <D.102110>; else goto <D.102111>;
  <D.102110>:
  D.102109 = base->changed;
  D.102112 = Glib::ustring::c_str (key);
  D.102113 = Gio::Settings::gobj (this);
  D.102109 (D.102113, D.102112);
  goto <D.102114>;
  <D.102111>:
  <D.102114>:
  <D.102108>:
}


virtual bool Gio::Settings::on_writable_change_event(guint) (struct Settings * const this, guint key)
{
  int (*__vtbl_ptr_type) () * D.102117;
  int (*__vtbl_ptr_type) () * D.102118;
  long int D.102119;
  sizetype D.102120;
  struct ObjectBase * D.102121;
  struct GObject * D.102122;
  struct GTypeClass * D.102123;
  gboolean (*<T10caa>) (struct GSettings *, GQuark) D.102126;
  bool D.102129;
  struct GSettings * D.102130;
  int D.102131;
  struct BaseClassType * const base;
  typedef RType RType;

  D.102117 = this->D.96969._vptr.Object;
  D.102118 = D.102117 + 18446744073709551592;
  D.102119 = MEM[(long int *)D.102118];
  D.102120 = (sizetype) D.102119;
  D.102121 = this + D.102120;
  D.102122 = D.102121->gobject_;
  D.102123 = MEM[(struct GTypeInstance *)D.102122].g_class;
  base = g_type_class_peek_parent (D.102123);
  if (base != 0B) goto <D.102124>; else goto <D.102125>;
  <D.102124>:
  D.102126 = base->writable_change_event;
  if (D.102126 != 0B) goto <D.102127>; else goto <D.102128>;
  <D.102127>:
  D.102126 = base->writable_change_event;
  D.102130 = Gio::Settings::gobj (this);
  D.102131 = D.102126 (D.102130, key);
  D.102129 = D.102131 != 0;
  return D.102129;
  <D.102128>:
  <D.102125>:
  D.102129 = 0;
  return D.102129;
}


virtual void Gio::Settings::on_writable_changed(const Glib::ustring&) (struct Settings * const this, const struct ustring & key)
{
  int (*__vtbl_ptr_type) () * D.102135;
  int (*__vtbl_ptr_type) () * D.102136;
  long int D.102137;
  sizetype D.102138;
  struct ObjectBase * D.102139;
  struct GObject * D.102140;
  struct GTypeClass * D.102141;
  void (*<T10ca4>) (struct GSettings *, const gchar *) D.102144;
  const char * D.102147;
  struct GSettings * D.102148;
  struct BaseClassType * const base;

  D.102135 = this->D.96969._vptr.Object;
  D.102136 = D.102135 + 18446744073709551592;
  D.102137 = MEM[(long int *)D.102136];
  D.102138 = (sizetype) D.102137;
  D.102139 = this + D.102138;
  D.102140 = D.102139->gobject_;
  D.102141 = MEM[(struct GTypeInstance *)D.102140].g_class;
  base = g_type_class_peek_parent (D.102141);
  if (base != 0B) goto <D.102142>; else goto <D.102143>;
  <D.102142>:
  D.102144 = base->writable_changed;
  if (D.102144 != 0B) goto <D.102145>; else goto <D.102146>;
  <D.102145>:
  D.102144 = base->writable_changed;
  D.102147 = Glib::ustring::c_str (key);
  D.102148 = Gio::Settings::gobj (this);
  D.102144 (D.102148, D.102147);
  goto <D.102149>;
  <D.102146>:
  <D.102149>:
  <D.102143>:
}