Glib::VariantBase::VariantBase(GVariant*, bool) (struct VariantBase * const this, struct GVariant * castitem, bool make_a_copy)
{
  bool retval.0;
  int D.90988;

  if (castitem != 0B) goto <D.90985>; else goto <D.90986>;
  <D.90985>:
  D.90988 = g_variant_is_floating (castitem);
  retval.0 = D.90988 != 0;
  if (retval.0 != 0) goto <D.90989>; else goto <D.90990>;
  <D.90989>:
  g_variant_ref_sink (castitem);
  goto <D.90991>;
  <D.90990>:
  <D.90991>:
  if (make_a_copy != 0) goto <D.90992>; else goto <D.90993>;
  <D.90992>:
  g_variant_ref (castitem);
  goto <D.90994>;
  <D.90993>:
  <D.90994>:
  goto <D.90995>;
  <D.90986>:
  <D.90995>:
  this->gobject_ = castitem;
}


void Glib::VariantBase::get_normal_form(Glib::VariantBase&) const (const struct VariantBase * const this, struct VariantBase & result)
{
  const struct GVariant * D.90997;
  struct GVariant * const g_value;

  D.90997 = Glib::VariantBase::gobj (this);
  g_value = g_variant_get_normal_form (D.90997);
  Glib::VariantBase::init (result, g_value, 0);
}


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

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


void Glib::VariantBase::byteswap(Glib::VariantBase&) const (const struct VariantBase * const this, struct VariantBase & result)
{
  const struct GVariant * D.91001;
  struct GVariant * const g_value;

  D.91001 = Glib::VariantBase::gobj (this);
  g_value = g_variant_byteswap (D.91001);
  Glib::VariantBase::init (result, g_value, 0);
}


Glib::VariantStringBase::VariantStringBase() (struct VariantStringBase * const this)
{
  struct VariantBase * D.91003;

  D.91003 = &this->D.66743;
  Glib::VariantBase::VariantBase (D.91003);
  try
    {

    }
  catch
    {
      D.91003 = &this->D.66743;
      Glib::VariantBase::~VariantBase (D.91003);
    }
}


Glib::VariantStringBase::VariantStringBase(GVariant*, bool) (struct VariantStringBase * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91004;
  struct VariantBase * D.91005;

  D.91004 = (int) take_a_reference;
  D.91005 = &this->D.66743;
  Glib::VariantBase::VariantBase (D.91005, castitem, D.91004);
  try
    {

    }
  catch
    {
      D.91005 = &this->D.66743;
      Glib::VariantBase::~VariantBase (D.91005);
    }
}


static void Glib::VariantStringBase::create_object_path(Glib::VariantStringBase&, const string&) (struct VariantStringBase & output, const struct string & object_path)
{
  const char * D.91006;
  struct VariantBase * D.91007;
  struct GVariant * result;

  result = 0B;
  D.91006 = std::basic_string<char>::c_str (object_path);
  result = g_variant_new_object_path (D.91006);
  g_variant_ref_sink (result);
  D.91007 = &output->D.66743;
  Glib::VariantBase::init (D.91007, result, 0);
}


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

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


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

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


static void Glib::VariantStringBase::create_signature(Glib::VariantStringBase&, const string&) (struct VariantStringBase & output, const struct string & signature)
{
  const char * D.91015;
  struct VariantBase * D.91016;
  struct GVariant * result;

  result = 0B;
  D.91015 = std::basic_string<char>::c_str (signature);
  result = g_variant_new_signature (D.91015);
  g_variant_ref_sink (result);
  D.91016 = &output->D.66743;
  Glib::VariantBase::init (D.91016, result, 0);
}


Glib::VariantContainerBase::VariantContainerBase() (struct VariantContainerBase * const this)
{
  struct VariantBase * D.91019;

  D.91019 = &this->D.66789;
  Glib::VariantBase::VariantBase (D.91019);
  try
    {

    }
  catch
    {
      D.91019 = &this->D.66789;
      Glib::VariantBase::~VariantBase (D.91019);
    }
}


Glib::VariantContainerBase::VariantContainerBase(GVariant*, bool) (struct VariantContainerBase * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91020;
  struct VariantBase * D.91021;

  D.91020 = (int) take_a_reference;
  D.91021 = &this->D.66789;
  Glib::VariantBase::VariantBase (D.91021, castitem, D.91020);
  try
    {

    }
  catch
    {
      D.91021 = &this->D.66789;
      Glib::VariantBase::~VariantBase (D.91021);
    }
}


static Glib::VariantContainerBase Glib::VariantContainerBase::create_tuple(const std::vector<Glib::VariantBase>&) (const struct vector & children)
{
  size_t iftmp.1;
  long unsigned int D.91024;
  long unsigned int D.91028;
  struct GVariant * * D.91029;
  const struct VariantBase & D.91030;
  const struct GVariant * D.91031;
  bool retval.2;
  long unsigned int D.91033;
  long unsigned int D.91034;
  struct GVariant * D.91035;
  typedef struct GVariant * var_ptr;
  struct GVariant * * const var_array;
  struct VariantContainerBase result [value-expr: *<retval>];

  D.91024 = std::vector<Glib::VariantBase>::size (children);
  if (D.91024 <= 1143914305352105984) goto <D.91025>; else goto <D.91026>;
  <D.91025>:
  iftmp.1 = D.91024 * 8;
  goto <D.91027>;
  <D.91026>:
  iftmp.1 = 18446744073709551615;
  <D.91027>:
  var_array = operator new [] (iftmp.1);
  {
    size_type i;

    i = 0;
    goto <D.86750>;
    <D.86749>:
    D.91028 = i * 8;
    D.91029 = var_array + D.91028;
    D.91030 = std::vector<Glib::VariantBase>::operator[] (children, i);
    D.91031 = Glib::VariantBase::gobj (D.91030);
    *D.91029 = D.91031;
    i = i + 1;
    <D.86750>:
    D.91033 = std::vector<Glib::VariantBase>::size (children);
    retval.2 = D.91033 > i;
    if (retval.2 != 0) goto <D.86749>; else goto <D.86747>;
    <D.86747>:
  }
  D.91034 = std::vector<Glib::VariantBase>::size (children);
  D.91035 = g_variant_new_tuple (var_array, D.91034);
  Glib::VariantContainerBase::VariantContainerBase (<retval>, D.91035, 0);
  try
    {
      if (var_array != 0B) goto <D.91036>; else goto <D.91037>;
      <D.91036>:
      operator delete [] (var_array);
      goto <D.91038>;
      <D.91037>:
      <D.91038>:
      return <retval>;
    }
  catch
    {
      Glib::VariantContainerBase::~VariantContainerBase (<retval>);
    }
}


std::vector<_Tp, _Alloc>::const_reference std::vector<_Tp, _Alloc>::operator[](std::vector<_Tp, _Alloc>::size_type) const [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::const_reference = const Glib::VariantBase&; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n)
{
  const struct VariantBase & D.91042;
  struct VariantBase * D.91043;
  long unsigned int D.91044;

  D.91043 = this->D.86741._M_impl._M_start;
  D.91044 = __n * 8;
  D.91042 = D.91043 + D.91044;
  return D.91042;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.91046;
  struct VariantBase * D.91047;
  long int D.91048;
  struct VariantBase * D.91049;
  long int D.91050;
  long int D.91051;
  long int D.91052;

  D.91047 = this->D.86741._M_impl._M_finish;
  D.91048 = (long int) D.91047;
  D.91049 = this->D.86741._M_impl._M_start;
  D.91050 = (long int) D.91049;
  D.91051 = D.91048 - D.91050;
  D.91052 = D.91051 /[ex] 8;
  D.91046 = (size_type) D.91052;
  return D.91046;
}


static Glib::VariantContainerBase Glib::VariantContainerBase::create_tuple(const Glib::VariantBase&) (const struct VariantBase & child)
{
  struct vector vec;

  try
    {
      std::vector<Glib::VariantBase>::vector (&vec);
      try
        {
          std::vector<Glib::VariantBase>::push_back (&vec, child);
          *<retval> = Glib::VariantContainerBase::create_tuple (&vec); [return slot optimization]
          return <retval>;
        }
      finally
        {
          std::vector<Glib::VariantBase>::~vector (&vec);
        }
    }
  finally
    {
      vec = {CLOBBER};
    }
}


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

  D.91061 = &this->D.86741;
  std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_Vector_base (D.91061);
  try
    {

    }
  catch
    {
      D.91061 = &this->D.86741;
      std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::~_Vector_base (D.91061);
    }
}


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

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

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


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


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

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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::value_type = Glib::VariantBase] (struct vector * const this, const struct value_type & __x)
{
  struct VariantBase * D.91065;
  struct VariantBase * D.91066;
  struct _Vector_impl * D.91069;
  struct VariantBase * D.91070;
  struct __normal_iterator D.91072;

  D.91065 = this->D.86741._M_impl._M_finish;
  D.91066 = this->D.86741._M_impl._M_end_of_storage;
  if (D.91065 != D.91066) goto <D.91067>; else goto <D.91068>;
  <D.91067>:
  D.91065 = this->D.86741._M_impl._M_finish;
  D.91069 = &this->D.86741._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::construct<Glib::VariantBase> (D.91069, D.91065, __x);
  D.91065 = this->D.86741._M_impl._M_finish;
  D.91070 = D.91065 + 8;
  this->D.86741._M_impl._M_finish = D.91070;
  goto <D.91071>;
  <D.91068>:
  D.91072 = std::vector<Glib::VariantBase>::end (this);
  std::vector<Glib::VariantBase>::_M_insert_aux (this, D.91072, __x);
  <D.91071>:
}


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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = Glib::VariantBase; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::VariantBase*] (struct new_allocator * const this, struct VariantBase * __p, const struct VariantBase & __val)
{
  void * D.90367;
  void * D.90368;
  struct VariantBase * iftmp.3;

  D.90367 = __p;
  D.90368 = operator new (8, D.90367);
  if (D.90368 != 0B) goto <D.91074>; else goto <D.91075>;
  <D.91074>:
  try
    {
      Glib::VariantBase::VariantBase (D.90368, __val);
    }
  catch
    {
      operator delete (D.90368, D.90367);
    }
  iftmp.3 = D.90368;
  goto <D.91076>;
  <D.91075>:
  iftmp.3 = D.90368;
  <D.91076>:
}


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

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


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

  try
    {

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


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::end() [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = Glib::VariantBase*] (struct vector * const this)
{
  struct iterator D.91082;
  struct iterator D.90053;
  struct VariantBase * * D.91083;

  D.91083 = &this->D.86741._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::__normal_iterator (&D.90053, D.91083);
  try
    {
      D.91082 = D.90053;
      return D.91082;
    }
  finally
    {
      D.90053 = {CLOBBER};
    }
}


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

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


void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = Glib::VariantBase*] (struct vector * const this, struct iterator __position, const struct VariantBase & __x)
{
  struct VariantBase * D.91087;
  struct VariantBase * D.91088;
  const struct VariantBase * D.91091;
  struct _Vector_impl * D.91092;
  struct VariantBase * D.91093;
  struct VariantBase * D.91094;
  struct VariantBase * D.91095;
  struct VariantBase * const & D.91096;
  struct VariantBase * D.91097;
  struct VariantBase & D.91098;
  struct iterator D.90038;
  long int D.91100;
  struct _Vector_base * D.91101;
  long unsigned int D.91102;
  struct VariantBase * D.91103;
  struct _Tp_alloc_type & D.91104;
  struct VariantBase * const & D.91105;
  struct VariantBase * D.91106;
  struct VariantBase * D.91107;
  struct _Tp_alloc_type & D.91108;
  struct VariantBase * const & D.91109;
  struct VariantBase * D.91110;
  void * D.91111;
  struct _Tp_alloc_type & D.91115;
  struct _Tp_alloc_type & D.91116;
  long int D.91117;
  long int D.91118;
  long int D.91119;
  long int D.91120;
  long unsigned int D.91121;
  long unsigned int D.91122;
  struct VariantBase * D.91123;

  {
    D.91087 = this->D.86741._M_impl._M_finish;
    D.91088 = this->D.86741._M_impl._M_end_of_storage;
    if (D.91087 != D.91088) goto <D.91089>; else goto <D.91090>;
    <D.91089>:
    {
      struct VariantBase __x_copy;

      try
        {
          D.91087 = this->D.86741._M_impl._M_finish;
          D.91091 = D.91087 + 18446744073709551608;
          D.91087 = this->D.86741._M_impl._M_finish;
          D.91092 = &this->D.86741._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::construct<Glib::VariantBase> (D.91092, D.91087, D.91091);
          D.91087 = this->D.86741._M_impl._M_finish;
          D.91093 = D.91087 + 8;
          this->D.86741._M_impl._M_finish = D.91093;
          Glib::VariantBase::VariantBase (&__x_copy, __x);
          try
            {
              D.91087 = this->D.86741._M_impl._M_finish;
              D.91094 = D.91087 + 18446744073709551608;
              D.91087 = this->D.86741._M_impl._M_finish;
              D.91095 = D.91087 + 18446744073709551600;
              D.91096 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::base (&__position);
              D.91097 = *D.91096;
              std::copy_backward<Glib::VariantBase*, Glib::VariantBase*> (D.91097, D.91095, D.91094);
              D.91098 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::operator* (&__position);
              Glib::VariantBase::operator= (D.91098, &__x_copy);
            }
          finally
            {
              Glib::VariantBase::~VariantBase (&__x_copy);
            }
        }
      finally
        {
          __x_copy = {CLOBBER};
        }
    }
    goto <D.91099>;
    <D.91090>:
    {
      const size_type __len;
      const size_type __elems_before;
      struct VariantBase * __new_start;
      struct VariantBase * __new_finish;

      __len = std::vector<Glib::VariantBase>::_M_check_len (this, 1, "vector::_M_insert_aux");
      D.90038 = std::vector<Glib::VariantBase>::begin (this);
      try
        {
          D.91100 = __gnu_cxx::operator-<Glib::VariantBase*, std::vector<Glib::VariantBase> > (&__position, &D.90038);
          __elems_before = (const size_type) D.91100;
        }
      finally
        {
          D.90038 = {CLOBBER};
        }
      D.91101 = &this->D.86741;
      __new_start = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_allocate (D.91101, __len);
      __new_finish = __new_start;
      try
        {
          D.91102 = __elems_before * 8;
          D.91103 = __new_start + D.91102;
          D.91092 = &this->D.86741._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::construct<Glib::VariantBase> (D.91092, D.91103, __x);
          __new_finish = 0B;
          D.91101 = &this->D.86741;
          D.91104 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91101);
          D.91105 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::base (&__position);
          D.91106 = *D.91105;
          D.91107 = this->D.86741._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<Glib::VariantBase*, Glib::VariantBase*, std::allocator<Glib::VariantBase> > (D.91107, D.91106, __new_start, D.91104);
          __new_finish = __new_finish + 8;
          D.91101 = &this->D.86741;
          D.91108 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91101);
          D.91087 = this->D.86741._M_impl._M_finish;
          D.91109 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::base (&__position);
          D.91110 = *D.91109;
          __new_finish = std::__uninitialized_move_if_noexcept_a<Glib::VariantBase*, Glib::VariantBase*, std::allocator<Glib::VariantBase> > (D.91110, D.91087, __new_finish, D.91108);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.91111 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.91111);
                  if (__new_finish == 0B) goto <D.91112>; else goto <D.91113>;
                  <D.91112>:
                  D.91102 = __elems_before * 8;
                  D.91103 = __new_start + D.91102;
                  D.91092 = &this->D.86741._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::destroy (D.91092, D.91103);
                  goto <D.91114>;
                  <D.91113>:
                  D.91101 = &this->D.86741;
                  D.91115 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91101);
                  std::_Destroy<Glib::VariantBase*, Glib::VariantBase> (__new_start, __new_finish, D.91115);
                  <D.91114>:
                  D.91101 = &this->D.86741;
                  std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_deallocate (D.91101, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.91101 = &this->D.86741;
      D.91116 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91101);
      D.91087 = this->D.86741._M_impl._M_finish;
      D.91107 = this->D.86741._M_impl._M_start;
      std::_Destroy<Glib::VariantBase*, Glib::VariantBase> (D.91107, D.91087, D.91116);
      D.91088 = this->D.86741._M_impl._M_end_of_storage;
      D.91117 = (long int) D.91088;
      D.91107 = this->D.86741._M_impl._M_start;
      D.91118 = (long int) D.91107;
      D.91119 = D.91117 - D.91118;
      D.91120 = D.91119 /[ex] 8;
      D.91121 = (long unsigned int) D.91120;
      D.91107 = this->D.86741._M_impl._M_start;
      D.91101 = &this->D.86741;
      std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_deallocate (D.91101, D.91107, D.91121);
      this->D.86741._M_impl._M_start = __new_start;
      this->D.86741._M_impl._M_finish = __new_finish;
      D.91122 = __len * 8;
      D.91123 = __new_start + D.91122;
      this->D.86741._M_impl._M_end_of_storage = D.91123;
    }
    <D.91099>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = Glib::VariantBase*; _BI2 = Glib::VariantBase*] (struct VariantBase * __first, struct VariantBase * __last, struct VariantBase * __result)
{
  struct VariantBase * D.91133;
  struct VariantBase * D.91134;
  struct VariantBase * D.91135;

  D.91134 = std::__miter_base<Glib::VariantBase*> (__last);
  D.91135 = std::__miter_base<Glib::VariantBase*> (__first);
  D.91133 = std::__copy_move_backward_a2<false, Glib::VariantBase*, Glib::VariantBase*> (D.91135, D.91134, __result);
  return D.91133;
}


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

  D.91140 = std::_Iter_base<Glib::VariantBase*, false>::_S_base (__it);
  return D.91140;
}


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

  D.91142 = __it;
  return D.91142;
}


