GType Glib::custom_boxed_type_register(const char*, Glib::ValueInitFunc, Glib::ValueFreeFunc, Glib::ValueCopyFunc) (const char * type_name, void (*ValueInitFunc) (struct GValue *) init_func, void (*ValueFreeFunc) (struct GValue *) free_func, void (*ValueCopyFunc) (const struct GValue *, struct GValue *) copy_func)
{
  struct allocator D.35333;
  const char * D.35480;
  GType D.35483;
  const char * D.35484;
  struct string full_name;
  const struct GTypeValueTable value_table;
  const struct GTypeInfo type_info;

  try
    {
      std::allocator<char>::allocator (&D.35333);
      try
        {
          std::basic_string<char>::basic_string (&full_name, "glibmm__CustomBoxed_", &D.35333);
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.35333);
            }
          catch
            {
              std::basic_string<char>::~basic_string (&full_name);
            }
          D.35333 = {CLOBBER};
        }
      try
        {
          Glib::append_canonical_typename (&full_name, type_name);
          {
            const GType existing_type;

            D.35480 = std::basic_string<char>::c_str (&full_name);
            existing_type = g_type_from_name (D.35480);
            if (existing_type != 0) goto <D.35481>; else goto <D.35482>;
            <D.35481>:
            {anonymous}::warn_already_registered ("Glib::custom_boxed_type_register", &full_name);
            D.35483 = existing_type;
            return D.35483;
            <D.35482>:
          }
          value_table = {};
          value_table.value_init = init_func;
          value_table.value_free = free_func;
          value_table.value_copy = copy_func;
          type_info = {};
          type_info.value_table = &value_table;
          D.35484 = std::basic_string<char>::c_str (&full_name);
          D.35483 = g_type_register_static (72, D.35484, &type_info, 0);
          return D.35483;
        }
      finally
        {
          std::basic_string<char>::~basic_string (&full_name);
        }
    }
  finally
    {
      full_name = {CLOBBER};
      value_table = {CLOBBER};
      type_info = {CLOBBER};
    }
}


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

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

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


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

  try
    {
      {

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


void {anonymous}::warn_already_registered(const char*, const string&) (const char * location, const struct string & full_name)
{
  const char * D.35498;

  D.35498 = std::basic_string<char>::c_str (full_name);
  g_log ("glibmm", 16, "file %s: (%s): The type name `%s\' has been registered already.\nThis is not supposed to happen -- please send a mail with detailed information about your platform to gtkmm-list@gnome.org.  Thanks.\n", "value_custom.cc", location, D.35498);
}


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

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


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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.35393;
  struct _Rep * D.35507;
  struct _Alloc_hider * D.35508;

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


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

  D.35514 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.35514);
  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.35516;

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


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

  try
    {
      {

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


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.35518;
  char * D.35519;

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


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.0;
  struct _Rep & D.35523;
  bool D.35524;
  long int D.35525;
  long int D.35526;
  bool retval.1;
  _Atomic_word * D.35530;
  int D.35531;

  D.35523 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.35524 = D.35523 != this;
  D.35525 = (long int) D.35524;
  D.35526 = __builtin_expect (D.35525, 0);
  retval.0 = D.35526 != 0;
  if (retval.0 != 0) goto <D.35527>; else goto <D.35528>;
  <D.35527>:
  D.35530 = &this->D.19179._M_refcount;
  D.35531 = __gnu_cxx::__exchange_and_add_dispatch (D.35530, -1);
  retval.1 = D.35531 <= 0;
  if (retval.1 != 0) goto <D.35532>; else goto <D.35533>;
  <D.35532>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.35534>;
  <D.35533>:
  <D.35534>:
  goto <D.35535>;
  <D.35528>:
  <D.35535>:
}


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.35537;
  void * __p;

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.2;
  int D.35540;
  _Atomic_word D.35543;

  D.35540 = __gthread_active_p ();
  retval.2 = D.35540 != 0;
  if (retval.2 != 0) goto <D.35541>; else goto <D.35542>;
  <D.35541>:
  D.35543 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.35543;
  <D.35542>:
  D.35543 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.35543;
}


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

  D.35546 = __gthrw___pthread_key_create != 0B;
  D.35545 = (int) D.35546;
  return D.35545;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.35548;
  unsigned int __val.3;
  unsigned int D.35550;

  __val.3 = (unsigned int) __val;
  D.35550 = __atomic_fetch_add_4 (__mem, __val.3, 4);
  D.35548 = (_Atomic_word) D.35550;
  return D.35548;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.35552;
  int D.35553;
  _Atomic_word D.35554;
  _Atomic_word __result;

  __result = *__mem;
  D.35552 = *__mem;
  D.35553 = D.35552 + __val;
  *__mem = D.35553;
  D.35554 = __result;
  return D.35554;
}


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.35387>:
}


GType Glib::custom_pointer_type_register(const char*) (const char * type_name)
{
  struct allocator D.35342;
  const char * D.35556;
  GType D.35559;
  const char * D.35560;
  struct string full_name;
  const struct GTypeInfo type_info;

  try
    {
      std::allocator<char>::allocator (&D.35342);
      try
        {
          std::basic_string<char>::basic_string (&full_name, "glibmm__CustomPointer_", &D.35342);
        }
      finally
        {
          try
            {
              std::allocator<char>::~allocator (&D.35342);
            }
          catch
            {
              std::basic_string<char>::~basic_string (&full_name);
            }
          D.35342 = {CLOBBER};
        }
      try
        {
          Glib::append_canonical_typename (&full_name, type_name);
          {
            const GType existing_type;

            D.35556 = std::basic_string<char>::c_str (&full_name);
            existing_type = g_type_from_name (D.35556);
            if (existing_type != 0) goto <D.35557>; else goto <D.35558>;
            <D.35557>:
            {anonymous}::warn_already_registered ("Glib::custom_pointer_type_register", &full_name);
            D.35559 = existing_type;
            return D.35559;
            <D.35558>:
          }
          type_info = {};
          D.35560 = std::basic_string<char>::c_str (&full_name);
          D.35559 = g_type_register_static (68, D.35560, &type_info, 0);
          return D.35559;
        }
      finally
        {
          std::basic_string<char>::~basic_string (&full_name);
        }
    }
  finally
    {
      full_name = {CLOBBER};
      type_info = {CLOBBER};
    }
}