_BI2 std::__copy_move_backward_a2(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = Glib::VariantBase*; _BI2 = Glib::VariantBase*] (struct VariantBase * __first, struct VariantBase * __last, struct VariantBase * __result)
{
  struct VariantBase * D.91144;
  struct VariantBase * D.91145;
  struct VariantBase * D.91146;
  struct VariantBase * D.91147;

  D.91145 = std::__niter_base<Glib::VariantBase*> (__result);
  D.91146 = std::__niter_base<Glib::VariantBase*> (__last);
  D.91147 = std::__niter_base<Glib::VariantBase*> (__first);
  D.91144 = std::__copy_move_backward_a<false, Glib::VariantBase*, Glib::VariantBase*> (D.91147, D.91146, D.91145);
  return D.91144;
}


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

  D.91150 = std::_Iter_base<Glib::VariantBase*, false>::_S_base (__it);
  return D.91150;
}


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

  __simple = 0;
  D.91152 = std::__copy_move_backward<false, false, std::random_access_iterator_tag>::__copy_move_b<Glib::VariantBase*, Glib::VariantBase*> (__first, __last, __result);
  return D.91152;
}


static _BI2 std::__copy_move_backward<false, false, std::random_access_iterator_tag>::__copy_move_b(_BI1, _BI1, _BI2) [with _BI1 = Glib::VariantBase*; _BI2 = Glib::VariantBase*] (struct VariantBase * __first, struct VariantBase * __last, struct VariantBase * __result)
{
  long int __last.4;
  long int __first.5;
  long int D.91157;
  struct VariantBase * D.91158;
  difference_type __n;

  __last.4 = (long int) __last;
  __first.5 = (long int) __first;
  D.91157 = __last.4 - __first.5;
  __n = D.91157 /[ex] 8;
  goto <D.90901>;
  <D.90900>:
  __last = __last + 18446744073709551608;
  __result = __result + 18446744073709551608;
  Glib::VariantBase::operator= (__result, __last);
  __n = __n + -1;
  <D.90901>:
  if (__n > 0) goto <D.90900>; else goto <D.90898>;
  <D.90898>:
  D.91158 = __result;
  return D.91158;
}


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

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


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::_M_check_len(std::vector<_Tp, _Alloc>::size_type, const char*) const [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n, const char * __s)
{
  bool retval.6;
  long unsigned int D.91163;
  long unsigned int D.91164;
  long unsigned int D.91165;
  long unsigned int __n.7;
  long unsigned int D.91169;
  const long unsigned int D.90394;
  long unsigned int D.91170;
  const long unsigned int & D.91171;
  long unsigned int D.91172;
  size_type D.91173;
  size_type iftmp.8;
  long unsigned int D.91178;
  long unsigned int D.91180;
  const size_type __len;

  D.91163 = std::vector<Glib::VariantBase>::max_size (this);
  D.91164 = std::vector<Glib::VariantBase>::size (this);
  D.91165 = D.91163 - D.91164;
  __n.7 = __n;
  retval.6 = D.91165 < __n.7;
  if (retval.6 != 0) goto <D.91167>; else goto <D.91168>;
  <D.91167>:
  std::__throw_length_error (__s);
  <D.91168>:
  D.91169 = std::vector<Glib::VariantBase>::size (this);
  D.91170 = std::vector<Glib::VariantBase>::size (this);
  D.90394 = D.91170;
  try
    {
      D.91171 = std::max<long unsigned int> (&D.90394, &__n);
      D.91172 = *D.91171;
      __len = D.91169 + D.91172;
    }
  finally
    {
      D.90394 = {CLOBBER};
    }
  D.91178 = std::vector<Glib::VariantBase>::size (this);
  if (D.91178 > __len) goto <D.91175>; else goto <D.91179>;
  <D.91179>:
  D.91180 = std::vector<Glib::VariantBase>::max_size (this);
  if (D.91180 < __len) goto <D.91175>; else goto <D.91176>;
  <D.91175>:
  iftmp.8 = std::vector<Glib::VariantBase>::max_size (this);
  goto <D.91177>;
  <D.91176>:
  iftmp.8 = __len;
  <D.91177>:
  D.91173 = iftmp.8;
  return D.91173;
}


const _Tp& std::max(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.91185;
  long unsigned int D.91186;
  const long unsigned int & D.91189;

  D.91185 = *__a;
  D.91186 = *__b;
  if (D.91185 < D.91186) goto <D.91187>; else goto <D.91188>;
  <D.91187>:
  D.91189 = __b;
  return D.91189;
  <D.91188>:
  D.91189 = __a;
  return D.91189;
}


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

  D.91192 = &this->D.86741;
  D.91193 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91192);
  D.91191 = __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::max_size (D.91193);
  return D.91191;
}


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

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


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

  D.91197 = __gnu_cxx::new_allocator<Glib::VariantBase>::max_size (__a);
  return D.91197;
}


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

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


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::begin() [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = Glib::VariantBase*] (struct vector * const this)
{
  struct iterator D.91202;
  struct iterator D.90396;
  struct VariantBase * * D.91203;

  D.91203 = &this->D.86741._M_impl._M_start;
  __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::__normal_iterator (&D.90396, D.91203);
  try
    {
      D.91202 = D.90396;
      return D.91202;
    }
  finally
    {
      D.90396 = {CLOBBER};
    }
}


typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type __gnu_cxx::operator-(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = Glib::VariantBase*; _Container = std::vector<Glib::VariantBase>; typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type = long int] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  difference_type D.91206;
  struct VariantBase * const & D.91207;
  struct VariantBase * D.91208;
  long int D.91209;
  struct VariantBase * const & D.91210;
  struct VariantBase * D.91211;
  long int D.91212;
  long int D.91213;

  D.91207 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::base (__lhs);
  D.91208 = *D.91207;
  D.91209 = (long int) D.91208;
  D.91210 = __gnu_cxx::__normal_iterator<Glib::VariantBase*, std::vector<Glib::VariantBase> >::base (__rhs);
  D.91211 = *D.91210;
  D.91212 = (long int) D.91211;
  D.91213 = D.91209 - D.91212;
  D.91206 = D.91213 /[ex] 8;
  return D.91206;
}


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

  if (__n != 0) goto <D.91217>; else goto <D.91218>;
  <D.91217>:
  D.91219 = &this->_M_impl;
  iftmp.9 = __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::allocate (D.91219, __n);
  goto <D.91220>;
  <D.91218>:
  iftmp.9 = 0B;
  <D.91220>:
  D.91215 = iftmp.9;
  return D.91215;
}


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

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


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = Glib::VariantBase; __gnu_cxx::new_allocator<_Tp>::pointer = Glib::VariantBase*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.86054)
{
  bool retval.10;
  long unsigned int D.91227;
  struct VariantBase * D.91230;
  long unsigned int D.91231;

  D.91227 = __gnu_cxx::new_allocator<Glib::VariantBase>::max_size (this);
  retval.10 = D.91227 < __n;
  if (retval.10 != 0) goto <D.91228>; else goto <D.91229>;
  <D.91228>:
  std::__throw_bad_alloc ();
  <D.91229>:
  D.91231 = __n * 8;
  D.91230 = operator new (D.91231);
  return D.91230;
}


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

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


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

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


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = Glib::VariantBase*; _ForwardIterator = Glib::VariantBase*; _Tp = Glib::VariantBase] (struct VariantBase * __first, struct VariantBase * __last, struct VariantBase * __result, struct allocator & D.90405)
{
  struct VariantBase * D.91239;

  D.91239 = std::uninitialized_copy<Glib::VariantBase*, Glib::VariantBase*> (__first, __last, __result);
  return D.91239;
}


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

  __assignable = 1;
  D.91242 = std::__uninitialized_copy<false>::__uninit_copy<Glib::VariantBase*, Glib::VariantBase*> (__first, __last, __result);
  return D.91242;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::VariantBase*; _ForwardIterator = Glib::VariantBase*; bool _TrivialValueTypes = false] (struct VariantBase * __first, struct VariantBase * __last, struct VariantBase * __result)
{
  struct VariantBase * D.91245;
  struct VariantBase * D.91246;
  void * D.91247;
  struct VariantBase * __cur;

  __cur = __result;
  try
    {
      goto <D.90911>;
      <D.90910>:
      D.91245 = std::__addressof<Glib::VariantBase> (__cur);
      std::_Construct<Glib::VariantBase, Glib::VariantBase> (D.91245, __first);
      __first = __first + 8;
      __cur = __cur + 8;
      <D.90911>:
      if (__first != __last) goto <D.90910>; else goto <D.90908>;
      <D.90908>:
      D.91246 = __cur;
      return D.91246;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.91247 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.91247);
              std::_Destroy<Glib::VariantBase*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


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

  D.91252 = __r;
  return D.91252;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::VariantBase; _T2 = Glib::VariantBase] (struct VariantBase * __p, const struct VariantBase & __value)
{
  void * D.90952;
  void * D.90953;
  struct VariantBase * iftmp.11;

  D.90952 = __p;
  D.90953 = operator new (8, D.90952);
  if (D.90953 != 0B) goto <D.91255>; else goto <D.91256>;
  <D.91255>:
  try
    {
      Glib::VariantBase::VariantBase (D.90953, __value);
    }
  catch
    {
      operator delete (D.90953, D.90952);
    }
  iftmp.11 = D.90953;
  goto <D.91257>;
  <D.91256>:
  iftmp.11 = D.90953;
  <D.91257>:
}


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

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


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

  goto <D.90633>;
  <D.90632>:
  D.91259 = std::__addressof<Glib::VariantBase> (__first);
  std::_Destroy<Glib::VariantBase> (D.91259);
  __first = __first + 8;
  <D.90633>:
  if (__first != __last) goto <D.90632>; else goto <D.90630>;
  <D.90630>:
}


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


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


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


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

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


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


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

  if (__p != 0B) goto <D.91262>; else goto <D.91263>;
  <D.91262>:
  D.91264 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::VariantBase> >::deallocate (D.91264, __p, __n);
  goto <D.91265>;
  <D.91263>:
  <D.91265>:
}


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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>] (struct vector * const this)
{
  struct _Vector_base * D.91266;
  struct _Tp_alloc_type & D.91267;
  struct VariantBase * D.91268;
  struct VariantBase * D.91269;

  {
    try
      {
        try
          {
            D.91266 = &this->D.86741;
            D.91267 = std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_get_Tp_allocator (D.91266);
            D.91268 = this->D.86741._M_impl._M_finish;
            D.91269 = this->D.86741._M_impl._M_start;
            std::_Destroy<Glib::VariantBase*, Glib::VariantBase> (D.91269, D.91268, D.91267);
          }
        finally
          {
            D.91266 = &this->D.86741;
            std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::~_Vector_base (D.91266);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.89417>:
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = Glib::VariantBase; _Alloc = std::allocator<Glib::VariantBase>] (struct _Vector_base * const this)
{
  struct VariantBase * D.91272;
  long int D.91273;
  struct VariantBase * D.91274;
  long int D.91275;
  long int D.91276;
  long int D.91277;
  long unsigned int D.91278;
  struct _Vector_impl * D.91279;

  {
    try
      {
        try
          {
            D.91272 = this->_M_impl._M_end_of_storage;
            D.91273 = (long int) D.91272;
            D.91274 = this->_M_impl._M_start;
            D.91275 = (long int) D.91274;
            D.91276 = D.91273 - D.91275;
            D.91277 = D.91276 /[ex] 8;
            D.91278 = (long unsigned int) D.91277;
            D.91274 = this->_M_impl._M_start;
            std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_M_deallocate (this, D.91274, D.91278);
          }
        finally
          {
            D.91279 = &this->_M_impl;
            std::_Vector_base<Glib::VariantBase, std::allocator<Glib::VariantBase> >::_Vector_impl::~_Vector_impl (D.91279);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.90018>:
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


static Glib::VariantContainerBase Glib::VariantContainerBase::create_maybe(const Glib::VariantType&, const Glib::VariantBase&) (const struct VariantType & child_type, const struct VariantBase & child)
{
  const struct GVariant * D.91285;
  const struct GVariantType * D.91286;
  struct GVariant * g_variant;
  struct VariantContainerBase result [value-expr: *<retval>];

  D.91285 = Glib::VariantBase::gobj (child);
  D.91286 = Glib::VariantType::gobj (child_type);
  g_variant = g_variant_new_maybe (D.91286, D.91285);
  Glib::VariantContainerBase::VariantContainerBase (<retval>, g_variant, 0);
  try
    {
      return <retval>;
    }
  catch
    {
      Glib::VariantContainerBase::~VariantContainerBase (<retval>);
    }
}


const GVariantType* Glib::VariantType::gobj() const (const struct VariantType * const this)
{
  const struct GVariantType * D.91289;

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


void Glib::VariantContainerBase::get_child(Glib::VariantBase&, gsize) const (const struct VariantContainerBase * const this, struct VariantBase & child, gsize index)
{
  bool retval.12;
  struct GVariant * D.91292;
  long unsigned int D.91293;
  void * D.86795;
  const struct string D.86791;
  struct allocator D.86790;
  struct GVariant * const gvariant;

  D.91292 = this->D.66789.gobject_;
  D.91293 = g_variant_n_children (D.91292);
  retval.12 = D.91293 <= index;
  if (retval.12 != 0) goto <D.91294>; else goto <D.91295>;
  <D.91294>:
  D.86795 = __cxa_allocate_exception (16);
  try
    {
      std::allocator<char>::allocator (&D.86790);
      try
        {
          std::basic_string<char>::basic_string (&D.86791, "VariantContainerBase::get(): Index out of bounds.", &D.86790);
          try
            {
              std::out_of_range::out_of_range (D.86795, &D.86791);
            }
          finally
            {
              try
                {
                  std::basic_string<char>::~basic_string (&D.86791);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.86791 = {CLOBBER};
            }
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.86790);
            }
          catch
            {
              <<<eh_must_not_throw (terminate)>>>
            }
          D.86790 = {CLOBBER};
        }
    }
  catch
    {
      __cxa_free_exception (D.86795);
    }
  __cxa_throw (D.86795, &_ZTISt12out_of_range, __comp_dtor );
  <D.91295>:
  D.91292 = this->D.66789.gobject_;
  gvariant = g_variant_get_child_value (D.91292, index);
  Glib::VariantBase::init (child, gvariant, 0);
}


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

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

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


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

  try
    {
      {

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


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

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


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

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


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

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

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


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

  try
    {
      {

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


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

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


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.13;
  struct _Rep & D.91319;
  bool D.91320;
  long int D.91321;
  long int D.91322;
  bool retval.14;
  _Atomic_word * D.91326;
  int D.91327;

  D.91319 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.91320 = D.91319 != this;
  D.91321 = (long int) D.91320;
  D.91322 = __builtin_expect (D.91321, 0);
  retval.13 = D.91322 != 0;
  if (retval.13 != 0) goto <D.91323>; else goto <D.91324>;
  <D.91323>:
  D.91326 = &this->D.18966._M_refcount;
  D.91327 = __gnu_cxx::__exchange_and_add_dispatch (D.91326, -1);
  retval.14 = D.91327 <= 0;
  if (retval.14 != 0) goto <D.91328>; else goto <D.91329>;
  <D.91328>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.91330>;
  <D.91329>:
  <D.91330>:
  goto <D.91331>;
  <D.91324>:
  <D.91331>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.15;
  int D.91336;
  _Atomic_word D.91339;

  D.91336 = __gthread_active_p ();
  retval.15 = D.91336 != 0;
  if (retval.15 != 0) goto <D.91337>; else goto <D.91338>;
  <D.91337>:
  D.91339 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.91339;
  <D.91338>:
  D.91339 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.91339;
}


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

  D.91342 = __gthrw___pthread_key_create != 0B;
  D.91341 = (int) D.91342;
  return D.91341;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.91344;
  unsigned int __val.16;
  unsigned int D.91346;

  __val.16 = (unsigned int) __val;
  D.91346 = __atomic_fetch_add_4 (__mem, __val.16, 4);
  D.91344 = (_Atomic_word) D.91346;
  return D.91344;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.91348;
  int D.91349;
  _Atomic_word D.91350;
  _Atomic_word __result;

  __result = *__mem;
  D.91348 = *__mem;
  D.91349 = D.91348 + __val;
  *__mem = D.91349;
  D.91350 = __result;
  return D.91350;
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


static V_CastTo Glib::VariantBase::cast_dynamic(const Glib::VariantBase&) [with V_CastTo = Glib::VariantContainerBase] (const struct VariantBase & v)
{
  bool retval.17;
  const struct GVariant * D.91356;
  bool retval.18;
  struct VariantType D.86812;
  const struct GVariant * D.91362;
  void * D.86824;
  void * D.91363;

  try
    {
      D.91356 = Glib::VariantBase::gobj (v);
      retval.17 = D.91356 == 0B;
      if (retval.17 != 0) goto <D.91357>; else goto <D.91358>;
      <D.91357>:
      Glib::VariantContainerBase::VariantContainerBase (<retval>);
      return <retval>;
      <D.91358>:
      D.86812 = Glib::VariantBase::get_type (v); [return slot optimization]
      try
        {
          retval.18 = Glib::VariantType::is_container (&D.86812);
        }
      finally
        {
          Glib::VariantType::~VariantType (&D.86812);
          D.86812 = {CLOBBER};
        }
      if (retval.18 != 0) goto <D.91360>; else goto <D.91361>;
      <D.91360>:
      D.91362 = Glib::VariantBase::gobj (v);
      Glib::VariantContainerBase::VariantContainerBase (<retval>, D.91362, 1);
      return <retval>;
      <D.91361>:
      D.86824 = __cxa_allocate_exception (8);
      try
        {
          std::bad_cast::bad_cast (D.86824);
        }
      catch
        {
          __cxa_free_exception (D.86824);
        }
      __cxa_throw (D.86824, &_ZTISt8bad_cast, __comp_dtor );
    }
  catch
    {
      <<<eh_filter (struct bad_cast)>>>
        {
          
            D.91363 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91363);
          
        }
    }
}


std::bad_cast::bad_cast() (struct bad_cast * const this)
{
  struct exception * D.91369;
  void * D.91370;

  try
    {
      {
        D.91369 = &this->D.66484;
        std::exception::exception (D.91369);
        try
          {
            this->D.66484._vptr.exception = &MEM[(void *)&_ZTVSt8bad_cast + 16B];
          }
        catch
          {
            D.91369 = &this->D.66484;
            std::exception::~exception (D.91369);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.91370 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91370);
          
        }
    }
}


std::exception::exception() (struct exception * const this)
{
  void * D.91371;

  try
    {
      {
        this->_vptr.exception = &MEM[(void *)&_ZTVSt9exception + 16B];
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.91371 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91371);
          
        }
    }
}


bool Glib::VariantContainerBase::get_maybe(Glib::VariantBase&) const (const struct VariantContainerBase * const this, struct VariantBase & maybe)
{
  const struct VariantBase * D.91372;
  const struct GVariant * D.91373;
  bool D.91376;
  struct GVariant * const g_value;

  D.91372 = &this->D.66789;
  D.91373 = Glib::VariantBase::gobj (D.91372);
  g_value = g_variant_get_maybe (D.91373);
  if (g_value != 0B) goto <D.91374>; else goto <D.91375>;
  <D.91374>:
  Glib::VariantBase::init (maybe, g_value, 0);
  D.91376 = 1;
  return D.91376;
  <D.91375>:
  D.91376 = 0;
  return D.91376;
}


Glib::VariantBase::operator const void*() const (const struct VariantBase * const this)
{
  const void * D.91379;
  const void * iftmp.19;
  const struct GVariant * D.91381;

  D.91381 = Glib::VariantBase::gobj (this);
  if (D.91381 != 0B) goto <D.91382>; else goto <D.91383>;
  <D.91382>:
  iftmp.19 = 1B;
  goto <D.91384>;
  <D.91383>:
  iftmp.19 = 0B;
  <D.91384>:
  D.91379 = iftmp.19;
  return D.91379;
}


void Glib::VariantBase::init(const GVariant*, bool) (struct VariantBase * const this, const struct GVariant * cobject, bool take_a_reference)
{
  struct GVariant * D.91386;

  D.91386 = this->gobject_;
  if (D.91386 != 0B) goto <D.91387>; else goto <D.91388>;
  <D.91387>:
  D.91386 = this->gobject_;
  g_variant_unref (D.91386);
  goto <D.91389>;
  <D.91388>:
  <D.91389>:
  this->gobject_ = cobject;
  if (take_a_reference != 0) goto <D.91390>; else goto <D.91391>;
  <D.91390>:
  D.91386 = this->gobject_;
  g_variant_ref (D.91386);
  goto <D.91392>;
  <D.91391>:
  <D.91392>:
}


Glib::Variant<Glib::VariantBase>::Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.91393;

  D.91393 = &this->D.66837;
  Glib::VariantContainerBase::VariantContainerBase (D.91393);
  try
    {

    }
  catch
    {
      D.91393 = &this->D.66837;
      Glib::VariantContainerBase::~VariantContainerBase (D.91393);
    }
}


Glib::Variant<Glib::VariantBase>::Variant(GVariant*, bool) (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91394;
  struct VariantContainerBase * D.91395;

  D.91394 = (int) take_a_reference;
  D.91395 = &this->D.66837;
  Glib::VariantContainerBase::VariantContainerBase (D.91395, castitem, D.91394);
  try
    {

    }
  catch
    {
      D.91395 = &this->D.66837;
      Glib::VariantContainerBase::~VariantContainerBase (D.91395);
    }
}


static const Glib::VariantType& Glib::Variant<Glib::VariantBase>::variant_type() ()
{
  const struct VariantType & D.91396;

  D.91396 = &VARIANT_TYPE_VARIANT;
  return D.91396;
}


static Glib::Variant<Glib::VariantBase> Glib::Variant<Glib::VariantBase>::create(const Glib::VariantBase&) (const struct VariantBase & data)
{
  const struct GVariant * D.91399;
  struct GVariant * D.91400;
  struct Variant result [value-expr: *<retval>];

  D.91399 = Glib::VariantBase::gobj (data);
  D.91400 = g_variant_new_variant (D.91399);
  Glib::Variant<Glib::VariantBase>::Variant (<retval>, D.91400, 0);
  try
    {
      return <retval>;
    }
  catch
    {
      Glib::Variant<Glib::VariantBase>::~Variant (<retval>);
    }
}


void Glib::Variant<Glib::VariantBase>::get(Glib::VariantBase&) const (const struct Variant * const this, struct VariantBase & variant)
{
  struct GVariant * D.91403;
  struct GVariant * const gvariant;

  D.91403 = this->D.66837.D.66789.gobject_;
  gvariant = g_variant_get_variant (D.91403);
  Glib::VariantBase::init (variant, gvariant, 0);
}


Glib::Variant<Glib::ustring>::Variant() (struct Variant * const this)
{
  struct VariantStringBase * D.91405;

  D.91405 = &this->D.66896;
  Glib::VariantStringBase::VariantStringBase (D.91405);
  try
    {

    }
  catch
    {
      D.91405 = &this->D.66896;
      Glib::VariantStringBase::~VariantStringBase (D.91405);
    }
}


Glib::Variant<Glib::ustring>::Variant(GVariant*, bool) (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91406;
  struct VariantStringBase * D.91407;

  D.91406 = (int) take_a_reference;
  D.91407 = &this->D.66896;
  Glib::VariantStringBase::VariantStringBase (D.91407, castitem, D.91406);
  try
    {

    }
  catch
    {
      D.91407 = &this->D.66896;
      Glib::VariantStringBase::~VariantStringBase (D.91407);
    }
}


static const Glib::VariantType& Glib::Variant<Glib::ustring>::variant_type() ()
{
  const struct VariantType & D.91408;

  D.91408 = &VARIANT_TYPE_STRING;
  return D.91408;
}


static Glib::Variant<Glib::ustring> Glib::Variant<Glib::ustring>::create(const Glib::ustring&) (const struct ustring & data)
{
  const char * D.91411;
  struct GVariant * D.91412;
  struct Variant result [value-expr: *<retval>];

  D.91411 = Glib::ustring::c_str (data);
  D.91412 = g_variant_new_string (D.91411);
  Glib::Variant<Glib::ustring>::Variant (<retval>, D.91412, 0);
  try
    {
      return <retval>;
    }
  catch
    {
      Glib::Variant<Glib::ustring>::~Variant (<retval>);
    }
}


Glib::ustring Glib::Variant<Glib::ustring>::get() const (const struct Variant * const this)
{
  struct GVariant * D.91417;
  const gchar * D.91418;

  D.91417 = this->D.66896.D.66743.gobject_;
  D.91418 = g_variant_get_string (D.91417, 0B);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.91418); [return slot optimization]
  return <retval>;
}


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

  if (str != 0B) goto <D.91422>; else goto <D.91423>;
  <D.91422>:
  D.91424 = <retval>;
  Glib::ustring::ustring (D.91424, str);
  goto <D.91425>;
  <D.91423>:
  D.91424 = <retval>;
  Glib::ustring::ustring (D.91424);
  <D.91425>:
  return <retval>;
}


static V_CastTo Glib::VariantBase::cast_dynamic(const Glib::VariantBase&) [with V_CastTo = Glib::Variant<Glib::ustring>] (const struct VariantBase & v)
{
  bool retval.20;
  const struct GVariant * D.91429;
  bool retval.21;
  bool iftmp.22;
  bool D.91437;
  bool D.91439;
  bool D.91441;
  const struct GVariant * D.91444;
  void * D.86978;
  void * D.91445;

  try
    {
      {
        const struct VariantType vtype;

        try
          {
            D.91429 = Glib::VariantBase::gobj (v);
            retval.20 = D.91429 == 0B;
            if (retval.20 != 0) goto <D.91430>; else goto <D.91431>;
            <D.91430>:
            Glib::Variant<Glib::ustring>::Variant (<retval>);
            return <retval>;
            <D.91431>:
            vtype = Glib::VariantBase::get_type (v); [return slot optimization]
            try
              {
                D.91437 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_STRING);
                if (D.91437 != 0) goto <D.91434>; else goto <D.91438>;
                <D.91438>:
                D.91439 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_OBJECT_PATH);
                if (D.91439 != 0) goto <D.91434>; else goto <D.91440>;
                <D.91440>:
                D.91441 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_SIGNATURE);
                if (D.91441 != 0) goto <D.91434>; else goto <D.91435>;
                <D.91434>:
                iftmp.22 = 1;
                goto <D.91436>;
                <D.91435>:
                iftmp.22 = 0;
                <D.91436>:
                retval.21 = iftmp.22;
                if (retval.21 != 0) goto <D.91442>; else goto <D.91443>;
                <D.91442>:
                D.91444 = Glib::VariantBase::gobj (v);
                Glib::Variant<Glib::ustring>::Variant (<retval>, D.91444, 1);
                return <retval>;
                <D.91443>:
                D.86978 = __cxa_allocate_exception (8);
                try
                  {
                    std::bad_cast::bad_cast (D.86978);
                  }
                catch
                  {
                    __cxa_free_exception (D.86978);
                  }
                __cxa_throw (D.86978, &_ZTISt8bad_cast, __comp_dtor );
              }
            finally
              {
                Glib::VariantType::~VariantType (&vtype);
              }
          }
        finally
          {
            vtype = {CLOBBER};
          }
      }
    }
  catch
    {
      <<<eh_filter (struct bad_cast)>>>
        {
          
            D.91445 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91445);
          
        }
    }
}


Glib::Variant<std::basic_string<char> >::Variant() (struct Variant * const this)
{
  struct VariantStringBase * D.91456;

  D.91456 = &this->D.66932;
  Glib::VariantStringBase::VariantStringBase (D.91456);
  try
    {

    }
  catch
    {
      D.91456 = &this->D.66932;
      Glib::VariantStringBase::~VariantStringBase (D.91456);
    }
}


Glib::Variant<std::basic_string<char> >::Variant(GVariant*, bool) (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91457;
  struct VariantStringBase * D.91458;

  D.91457 = (int) take_a_reference;
  D.91458 = &this->D.66932;
  Glib::VariantStringBase::VariantStringBase (D.91458, castitem, D.91457);
  try
    {

    }
  catch
    {
      D.91458 = &this->D.66932;
      Glib::VariantStringBase::~VariantStringBase (D.91458);
    }
}


static const Glib::VariantType& Glib::Variant<std::basic_string<char> >::variant_type() ()
{
  const struct VariantType & D.91459;

  D.91459 = &VARIANT_TYPE_BYTESTRING;
  return D.91459;
}


static Glib::Variant<std::basic_string<char> > Glib::Variant<std::basic_string<char> >::create(const string&) (const struct string & data)
{
  const char * D.91462;
  struct GVariant * D.91463;
  struct Variant result [value-expr: *<retval>];

  D.91462 = std::basic_string<char>::c_str (data);
  D.91463 = g_variant_new_bytestring (D.91462);
  Glib::Variant<std::basic_string<char> >::Variant (<retval>, D.91463, 0);
  try
    {
      return <retval>;
    }
  catch
    {
      Glib::Variant<std::basic_string<char> >::~Variant (<retval>);
    }
}


static V_CastTo Glib::VariantBase::cast_dynamic(const Glib::VariantBase&) [with V_CastTo = Glib::Variant<std::basic_string<char> >] (const struct VariantBase & v)
{
  bool retval.23;
  const struct GVariant * D.91469;
  bool retval.24;
  bool iftmp.25;
  bool D.91477;
  bool D.91479;
  bool D.91481;
  bool D.91483;
  const struct GVariant * D.91486;
  void * D.87038;
  void * D.91487;

  try
    {
      {
        const struct VariantType vtype;

        try
          {
            D.91469 = Glib::VariantBase::gobj (v);
            retval.23 = D.91469 == 0B;
            if (retval.23 != 0) goto <D.91470>; else goto <D.91471>;
            <D.91470>:
            Glib::Variant<std::basic_string<char> >::Variant (<retval>);
            return <retval>;
            <D.91471>:
            vtype = Glib::VariantBase::get_type (v); [return slot optimization]
            try
              {
                D.91477 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_STRING);
                if (D.91477 != 0) goto <D.91474>; else goto <D.91478>;
                <D.91478>:
                D.91479 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_BYTESTRING);
                if (D.91479 != 0) goto <D.91474>; else goto <D.91480>;
                <D.91480>:
                D.91481 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_OBJECT_PATH);
                if (D.91481 != 0) goto <D.91474>; else goto <D.91482>;
                <D.91482>:
                D.91483 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_SIGNATURE);
                if (D.91483 != 0) goto <D.91474>; else goto <D.91475>;
                <D.91474>:
                iftmp.25 = 1;
                goto <D.91476>;
                <D.91475>:
                iftmp.25 = 0;
                <D.91476>:
                retval.24 = iftmp.25;
                if (retval.24 != 0) goto <D.91484>; else goto <D.91485>;
                <D.91484>:
                D.91486 = Glib::VariantBase::gobj (v);
                Glib::Variant<std::basic_string<char> >::Variant (<retval>, D.91486, 1);
                return <retval>;
                <D.91485>:
                D.87038 = __cxa_allocate_exception (8);
                try
                  {
                    std::bad_cast::bad_cast (D.87038);
                  }
                catch
                  {
                    __cxa_free_exception (D.87038);
                  }
                __cxa_throw (D.87038, &_ZTISt8bad_cast, __comp_dtor );
              }
            finally
              {
                Glib::VariantType::~VariantType (&vtype);
              }
          }
        finally
          {
            vtype = {CLOBBER};
          }
      }
    }
  catch
    {
      <<<eh_filter (struct bad_cast)>>>
        {
          
            D.91487 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91487);
          
        }
    }
}


std::string Glib::Variant<std::basic_string<char> >::get() const (const struct Variant * const this)
{
  const struct VariantBase * D.91500;
  bool retval.26;
  struct GVariant * D.91504;
  const struct VariantType vtype;
  const char * pch;

  try
    {
      D.91500 = &this->D.66932.D.66743;
      vtype = Glib::VariantBase::get_type (D.91500); [return slot optimization]
      try
        {
          pch = 0B;
          retval.26 = Glib::VariantType::equal (&vtype, &VARIANT_TYPE_BYTESTRING);
          if (retval.26 != 0) goto <D.91502>; else goto <D.91503>;
          <D.91502>:
          D.91504 = this->D.66932.D.66743.gobject_;
          pch = g_variant_get_bytestring (D.91504);
          goto <D.91505>;
          <D.91503>:
          D.91504 = this->D.66932.D.66743.gobject_;
          pch = g_variant_get_string (D.91504, 0B);
          <D.91505>:
          *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (pch); [return slot optimization]
          return <retval>;
        }
      finally
        {
          Glib::VariantType::~VariantType (&vtype);
        }
    }
  finally
    {
      vtype = {CLOBBER};
    }
}


std::string Glib::convert_const_gchar_ptr_to_stdstring(const char*) (const char * str)
{
  struct allocator D.78923;
  bool cleanup.27;
  struct string * D.91520;

  cleanup.27 = 0;
  try
    {
      if (str != 0B) goto <D.91515>; else goto <D.91516>;
      <D.91515>:
      std::allocator<char>::allocator (&D.78923);
      cleanup.27 = 1;
      D.91520 = <retval>;
      std::basic_string<char>::basic_string (D.91520, str, &D.78923);
      goto <D.91521>;
      <D.91516>:
      D.91520 = <retval>;
      std::basic_string<char>::basic_string (D.91520);
      <D.91521>:
      return <retval>;
    }
  finally
    {
      if (cleanup.27 != 0) goto <D.91518>; else goto <D.91519>;
      <D.91518>:
      std::allocator<char>::~allocator (&D.78923);
      D.78923 = {CLOBBER};
      <D.91519>:
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator D.89326;
  struct _Rep & D.91527;
  char * D.91528;
  struct _Alloc_hider * D.91529;

  std::allocator<char>::allocator (&D.89326);
  try
    {
      D.91527 = std::basic_string<char>::_S_empty_rep ();
      D.91528 = std::basic_string<char>::_Rep::_M_refdata (D.91527);
      D.91529 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.91529, D.91528, &D.89326);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.89326);
      D.89326 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


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


Glib::Variant<std::vector<Glib::ustring> >::Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.91538;

  D.91538 = &this->D.67036;
  Glib::VariantContainerBase::VariantContainerBase (D.91538);
  try
    {

    }
  catch
    {
      D.91538 = &this->D.67036;
      Glib::VariantContainerBase::~VariantContainerBase (D.91538);
    }
}


Glib::Variant<std::vector<Glib::ustring> >::Variant(GVariant*, bool) (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91539;
  struct VariantContainerBase * D.91540;

  D.91539 = (int) take_a_reference;
  D.91540 = &this->D.67036;
  Glib::VariantContainerBase::VariantContainerBase (D.91540, castitem, D.91539);
  try
    {

    }
  catch
    {
      D.91540 = &this->D.67036;
      Glib::VariantContainerBase::~VariantContainerBase (D.91540);
    }
}


static const Glib::VariantType& Glib::Variant<std::vector<Glib::ustring> >::variant_type() ()
{
  const struct VariantType & D.91541;

  D.91541 = &VARIANT_TYPE_STRING_ARRAY;
  return D.91541;
}


static Glib::Variant<std::vector<Glib::ustring> > Glib::Variant<std::vector<Glib::ustring> >::create(const type_vec_ustring&) (const struct type_vec_ustring & data)
{
  const struct VariantType & D.91544;
  const struct VariantType & D.91545;
  struct GVariantType * D.91546;
  const struct ustring * D.91547;
  const char * D.91548;
  struct string D.87945;
  const char * D.91549;
  struct __normal_iterator D.87944;
  bool retval.28;
  struct const_iterator D.87937;
  struct string D.87947;
  const char * D.91551;
  struct GVariant * D.91552;
  struct VariantType element_variant_type;
  struct VariantType array_variant_type;
  struct GVariantBuilder * builder;
  struct Variant result [value-expr: *<retval>];

  try
    {
      D.91544 = Glib::Variant<Glib::ustring>::variant_type ();
      Glib::VariantType::VariantType (&element_variant_type, D.91544);
      try
        {
          D.91545 = Glib::Variant<std::vector<Glib::ustring> >::variant_type ();
          Glib::VariantType::VariantType (&array_variant_type, D.91545);
          try
            {
              D.91546 = Glib::VariantType::gobj (&array_variant_type);
              builder = g_variant_builder_new (D.91546);
              {
                struct const_iterator iter;

                try
                  {
                    iter = std::vector<Glib::ustring>::begin (data);
                    goto <D.87972>;
                    <D.87971>:
                    D.91547 = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::operator-> (&iter);
                    D.91548 = Glib::ustring::c_str (D.91547);
                    D.87945 = Glib::VariantType::get_string (&element_variant_type); [return slot optimization]
                    try
                      {
                        D.91549 = std::basic_string<char>::c_str (&D.87945);
                        g_variant_builder_add (builder, D.91549, D.91548);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.87945);
                        D.87945 = {CLOBBER};
                      }
                    D.87944 = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::operator++ (&iter, 0);
                    <D.87972>:
                    D.87937 = std::vector<Glib::ustring>::end (data);
                    try
                      {
                        retval.28 = __gnu_cxx::operator< <const Glib::ustring*, std::vector<Glib::ustring> > (&iter, &D.87937);
                      }
                    finally
                      {
                        D.87937 = {CLOBBER};
                      }
                    if (retval.28 != 0) goto <D.87971>; else goto <D.87969>;
                    <D.87969>:
                  }
                finally
                  {
                    iter = {CLOBBER};
                  }
              }
              D.87947 = Glib::VariantType::get_string (&array_variant_type); [return slot optimization]
              try
                {
                  D.91551 = std::basic_string<char>::c_str (&D.87947);
                  D.91552 = g_variant_new (D.91551, builder);
                  Glib::Variant<std::vector<Glib::ustring> >::Variant (<retval>, D.91552, 0);
                }
              finally
                {
                  try
                    {
                      std::basic_string<char>::~basic_string (&D.87947);
                    }
                  catch
                    {
                      Glib::Variant<std::vector<Glib::ustring> >::~Variant (<retval>);
                    }
                  D.87947 = {CLOBBER};
                }
              try
                {
                  g_variant_builder_unref (builder);
                  return <retval>;
                }
              catch
                {
                  Glib::Variant<std::vector<Glib::ustring> >::~Variant (<retval>);
                }
            }
          finally
            {
              Glib::VariantType::~VariantType (&array_variant_type);
            }
        }
      finally
        {
          Glib::VariantType::~VariantType (&element_variant_type);
        }
    }
  finally
    {
      element_variant_type = {CLOBBER};
      array_variant_type = {CLOBBER};
    }
}


GVariantType* Glib::VariantType::gobj() (struct VariantType * const this)
{
  struct GVariantType * D.91572;

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


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::begin() const [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::ustring*] (const struct vector * const this)
{
  struct const_iterator D.91574;
  struct const_iterator D.89549;
  const struct ustring * const D.89548;
  struct ustring * D.91575;

  D.91575 = this->D.87822._M_impl._M_start;
  D.89548 = D.91575;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::__normal_iterator (&D.89549, &D.89548);
      try
        {
          D.91574 = D.89549;
          return D.91574;
        }
      finally
        {
          D.89549 = {CLOBBER};
        }
    }
  finally
    {
      D.89548 = {CLOBBER};
    }
}


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

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


__gnu_cxx::__normal_iterator<_Iterator, _Container>::pointer __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator->() const [with _Iterator = const Glib::ustring*; _Container = std::vector<Glib::ustring>; __gnu_cxx::__normal_iterator<_Iterator, _Container>::pointer = const Glib::ustring*] (const struct __normal_iterator * const this)
{
  const struct ustring * D.91580;

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


__gnu_cxx::__normal_iterator<_Iterator, _Container> __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++(int) [with _Iterator = const Glib::ustring*; _Container = std::vector<Glib::ustring>] (struct __normal_iterator * const this, int D.87876)
{
  struct __normal_iterator D.91582;
  struct __normal_iterator D.89556;
  const struct ustring * const D.89555;
  const struct ustring * D.91583;
  const struct ustring * D.91584;
  const struct ustring * D.91585;

  D.91583 = this->_M_current;
  D.91584 = D.91583;
  D.91585 = D.91584 + 8;
  this->_M_current = D.91585;
  D.89555 = D.91584;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::__normal_iterator (&D.89556, &D.89555);
      try
        {
          D.91582 = D.89556;
          return D.91582;
        }
      finally
        {
          D.89556 = {CLOBBER};
        }
    }
  finally
    {
      D.89555 = {CLOBBER};
    }
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::end() const [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const Glib::ustring*] (const struct vector * const this)
{
  struct const_iterator D.91589;
  struct const_iterator D.89552;
  const struct ustring * const D.89551;
  struct ustring * D.91590;

  D.91590 = this->D.87822._M_impl._M_finish;
  D.89551 = D.91590;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::__normal_iterator (&D.89552, &D.89551);
      try
        {
          D.91589 = D.89552;
          return D.91589;
        }
      finally
        {
          D.89552 = {CLOBBER};
        }
    }
  finally
    {
      D.89551 = {CLOBBER};
    }
}


bool __gnu_cxx::operator<(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = const Glib::ustring*; _Container = std::vector<Glib::ustring>] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  bool D.91594;
  const struct ustring * const & D.91595;
  const struct ustring * D.91596;
  const struct ustring * const & D.91597;
  const struct ustring * D.91598;

  D.91595 = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::base (__lhs);
  D.91596 = *D.91595;
  D.91597 = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::base (__rhs);
  D.91598 = *D.91597;
  D.91594 = D.91596 < D.91598;
  return D.91594;
}


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

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


Glib::Variant<std::vector<Glib::ustring> >::~Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.91602;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.91602 = &this->D.67036;
            Glib::VariantContainerBase::~VariantContainerBase (D.91602);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87962>:
}


Glib::VariantContainerBase::~VariantContainerBase() (struct VariantContainerBase * const this)
{
  struct VariantBase * D.91604;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.91604 = &this->D.66789;
            Glib::VariantBase::~VariantBase (D.91604);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.75071>:
}


Glib::ustring Glib::Variant<std::vector<Glib::ustring> >::get_child(gsize) const (const struct Variant * const this, gsize index)
{
  const struct VariantBase * D.91607;
  const struct GVariant * D.91608;
  long unsigned int n_elements.29;
  void * D.87983;
  const struct string D.87981;
  struct allocator D.87980;
  long unsigned int D.91612;
  const gchar * * D.91613;
  const gchar * D.91614;
  gsize n_elements;
  const gchar * * array;
  const struct ustring result [value-expr: *<retval>];

  try
    {
      n_elements = 0;
      D.91607 = &this->D.67036.D.66789;
      D.91608 = Glib::VariantBase::gobj (D.91607);
      array = g_variant_get_strv (D.91608, &n_elements);
      n_elements.29 = n_elements;
      if (index >= n_elements.29) goto <D.91610>; else goto <D.91611>;
      <D.91610>:
      D.87983 = __cxa_allocate_exception (16);
      try
        {
          std::allocator<char>::allocator (&D.87980);
          try
            {
              std::basic_string<char>::basic_string (&D.87981, "Variant< std::vector<Glib::ustring> >::get(): Index out of bounds.", &D.87980);
              try
                {
                  std::out_of_range::out_of_range (D.87983, &D.87981);
                }
              finally
                {
                  try
                    {
                      std::basic_string<char>::~basic_string (&D.87981);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.87981 = {CLOBBER};
                }
            }
          finally
            {
              try
                {
                  std::allocator<char>::~allocator (&D.87980);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.87980 = {CLOBBER};
            }
        }
      catch
        {
          __cxa_free_exception (D.87983);
        }
      __cxa_throw (D.87983, &_ZTISt12out_of_range, __comp_dtor );
      <D.91611>:
      D.91612 = index * 8;
      D.91613 = array + D.91612;
      D.91614 = *D.91613;
      Glib::ustring::ustring (<retval>, D.91614);
      try
        {
          g_free (array);
          return <retval>;
        }
      catch
        {
          Glib::ustring::~ustring (<retval>);
        }
    }
  finally
    {
      n_elements = {CLOBBER};
    }
}


Glib::type_vec_ustring Glib::Variant<std::vector<Glib::ustring> >::get() const (const struct Variant * const this)
{
  const struct VariantBase * D.91624;
  const struct GVariant * D.91625;
  struct allocator_type D.88008;
  long unsigned int n_elements.30;
  long unsigned int D.91627;
  const gchar * * D.91628;
  gsize n_elements;
  const gchar * * array;
  const struct type_vec_ustring result [value-expr: *<retval>];

  try
    {
      n_elements = 0;
      D.91624 = &this->D.67036.D.66789;
      D.91625 = Glib::VariantBase::gobj (D.91624);
      array = g_variant_get_strv (D.91625, &n_elements);
      std::allocator<Glib::ustring>::allocator (&D.88008);
      try
        {
          n_elements.30 = n_elements;
          D.91627 = n_elements.30 * 8;
          D.91628 = array + D.91627;
          std::vector<Glib::ustring>::vector<const char**> (<retval>, array, D.91628, &D.88008);
        }
      finally
        {
          try
            {
              std::allocator<Glib::ustring>::~allocator (&D.88008);
            }
          catch
            {
              std::vector<Glib::ustring>::~vector (<retval>);
            }
          D.88008 = {CLOBBER};
        }
      try
        {
          g_free (array);
          return <retval>;
        }
      catch
        {
          std::vector<Glib::ustring>::~vector (<retval>);
        }
    }
  finally
    {
      n_elements = {CLOBBER};
    }
}


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

  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.91635 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91635);
          
        }
    }
}


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

  try
    {
      {

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


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = const char**; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<Glib::ustring>] (struct vector * const this, const char * * __first, const char * * __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.91637;
  struct _Integral D.89659;
  struct __false_type D.91638;

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

        try
          {
            std::vector<Glib::ustring>::_M_initialize_dispatch<const char**> (this, __first, __last, D.91638);
          }
        finally
          {
            D.89659 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.91637 = &this->D.87822;
      std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.91637);
    }
}


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

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

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


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

  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.91642 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.91642);
          
        }
    }
}


__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.87162)
{
  void * D.91643;

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = const char**; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, const char * * __first, const char * * __last, struct __false_type D.89617)
{
  struct forward_iterator_tag D.90121;
  struct _IterCategory D.90095;
  struct _IterCategory * D.91644;
  struct forward_iterator_tag D.91645;
  typedef struct _IterCategory _IterCategory;

  try
    {
      D.91644 = &D.90095;
      std::vector<Glib::ustring>::_M_range_initialize<const char**> (this, __first, __last, D.91645);
    }
  finally
    {
      D.90095 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = const char**; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, const char * * __first, const char * * __last, struct forward_iterator_tag D.90100)
{
  long int D.91647;
  struct _Vector_base * D.91648;
  struct ustring * D.91649;
  struct ustring * D.91650;
  long unsigned int D.91651;
  struct ustring * D.91652;
  struct _Tp_alloc_type & D.91653;
  struct ustring * D.91654;
  const size_type __n;

  D.91647 = std::distance<const char**> (__first, __last);
  __n = (const size_type) D.91647;
  D.91648 = &this->D.87822;
  D.91649 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_allocate (D.91648, __n);
  this->D.87822._M_impl._M_start = D.91649;
  D.91650 = this->D.87822._M_impl._M_start;
  D.91651 = __n * 8;
  D.91652 = D.91650 + D.91651;
  this->D.87822._M_impl._M_end_of_storage = D.91652;
  D.91648 = &this->D.87822;
  D.91653 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.91648);
  D.91650 = this->D.87822._M_impl._M_start;
  D.91654 = std::__uninitialized_copy_a<const char**, Glib::ustring*, Glib::ustring> (__first, __last, D.91650, D.91653);
  this->D.87822._M_impl._M_finish = D.91654;
}


typename std::iterator_traits<_Iterator>::difference_type std::distance(_InputIterator, _InputIterator) [with _InputIterator = const char**; typename std::iterator_traits<_Iterator>::difference_type = long int] (const char * * __first, const char * * __last)
{
  difference_type D.91658;
  struct iterator_category D.90678;
  struct random_access_iterator_tag D.91659;
  const char * * __first.31;

  std::__iterator_category<const char**> (&__first);
  try
    {
      __first.31 = __first;
      D.91658 = std::__distance<const char**> (__first.31, __last, D.91659);
      return D.91658;
    }
  finally
    {
      D.90678 = {CLOBBER};
    }
}


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

  return D.91663;
}


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

  __last.32 = (long int) __last;
  __first.33 = (long int) __first;
  D.91668 = __last.32 - __first.33;
  D.91665 = D.91668 /[ex] 8;
  return D.91665;
}


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.91670;
  struct ustring * iftmp.34;
  struct _Vector_impl * D.91674;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.91672>; else goto <D.91673>;
  <D.91672>:
  D.91674 = &this->_M_impl;
  iftmp.34 = __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::allocate (D.91674, __n);
  goto <D.91675>;
  <D.91673>:
  iftmp.34 = 0B;
  <D.91675>:
  D.91670 = iftmp.34;
  return D.91670;
}


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

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


_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.87135)
{
  bool retval.35;
  long unsigned int D.91682;
  struct ustring * D.91685;
  long unsigned int D.91686;

  D.91682 = __gnu_cxx::new_allocator<Glib::ustring>::max_size (this);
  retval.35 = D.91682 < __n;
  if (retval.35 != 0) goto <D.91683>; else goto <D.91684>;
  <D.91683>:
  std::__throw_bad_alloc ();
  <D.91684>:
  D.91686 = __n * 8;
  D.91685 = operator new (D.91686);
  return D.91685;
}


__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.91689;
  void * D.91690;

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


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

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


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

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


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

  __assignable = 1;
  D.91697 = std::__uninitialized_copy<false>::__uninit_copy<const char**, Glib::ustring*> (__first, __last, __result);
  return D.91697;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = const char**; _ForwardIterator = Glib::ustring*; bool _TrivialValueTypes = false] (const char * * __first, const char * * __last, struct ustring * __result)
{
  struct ustring * D.91700;
  struct ustring * D.91701;
  void * D.91702;
  struct ustring * __cur;

  __cur = __result;
  try
    {
      goto <D.90927>;
      <D.90926>:
      D.91700 = std::__addressof<Glib::ustring> (__cur);
      std::_Construct<Glib::ustring, const char*> (D.91700, __first);
      __first = __first + 8;
      __cur = __cur + 8;
      <D.90927>:
      if (__first != __last) goto <D.90926>; else goto <D.90924>;
      <D.90924>:
      D.91701 = __cur;
      return D.91701;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.91702 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.91702);
              std::_Destroy<Glib::ustring*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


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

  D.91707 = __r;
  return D.91707;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = Glib::ustring; _T2 = const char*] (struct ustring * __p, const char * const & __value)
{
  void * D.90956;
  void * D.90957;
  struct ustring * iftmp.36;
  const char * D.91712;

  D.90956 = __p;
  D.90957 = operator new (8, D.90956);
  if (D.90957 != 0B) goto <D.91710>; else goto <D.91711>;
  <D.91710>:
  try
    {
      D.91712 = *__value;
      Glib::ustring::ustring (D.90957, D.91712);
    }
  catch
    {
      operator delete (D.90957, D.90956);
    }
  iftmp.36 = D.90957;
  goto <D.91713>;
  <D.91711>:
  iftmp.36 = D.90957;
  <D.91713>:
}


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

  goto <D.90717>;
  <D.90716>:
  D.91715 = std::__addressof<Glib::ustring> (__first);
  std::_Destroy<Glib::ustring> (D.91715);
  __first = __first + 8;
  <D.90717>:
  if (__first != __last) goto <D.90716>; else goto <D.90714>;
  <D.90714>:
}


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.91716;
  long int D.91717;
  struct ustring * D.91718;
  long int D.91719;
  long int D.91720;
  long int D.91721;
  long unsigned int D.91722;
  struct _Vector_impl * D.91723;

  {
    try
      {
        try
          {
            D.91716 = this->_M_impl._M_end_of_storage;
            D.91717 = (long int) D.91716;
            D.91718 = this->_M_impl._M_start;
            D.91719 = (long int) D.91718;
            D.91720 = D.91717 - D.91719;
            D.91721 = D.91720 /[ex] 8;
            D.91722 = (long unsigned int) D.91721;
            D.91718 = this->_M_impl._M_start;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_deallocate (this, D.91718, D.91722);
          }
        finally
          {
            D.91723 = &this->_M_impl;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.91723);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.90082>:
}


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

  if (__p != 0B) goto <D.91726>; else goto <D.91727>;
  <D.91726>:
  D.91728 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::deallocate (D.91728, __p, __n);
  goto <D.91729>;
  <D.91727>:
  <D.91729>:
}


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.87139)
{
  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.90073>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this)
{
  struct _Vector_base * D.91732;
  struct _Tp_alloc_type & D.91733;
  struct ustring * D.91734;
  struct ustring * D.91735;

  {
    try
      {
        try
          {
            D.91732 = &this->D.87822;
            D.91733 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.91732);
            D.91734 = this->D.87822._M_impl._M_finish;
            D.91735 = this->D.87822._M_impl._M_start;
            std::_Destroy<Glib::ustring*, Glib::ustring> (D.91735, D.91734, D.91733);
          }
        finally
          {
            D.91732 = &this->D.87822;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.91732);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.89673>:
}


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


Glib::VariantIter Glib::Variant<std::vector<Glib::ustring> >::get_iter() const (const struct Variant * const this)
{
  const struct VariantType & D.91739;
  const struct VariantType & D.91740;
  struct string D.88018;
  const char * D.91741;
  const struct VariantBase * D.91742;
  const struct GVariant * D.91743;
  struct GVariantIter * g_iter.37;
  struct VariantType element_variant_type;
  struct VariantType array_variant_type;
  struct GVariantIter * g_iter;

  try
    {
      D.91739 = Glib::Variant<Glib::ustring>::variant_type ();
      Glib::VariantType::VariantType (&element_variant_type, D.91739);
      try
        {
          D.91740 = Glib::Variant<std::vector<Glib::ustring> >::variant_type ();
          Glib::VariantType::VariantType (&array_variant_type, D.91740);
          try
            {
              g_iter = 0B;
              D.88018 = Glib::VariantType::get_string (&array_variant_type); [return slot optimization]
              try
                {
                  D.91741 = std::basic_string<char>::c_str (&D.88018);
                  D.91742 = &this->D.67036.D.66789;
                  D.91743 = Glib::VariantBase::gobj (D.91742);
                  g_variant_get (D.91743, D.91741, &g_iter);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.88018);
                  D.88018 = {CLOBBER};
                }
              g_iter.37 = g_iter;
              Glib::VariantIter::VariantIter (<retval>, g_iter.37, 0);
              return <retval>;
            }
          finally
            {
              Glib::VariantType::~VariantType (&array_variant_type);
            }
        }
      finally
        {
          Glib::VariantType::~VariantType (&element_variant_type);
        }
    }
  finally
    {
      element_variant_type = {CLOBBER};
      array_variant_type = {CLOBBER};
      g_iter = {CLOBBER};
    }
}


Glib::Variant<std::vector<std::basic_string<char> > >::Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.91754;

  D.91754 = &this->D.67074;
  Glib::VariantContainerBase::VariantContainerBase (D.91754);
  try
    {

    }
  catch
    {
      D.91754 = &this->D.67074;
      Glib::VariantContainerBase::~VariantContainerBase (D.91754);
    }
}


Glib::Variant<std::vector<std::basic_string<char> > >::Variant(GVariant*, bool) (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.91755;
  struct VariantContainerBase * D.91756;

  D.91755 = (int) take_a_reference;
  D.91756 = &this->D.67074;
  Glib::VariantContainerBase::VariantContainerBase (D.91756, castitem, D.91755);
  try
    {

    }
  catch
    {
      D.91756 = &this->D.67074;
      Glib::VariantContainerBase::~VariantContainerBase (D.91756);
    }
}


static const Glib::VariantType& Glib::Variant<std::vector<std::basic_string<char> > >::variant_type() ()
{
  const struct VariantType & D.91757;

  D.91757 = &VARIANT_TYPE_BYTESTRING_ARRAY;
  return D.91757;
}


static Glib::Variant<std::vector<std::basic_string<char> > > Glib::Variant<std::vector<std::basic_string<char> > >::create(const type_vec_string&) (const struct type_vec_string & data)
{
  long unsigned int D.91760;
  int D.91767;
  long unsigned int D.91770;
  long unsigned int D.91771;
  long unsigned int D.91772;
  char * * D.91773;
  const struct basic_string & D.91774;
  const char * D.91775;
  gchar * D.91776;
  bool retval.38;
  long unsigned int D.91778;
  long unsigned int D.91779;
  long unsigned int D.91780;
  char * * D.91781;
  long unsigned int D.91782;
  long int D.91783;
  struct GVariant * D.91784;
  char * * str_array;
  struct Variant result [value-expr: *<retval>];

  {
    gsize __n;
    gsize __s;
    void * __p;

    D.91760 = std::vector<std::basic_string<char> >::size (data);
    __n = D.91760 + 1;
    __s = 8;
    if (__s == 1) goto <D.91761>; else goto <D.91762>;
    <D.91761>:
    __p = g_malloc (__n);
    goto <D.91763>;
    <D.91762>:
    D.91767 = __builtin_constant_p (__n);
    if (D.91767 != 0) goto <D.91768>; else goto <D.91764>;
    <D.91768>:
    if (__s == 0) goto <D.91765>; else goto <D.91769>;
    <D.91769>:
    D.91770 = 18446744073709551615 / __s;
    if (D.91770 >= __n) goto <D.91765>; else goto <D.91764>;
    <D.91765>:
    D.91771 = __n * __s;
    __p = g_malloc (D.91771);
    goto <D.91766>;
    <D.91764>:
    __p = g_malloc_n (__n, __s);
    <D.91766>:
    <D.91763>:
    str_array = __p;
  }
  {
    size_type i;

    i = 0;
    goto <D.88823>;
    <D.88822>:
    D.91772 = i * 8;
    D.91773 = str_array + D.91772;
    D.91774 = std::vector<std::basic_string<char> >::operator[] (data, i);
    D.91775 = std::basic_string<char>::c_str (D.91774);
    D.91776 = g_strdup (D.91775);
    *D.91773 = D.91776;
    i = i + 1;
    <D.88823>:
    D.91778 = std::vector<std::basic_string<char> >::size (data);
    retval.38 = D.91778 > i;
    if (retval.38 != 0) goto <D.88822>; else goto <D.88820>;
    <D.88820>:
  }
  D.91779 = std::vector<std::basic_string<char> >::size (data);
  D.91780 = D.91779 * 8;
  D.91781 = str_array + D.91780;
  *D.91781 = 0B;
  D.91782 = std::vector<std::basic_string<char> >::size (data);
  D.91783 = (long int) D.91782;
  D.91784 = g_variant_new_bytestring_array (str_array, D.91783);
  Glib::Variant<std::vector<std::basic_string<char> > >::Variant (<retval>, D.91784, 0);
  try
    {
      g_strfreev (str_array);
      return <retval>;
    }
  catch
    {
      Glib::Variant<std::vector<std::basic_string<char> > >::~Variant (<retval>);
    }
}


std::vector<_Tp, _Alloc>::const_reference std::vector<_Tp, _Alloc>::operator[](std::vector<_Tp, _Alloc>::size_type) const [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::vector<_Tp, _Alloc>::const_reference = const std::basic_string<char>&; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n)
{
  const struct basic_string & D.91793;
  struct basic_string * D.91794;
  long unsigned int D.91795;

  D.91794 = this->D.88793._M_impl._M_start;
  D.91795 = __n * 8;
  D.91793 = D.91794 + D.91795;
  return D.91793;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.91797;
  struct basic_string * D.91798;
  long int D.91799;
  struct basic_string * D.91800;
  long int D.91801;
  long int D.91802;
  long int D.91803;

  D.91798 = this->D.88793._M_impl._M_finish;
  D.91799 = (long int) D.91798;
  D.91800 = this->D.88793._M_impl._M_start;
  D.91801 = (long int) D.91800;
  D.91802 = D.91799 - D.91801;
  D.91803 = D.91802 /[ex] 8;
  D.91797 = (size_type) D.91803;
  return D.91797;
}


Glib::Variant<std::vector<std::basic_string<char> > >::~Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.91805;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.91805 = &this->D.67074;
            Glib::VariantContainerBase::~VariantContainerBase (D.91805);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.88813>:
}


static Glib::Variant<std::vector<std::basic_string<char> > > Glib::Variant<std::vector<std::basic_string<char> > >::create_from_object_paths(const type_vec_string&) (const struct type_vec_string & data)
{
  long unsigned int D.91808;
  int D.91815;
  long unsigned int D.91818;
  long unsigned int D.91819;
  long unsigned int D.91820;
  char * * D.91821;
  const struct basic_string & D.91822;
  const char * D.91823;
  gchar * D.91824;
  bool retval.39;
  long unsigned int D.91826;
  long unsigned int D.91827;
  long unsigned int D.91828;
  char * * D.91829;
  long unsigned int D.91830;
  long int D.91831;
  struct GVariant * D.91832;
  char * * str_array;
  struct Variant result [value-expr: *<retval>];

  {
    gsize __n;
    gsize __s;
    void * __p;

    D.91808 = std::vector<std::basic_string<char> >::size (data);
    __n = D.91808 + 1;
    __s = 8;
    if (__s == 1) goto <D.91809>; else goto <D.91810>;
    <D.91809>:
    __p = g_malloc (__n);
    goto <D.91811>;
    <D.91810>:
    D.91815 = __builtin_constant_p (__n);
    if (D.91815 != 0) goto <D.91816>; else goto <D.91812>;
    <D.91816>:
    if (__s == 0) goto <D.91813>; else goto <D.91817>;
    <D.91817>:
    D.91818 = 18446744073709551615 / __s;
    if (D.91818 >= __n) goto <D.91813>; else goto <D.91812>;
    <D.91813>:
    D.91819 = __n * __s;
    __p = g_malloc (D.91819);
    goto <D.91814>;
    <D.91812>:
    __p = g_malloc_n (__n, __s);
    <D.91814>:
    <D.91811>:
    str_array = __p;
  }
  {
    size_type i;

    i = 0;
    goto <D.88839>;
    <D.88838>:
    D.91820 = i * 8;
    D.91821 = str_array + D.91820;
    D.91822 = std::vector<std::basic_string<char> >::operator[] (data, i);
    D.91823 = std::basic_string<char>::c_str (D.91822);
    D.91824 = g_strdup (D.91823);
    *D.91821 = D.91824;
    i = i + 1;
    <D.88839>:
    D.91826 = std::vector<std::basic_string<char> >::size (data);
    retval.39 = D.91826 > i;
    if (retval.39 != 0) goto <D.88838>; else goto <D.88836>;
    <D.88836>:
  }
  D.91827 = std::vector<std::basic_string<char> >::size (data);
  D.91828 = D.91827 * 8;
  D.91829 = str_array + D.91828;
  *D.91829 = 0B;
  D.91830 = std::vector<std::basic_string<char> >::size (data);
  D.91831 = (long int) D.91830;
  D.91832 = g_variant_new_objv (str_array, D.91831);
  Glib::Variant<std::vector<std::basic_string<char> > >::Variant (<retval>, D.91832, 0);
  try
    {
      g_strfreev (str_array);
      return <retval>;
    }
  catch
    {
      Glib::Variant<std::vector<std::basic_string<char> > >::~Variant (<retval>);
    }
}


std::string Glib::Variant<std::vector<std::basic_string<char> > >::get_child(gsize) const (const struct Variant * const this, gsize index)
{
  const struct VariantBase * D.91842;
  const struct GVariant * D.91843;
  long unsigned int n_elements.40;
  void * D.88850;
  const struct string D.88848;
  struct allocator D.88847;
  struct allocator D.88853;
  long unsigned int D.91847;
  const gchar * * D.91848;
  const gchar * D.91849;
  gsize n_elements;
  const gchar * * array;
  const struct string result [value-expr: *<retval>];

  try
    {
      n_elements = 0;
      D.91842 = &this->D.67074.D.66789;
      D.91843 = Glib::VariantBase::gobj (D.91842);
      array = g_variant_get_bytestring_array (D.91843, &n_elements);
      n_elements.40 = n_elements;
      if (index >= n_elements.40) goto <D.91845>; else goto <D.91846>;
      <D.91845>:
      D.88850 = __cxa_allocate_exception (16);
      try
        {
          std::allocator<char>::allocator (&D.88847);
          try
            {
              std::basic_string<char>::basic_string (&D.88848, "Variant< std::vector<std::string> >::get(): Index out of bounds.", &D.88847);
              try
                {
                  std::out_of_range::out_of_range (D.88850, &D.88848);
                }
              finally
                {
                  try
                    {
                      std::basic_string<char>::~basic_string (&D.88848);
                    }
                  catch
                    {
                      <<<eh_must_not_throw (terminate)>>>
                    }
                  D.88848 = {CLOBBER};
                }
            }
          finally
            {
              try
                {
                  std::allocator<char>::~allocator (&D.88847);
                }
              catch
                {
                  <<<eh_must_not_throw (terminate)>>>
                }
              D.88847 = {CLOBBER};
            }
        }
      catch
        {
          __cxa_free_exception (D.88850);
        }
      __cxa_throw (D.88850, &_ZTISt12out_of_range, __comp_dtor );
      <D.91846>:
      std::allocator<char>::allocator (&D.88853);
      try
        {
          D.91847 = index * 8;
          D.91848 = array + D.91847;
          D.91849 = *D.91848;
          std::basic_string<char>::basic_string (<retval>, D.91849, &D.88853);
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.88853);
            }
          catch
            {
              std::basic_string<char>::~basic_string (<retval>);
            }
          D.88853 = {CLOBBER};
        }
      try
        {
          g_free (array);
          return <retval>;
        }
      catch
        {
          std::basic_string<char>::~basic_string (<retval>);
        }
    }
  finally
    {
      n_elements = {CLOBBER};
    }
}


Glib::type_vec_string Glib::Variant<std::vector<std::basic_string<char> > >::get() const (const struct Variant * const this)
{
  const struct VariantBase * D.91860;
  const struct GVariant * D.91861;
  struct allocator_type D.88877;
  long unsigned int n_elements.41;
  long unsigned int D.91863;
  const gchar * * D.91864;
  gsize n_elements;
  const gchar * * array;
  const struct type_vec_string result [value-expr: *<retval>];

  try
    {
      n_elements = 0;
      D.91860 = &this->D.67074.D.66789;
      D.91861 = Glib::VariantBase::gobj (D.91860);
      array = g_variant_get_bytestring_array (D.91861, &n_elements);
      std::allocator<std::basic_string<char> >::allocator (&D.88877);
      try
        {
          n_elements.41 = n_elements;
          D.91863 = n_elements.41 * 8;
          D.91864 = array + D.91863;
          std::vector<std::basic_string<char> >::vector<const char**> (<retval>, array, D.91864, &D.88877);
        }
      finally
        {
          try
            {
              std::allocator<std::basic_string<char> >::~allocator (&D.88877);
            }
          catch
            {
              std::vector<std::basic_string<char> >::~vector (<retval>);
            }
          D.88877 = {CLOBBER};
        }
      try
        {
          g_free (array);
          return <retval>;
        }
      catch
        {
          std::vector<std::basic_string<char> >::~vector (<retval>);
        }
    }
  finally
    {
      n_elements = {CLOBBER};
    }
}


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

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

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


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

  try
    {
      {

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


std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with _InputIterator = const char**; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<std::basic_string<char> >] (struct vector * const this, const char * * __first, const char * * __last, const struct allocator_type & __a)
{
  struct _Vector_base * D.91873;
  struct _Integral D.89760;
  struct __false_type D.91874;

  D.91873 = &this->D.88793;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_base (D.91873, __a);
  try
    {
      {
        typedef struct _Integral _Integral;

        try
          {
            std::vector<std::basic_string<char> >::_M_initialize_dispatch<const char**> (this, __first, __last, D.91874);
          }
        finally
          {
            D.89760 = {CLOBBER};
          }
      }
    }
  catch
    {
      D.91873 = &this->D.88793;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::~_Vector_base (D.91873);
    }
}


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

  D.91877 = &this->_M_impl;
  std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::_Vector_impl (D.91877, __a);
  try
    {

    }
  catch
    {
      D.91877 = &this->_M_impl;
      std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::~_Vector_impl (D.91877);
    }
}


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


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

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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = const char**; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct vector * const this, const char * * __first, const char * * __last, struct __false_type D.89748)
{
  struct forward_iterator_tag D.90183;
  struct _IterCategory D.90172;
  struct _IterCategory * D.91880;
  struct forward_iterator_tag D.91881;
  typedef struct _IterCategory _IterCategory;

  try
    {
      D.91880 = &D.90172;
      std::vector<std::basic_string<char> >::_M_range_initialize<const char**> (this, __first, __last, D.91881);
    }
  finally
    {
      D.90172 = {CLOBBER};
    }
}


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = const char**; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct vector * const this, const char * * __first, const char * * __last, struct forward_iterator_tag D.90177)
{
  long int D.91883;
  struct _Vector_base * D.91884;
  struct basic_string * D.91885;
  struct basic_string * D.91886;
  long unsigned int D.91887;
  struct basic_string * D.91888;
  struct _Tp_alloc_type & D.91889;
  struct basic_string * D.91890;
  const size_type __n;

  D.91883 = std::distance<const char**> (__first, __last);
  __n = (const size_type) D.91883;
  D.91884 = &this->D.88793;
  D.91885 = std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_allocate (D.91884, __n);
  this->D.88793._M_impl._M_start = D.91885;
  D.91886 = this->D.88793._M_impl._M_start;
  D.91887 = __n * 8;
  D.91888 = D.91886 + D.91887;
  this->D.88793._M_impl._M_end_of_storage = D.91888;
  D.91884 = &this->D.88793;
  D.91889 = std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_get_Tp_allocator (D.91884);
  D.91886 = this->D.88793._M_impl._M_start;
  D.91890 = std::__uninitialized_copy_a<const char**, std::basic_string<char>*, std::basic_string<char> > (__first, __last, D.91886, D.91889);
  this->D.88793._M_impl._M_finish = D.91890;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::_Vector_base<_Tp, _Alloc>::pointer = std::basic_string<char>*; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  struct basic_string * D.91894;
  struct basic_string * iftmp.42;
  struct _Vector_impl * D.91898;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.91896>; else goto <D.91897>;
  <D.91896>:
  D.91898 = &this->_M_impl;
  iftmp.42 = __gnu_cxx::__alloc_traits<std::allocator<std::basic_string<char> > >::allocate (D.91898, __n);
  goto <D.91899>;
  <D.91897>:
  iftmp.42 = 0B;
  <D.91899>:
  D.91894 = iftmp.42;
  return D.91894;
}


static __gnu_cxx::__alloc_traits<_Alloc>::pointer __gnu_cxx::__alloc_traits<_Alloc>::allocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<std::basic_string<char> >; __gnu_cxx::__alloc_traits<_Alloc>::pointer = std::basic_string<char>*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  struct basic_string * D.91902;

  D.91902 = __gnu_cxx::new_allocator<std::basic_string<char> >::allocate (__a, __n, 0B);
  return D.91902;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::basic_string<char>; __gnu_cxx::new_allocator<_Tp>::pointer = std::basic_string<char>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.88106)
{
  bool retval.43;
  long unsigned int D.91906;
  struct basic_string * D.91909;
  long unsigned int D.91910;

  D.91906 = __gnu_cxx::new_allocator<std::basic_string<char> >::max_size (this);
  retval.43 = D.91906 < __n;
  if (retval.43 != 0) goto <D.91907>; else goto <D.91908>;
  <D.91907>:
  std::__throw_bad_alloc ();
  <D.91908>:
  D.91910 = __n * 8;
  D.91909 = operator new (D.91910);
  return D.91909;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::basic_string<char>; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.91913;
  void * D.91914;

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


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

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


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = const char**; _ForwardIterator = std::basic_string<char>*; _Tp = std::basic_string<char>] (const char * * __first, const char * * __last, struct basic_string * __result, struct allocator & D.90502)
{
  struct basic_string * D.91918;

  D.91918 = std::uninitialized_copy<const char**, std::basic_string<char>*> (__first, __last, __result);
  return D.91918;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = const char**; _ForwardIterator = std::basic_string<char>*] (const char * * __first, const char * * __last, struct basic_string * __result)
{
  struct basic_string * D.91921;
  typedef const char * _ValueType1;
  typedef struct _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.91921 = std::__uninitialized_copy<false>::__uninit_copy<const char**, std::basic_string<char>*> (__first, __last, __result);
  return D.91921;
}


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = const char**; _ForwardIterator = std::basic_string<char>*; bool _TrivialValueTypes = false] (const char * * __first, const char * * __last, struct basic_string * __result)
{
  struct basic_string * D.91924;
  struct basic_string * D.91925;
  void * D.91926;
  struct basic_string * __cur;

  __cur = __result;
  try
    {
      goto <D.90943>;
      <D.90942>:
      D.91924 = std::__addressof<std::basic_string<char> > (__cur);
      std::_Construct<std::basic_string<char>, const char*> (D.91924, __first);
      __first = __first + 8;
      __cur = __cur + 8;
      <D.90943>:
      if (__first != __last) goto <D.90942>; else goto <D.90940>;
      <D.90940>:
      D.91925 = __cur;
      return D.91925;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.91926 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.91926);
              std::_Destroy<std::basic_string<char>*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


_Tp* std::__addressof(_Tp&) [with _Tp = std::basic_string<char>] (struct basic_string & __r)
{
  struct basic_string * D.91931;

  D.91931 = __r;
  return D.91931;
}


void std::_Construct(_T1*, const _T2&) [with _T1 = std::basic_string<char>; _T2 = const char*] (struct basic_string * __p, const char * const & __value)
{
  const struct allocator & D.90964;
  struct allocator D.90963;
  void * D.90960;
  void * D.90961;
  struct basic_string * iftmp.44;
  const char * D.91936;

  std::allocator<char>::allocator (&D.90963);
  try
    {
      D.90964 = &D.90963;
      D.90960 = __p;
      D.90961 = operator new (8, D.90960);
      if (D.90961 != 0B) goto <D.91934>; else goto <D.91935>;
      <D.91934>:
      try
        {
          D.91936 = *__value;
          std::basic_string<char>::basic_string (D.90961, D.91936, D.90964);
        }
      catch
        {
          operator delete (D.90961, D.90960);
        }
      iftmp.44 = D.90961;
      goto <D.91937>;
      <D.91935>:
      iftmp.44 = D.90961;
      <D.91937>:
    }
  finally
    {
      std::allocator<char>::~allocator (&D.90963);
      D.90963 = {CLOBBER};
    }
}


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

  std::_Destroy_aux<false>::__destroy<std::basic_string<char>*> (__first, __last);
}


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

  goto <D.90770>;
  <D.90769>:
  D.91940 = std::__addressof<std::basic_string<char> > (__first);
  std::_Destroy<std::basic_string<char> > (D.91940);
  __first = __first + 8;
  <D.90770>:
  if (__first != __last) goto <D.90769>; else goto <D.90767>;
  <D.90767>:
}


void std::_Destroy(_Tp*) [with _Tp = std::basic_string<char>] (struct basic_string * __pointer)
{
  std::basic_string<char>::~basic_string (__pointer);
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct _Vector_base * const this)
{
  struct basic_string * D.91941;
  long int D.91942;
  struct basic_string * D.91943;
  long int D.91944;
  long int D.91945;
  long int D.91946;
  long unsigned int D.91947;
  struct _Vector_impl * D.91948;

  {
    try
      {
        try
          {
            D.91941 = this->_M_impl._M_end_of_storage;
            D.91942 = (long int) D.91941;
            D.91943 = this->_M_impl._M_start;
            D.91944 = (long int) D.91943;
            D.91945 = D.91942 - D.91944;
            D.91946 = D.91945 /[ex] 8;
            D.91947 = (long unsigned int) D.91946;
            D.91943 = this->_M_impl._M_start;
            std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_deallocate (this, D.91943, D.91947);
          }
        finally
          {
            D.91948 = &this->_M_impl;
            std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_Vector_impl::~_Vector_impl (D.91948);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.90167>:
}


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

  if (__p != 0B) goto <D.91951>; else goto <D.91952>;
  <D.91951>:
  D.91953 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<std::basic_string<char> > >::deallocate (D.91953, __p, __n);
  goto <D.91954>;
  <D.91952>:
  <D.91954>:
}


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


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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >] (struct vector * const this)
{
  struct _Vector_base * D.91957;
  struct _Tp_alloc_type & D.91958;
  struct basic_string * D.91959;
  struct basic_string * D.91960;

  {
    try
      {
        try
          {
            D.91957 = &this->D.88793;
            D.91958 = std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::_M_get_Tp_allocator (D.91957);
            D.91959 = this->D.88793._M_impl._M_finish;
            D.91960 = this->D.88793._M_impl._M_start;
            std::_Destroy<std::basic_string<char>*, std::basic_string<char> > (D.91960, D.91959, D.91958);
          }
        finally
          {
            D.91957 = &this->D.88793;
            std::_Vector_base<std::basic_string<char>, std::allocator<std::basic_string<char> > >::~_Vector_base (D.91957);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.89774>:
}


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


Glib::VariantIter Glib::Variant<std::vector<std::basic_string<char> > >::get_iter() const (const struct Variant * const this)
{
  const struct VariantType & D.91964;
  const struct VariantType & D.91965;
  struct string D.88887;
  const char * D.91966;
  const struct VariantBase * D.91967;
  const struct GVariant * D.91968;
  struct GVariantIter * g_iter.45;
  const struct VariantType element_variant_type;
  const struct VariantType array_variant_type;
  struct GVariantIter * g_iter;

  try
    {
      D.91964 = Glib::Variant<std::basic_string<char> >::variant_type ();
      Glib::VariantType::VariantType (&element_variant_type, D.91964);
      try
        {
          D.91965 = Glib::Variant<std::vector<std::basic_string<char> > >::variant_type ();
          Glib::VariantType::VariantType (&array_variant_type, D.91965);
          try
            {
              g_iter = 0B;
              D.88887 = Glib::VariantType::get_string (&array_variant_type); [return slot optimization]
              try
                {
                  D.91966 = std::basic_string<char>::c_str (&D.88887);
                  D.91967 = &this->D.67074.D.66789;
                  D.91968 = Glib::VariantBase::gobj (D.91967);
                  g_variant_get (D.91968, D.91966, &g_iter);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.88887);
                  D.88887 = {CLOBBER};
                }
              g_iter.45 = g_iter;
              Glib::VariantIter::VariantIter (<retval>, g_iter.45, 0);
              return <retval>;
            }
          finally
            {
              Glib::VariantType::~VariantType (&array_variant_type);
            }
        }
      finally
        {
          Glib::VariantType::~VariantType (&element_variant_type);
        }
    }
  finally
    {
      element_variant_type = {CLOBBER};
      array_variant_type = {CLOBBER};
      g_iter = {CLOBBER};
    }
}


Glib::VariantParseError::VariantParseError(Glib::VariantParseError::Code, const Glib::ustring&) (struct VariantParseError * const this, Code error_code, const struct ustring & error_message)
{
  int error_code.46;
  unsigned int D.91980;
  struct Error * D.91981;

  error_code.46 = (int) error_code;
  D.91980 = g_variant_parse_error_quark ();
  D.91981 = &this->D.66579;
  Glib::Error::Error (D.91981, D.91980, error_code.46, error_message);
  try
    {
      this->D.66579.D.32153._vptr.Exception = &MEM[(void *)&_ZTVN4Glib17VariantParseErrorE + 16B];
    }
  catch
    {
      D.91981 = &this->D.66579;
      Glib::Error::~Error (D.91981);
    }
}


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


Glib::VariantParseError::~VariantParseError() (struct VariantParseError * const this)
{
  struct Error * D.91983;
  int D.91984;

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

          }
        finally
          {
            D.91983 = &this->D.66579;
            Glib::Error::~Error (D.91983);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.90969>:
  D.91984 = 0;
  if (D.91984 != 0) goto <D.91985>; else goto <D.91986>;
  <D.91985>:
  operator delete (this);
  goto <D.91987>;
  <D.91986>:
  <D.91987>:
}


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

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


Glib::VariantParseError::Code Glib::VariantParseError::code() const (const struct VariantParseError * const this)
{
  Code D.91989;
  const struct Error * D.91990;
  int D.91991;

  D.91990 = &this->D.66579;
  D.91991 = Glib::Error::code (D.91990);
  D.91989 = (Code) D.91991;
  return D.91989;
}


static void Glib::VariantParseError::throw_func(GError*) (struct GError * gobject)
{
  void * D.88920;

  D.88920 = __cxa_allocate_exception (16);
  try
    {
      Glib::VariantParseError::VariantParseError (D.88920, gobject);
    }
  catch
    {
      __cxa_free_exception (D.88920);
    }
  __cxa_throw (D.88920, &_ZTIN4Glib17VariantParseErrorE, __comp_dtor );
}


Glib::VariantBase Glib::wrap(GVariant*, bool) (struct GVariant * object, bool take_copy)
{
  int D.91996;

  D.91996 = (int) take_copy;
  Glib::VariantBase::VariantBase (<retval>, object, D.91996);
  return <retval>;
}


Glib::VariantBase::VariantBase() (struct VariantBase * const this)
{
  this->gobject_ = 0B;
}


Glib::VariantBase::VariantBase(const Glib::VariantBase&) (struct VariantBase * const this, const struct VariantBase & src)
{
  struct GVariant * iftmp.47;
  struct GVariant * D.91999;

  D.91999 = src->gobject_;
  if (D.91999 != 0B) goto <D.92000>; else goto <D.92001>;
  <D.92000>:
  D.91999 = src->gobject_;
  iftmp.47 = g_variant_ref_sink (D.91999);
  goto <D.92002>;
  <D.92001>:
  iftmp.47 = 0B;
  <D.92002>:
  this->gobject_ = iftmp.47;
}


Glib::VariantBase& Glib::VariantBase::operator=(const Glib::VariantBase&) (struct VariantBase * const this, const struct VariantBase & src)
{
  struct GVariant * iftmp.48;
  struct GVariant * D.92005;
  struct GVariant * D.92009;
  struct VariantBase & D.92013;
  struct GVariant * const new_gobject;

  D.92005 = src->gobject_;
  if (D.92005 != 0B) goto <D.92006>; else goto <D.92007>;
  <D.92006>:
  D.92005 = src->gobject_;
  iftmp.48 = g_variant_ref_sink (D.92005);
  goto <D.92008>;
  <D.92007>:
  iftmp.48 = 0B;
  <D.92008>:
  new_gobject = iftmp.48;
  D.92009 = this->gobject_;
  if (D.92009 != 0B) goto <D.92010>; else goto <D.92011>;
  <D.92010>:
  D.92009 = this->gobject_;
  g_variant_unref (D.92009);
  goto <D.92012>;
  <D.92011>:
  <D.92012>:
  this->gobject_ = new_gobject;
  D.92013 = this;
  return D.92013;
}


Glib::VariantBase::~VariantBase() (struct VariantBase * const this)
{
  struct GVariant * D.92016;

  {
    try
      {
        D.92016 = this->gobject_;
        if (D.92016 != 0B) goto <D.92017>; else goto <D.92018>;
        <D.92017>:
        D.92016 = this->gobject_;
        g_variant_unref (D.92016);
        goto <D.92019>;
        <D.92018>:
        <D.92019>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.88952>:
}


GVariant* Glib::VariantBase::gobj_copy() const (const struct VariantBase * const this)
{
  struct GVariant * D.92021;
  struct GVariant * D.92022;

  D.92022 = this->gobject_;
  D.92021 = g_variant_ref_sink (D.92022);
  return D.92021;
}


Glib::VariantType Glib::VariantBase::get_type() const (const struct VariantBase * const this)
{
  const struct GVariant * D.92026;
  const struct GVariantType * D.92027;

  D.92026 = Glib::VariantBase::gobj (this);
  D.92027 = g_variant_get_type (D.92026);
  *<retval> = Glib::wrap (D.92027, 1); [return slot optimization]
  return <retval>;
}


std::string Glib::VariantBase::get_type_string() const (const struct VariantBase * const this)
{
  const struct GVariant * D.92031;
  const gchar * D.92032;

  D.92031 = Glib::VariantBase::gobj (this);
  D.92032 = g_variant_get_type_string (D.92031);
  *<retval> = Glib::convert_const_gchar_ptr_to_stdstring (D.92032); [return slot optimization]
  return <retval>;
}


bool Glib::VariantBase::is_floating() const (const struct VariantBase * const this)
{
  bool D.92035;
  const struct GVariant * D.92036;
  int D.92037;

  D.92036 = Glib::VariantBase::gobj (this);
  D.92037 = g_variant_is_floating (D.92036);
  D.92035 = D.92037 != 0;
  return D.92035;
}


bool Glib::VariantBase::is_of_type(const Glib::VariantType&) const (const struct VariantBase * const this, const struct VariantType & type)
{
  bool D.92040;
  const struct GVariantType * D.92041;
  const struct GVariant * D.92042;
  int D.92043;

  D.92041 = Glib::VariantType::gobj (type);
  D.92042 = Glib::VariantBase::gobj (this);
  D.92043 = g_variant_is_of_type (D.92042, D.92041);
  D.92040 = D.92043 != 0;
  return D.92040;
}


bool Glib::VariantBase::is_container() const (const struct VariantBase * const this)
{
  bool D.92046;
  const struct GVariant * D.92047;
  int D.92048;

  D.92047 = Glib::VariantBase::gobj (this);
  D.92048 = g_variant_is_container (D.92047);
  D.92046 = D.92048 != 0;
  return D.92046;
}


GVariantClass Glib::VariantBase::classify() const (const struct VariantBase * const this)
{
  GVariantClass D.92051;
  const struct GVariant * D.92052;

  D.92052 = Glib::VariantBase::gobj (this);
  D.92051 = g_variant_classify (D.92052);
  return D.92051;
}


gsize Glib::VariantBase::get_size() const (const struct VariantBase * const this)
{
  gsize D.92055;
  const struct GVariant * D.92056;

  D.92056 = Glib::VariantBase::gobj (this);
  D.92055 = g_variant_get_size (D.92056);
  return D.92055;
}


const void* Glib::VariantBase::get_data() (struct VariantBase * const this)
{
  const void * D.92059;
  struct GVariant * D.92060;

  D.92060 = Glib::VariantBase::gobj (this);
  D.92059 = g_variant_get_data (D.92060);
  return D.92059;
}


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

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


void Glib::VariantBase::store(gpointer) const (const struct VariantBase * const this, void * data)
{
  const struct GVariant * D.92065;

  D.92065 = Glib::VariantBase::gobj (this);
  g_variant_store (D.92065, data);
}


Glib::ustring Glib::VariantBase::print(bool) const (const struct VariantBase * const this, bool type_annotate)
{
  int D.92067;
  const struct GVariant * D.92068;
  gchar * D.92069;

  D.92067 = (int) type_annotate;
  D.92068 = Glib::VariantBase::gobj (this);
  D.92069 = g_variant_print (D.92068, D.92067);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.92069); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.49;
  char * D.92078;
  struct ustring * D.92079;

  cleanup.49 = 0;
  try
    {
      if (str != 0B) goto <D.92073>; else goto <D.92074>;
      <D.92073>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.49 = 1;
      D.92078 = Glib::ScopedPtr<char>::get (&D.78974);
      D.92079 = <retval>;
      Glib::ustring::ustring (D.92079, D.92078);
      goto <D.92080>;
      <D.92074>:
      D.92079 = <retval>;
      Glib::ustring::ustring (D.92079);
      <D.92080>:
      return <retval>;
    }
  finally
    {
      if (cleanup.49 != 0) goto <D.92076>; else goto <D.92077>;
      <D.92076>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.92077>:
    }
}


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

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


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

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


guint Glib::VariantBase::hash() const (const struct VariantBase * const this)
{
  guint D.92090;
  const struct GVariant * D.92091;

  D.92091 = Glib::VariantBase::gobj (this);
  D.92090 = g_variant_hash (D.92091);
  return D.92090;
}


bool Glib::VariantBase::equal(const Glib::VariantBase&) const (const struct VariantBase * const this, const struct VariantBase & other)
{
  bool D.92094;
  const struct GVariant * D.92095;
  const struct GVariant * D.92096;
  int D.92097;

  D.92095 = Glib::VariantBase::gobj (other);
  D.92096 = Glib::VariantBase::gobj (this);
  D.92097 = g_variant_equal (D.92096, D.92095);
  D.92094 = D.92097 != 0;
  return D.92094;
}


bool Glib::VariantBase::is_normal_form() const (const struct VariantBase * const this)
{
  bool D.92100;
  const struct GVariant * D.92101;
  int D.92102;

  D.92101 = Glib::VariantBase::gobj (this);
  D.92102 = g_variant_is_normal_form (D.92101);
  D.92100 = D.92102 != 0;
  return D.92100;
}


bool Glib::VariantBase::check_format_string(const string&, bool) const (const struct VariantBase * const this, const struct string & format_string, bool copy_only)
{
  bool D.92105;
  int D.92106;
  const char * D.92107;
  const struct GVariant * D.92108;
  int D.92109;

  D.92106 = (int) copy_only;
  D.92107 = std::basic_string<char>::c_str (format_string);
  D.92108 = Glib::VariantBase::gobj (this);
  D.92109 = g_variant_check_format_string (D.92108, D.92107, D.92106);
  D.92105 = D.92109 != 0;
  return D.92105;
}


static bool Glib::VariantStringBase::is_object_path(const string&) (const struct string & string)
{
  bool D.92113;
  const char * D.92114;
  int D.92115;

  D.92114 = std::basic_string<char>::c_str (string);
  D.92115 = g_variant_is_object_path (D.92114);
  D.92113 = D.92115 != 0;
  return D.92113;
}


static bool Glib::VariantStringBase::is_signature(const string&) (const struct string & string)
{
  bool D.92119;
  const char * D.92120;
  int D.92121;

  D.92120 = std::basic_string<char>::c_str (string);
  D.92121 = g_variant_is_signature (D.92120);
  D.92119 = D.92121 != 0;
  return D.92119;
}


gsize Glib::VariantContainerBase::get_n_children() const (const struct VariantContainerBase * const this)
{
  gsize D.92125;
  const struct VariantBase * D.92126;
  const struct GVariant * D.92127;

  D.92126 = &this->D.66789;
  D.92127 = Glib::VariantBase::gobj (D.92126);
  D.92125 = g_variant_n_children (D.92127);
  return D.92125;
}


Glib::VariantBase Glib::VariantContainerBase::get_child(gsize) (struct VariantContainerBase * const this, gsize index)
{
  struct VariantBase * D.92131;
  struct GVariant * D.92132;
  struct GVariant * D.92133;

  D.92131 = &this->D.66789;
  D.92132 = Glib::VariantBase::gobj (D.92131);
  D.92133 = g_variant_get_child_value (D.92132, index);
  *<retval> = Glib::wrap (D.92133, 0); [return slot optimization]
  return <retval>;
}


Glib::VariantBase Glib::Variant<Glib::VariantBase>::get() const (const struct Variant * const this)
{
  const struct VariantBase * D.92137;
  const struct GVariant * D.92138;
  struct GVariant * D.92139;

  D.92137 = &this->D.66837.D.66789;
  D.92138 = Glib::VariantBase::gobj (D.92137);
  D.92139 = g_variant_get_variant (D.92138);
  *<retval> = Glib::wrap (D.92139, 0); [return slot optimization]
  return <retval>;
}


(static initializers for variant.cc) ()
{
  __static_initialization_and_destruction_0 (1, 65535);
}


void __static_initialization_and_destruction_0(int, int) (int __initialize_p, int __priority)
{
  if (__initialize_p == 1) goto <D.92142>; else goto <D.92143>;
  <D.92142>:
  if (__priority == 65535) goto <D.92144>; else goto <D.92145>;
  <D.92144>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  goto <D.92146>;
  <D.92145>:
  <D.92146>:
  goto <D.92147>;
  <D.92143>:
  <D.92147>:
}