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

  D.67965 = &this->gobject_;
  memset (D.67965, 0, 24);
}


void* memset(void*, int, size_t) (void * __dest, int __ch, size_t __len)
{
  int D.67968;
  int D.67973;
  void * D.67975;
  long unsigned int D.67976;
  void * D.67977;

  try
    {
      D.67968 = __builtin_constant_p (__len);
      if (D.67968 != 0) goto <D.67969>; else goto <D.67970>;
      <D.67969>:
      if (__len == 0) goto <D.67971>; else goto <D.67972>;
      <D.67971>:
      D.67973 = __builtin_constant_p (__ch);
      if (D.67973 == 0) goto <D.67966>; else goto <D.67974>;
      <D.67974>:
      if (__ch != 0) goto <D.67966>; else goto <D.67967>;
      <D.67966>:
      __warn_memset_zero_len ();
      D.67975 = __dest;
      return D.67975;
      <D.67967>:
      <D.67972>:
      <D.67970>:
      D.67976 = __builtin_object_size (__dest, 0);
      D.67975 = __builtin___memset_chk (__dest, __ch, __len, D.67976);
      return D.67975;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.67977 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.67977);
          
        }
    }
}


void Glib::ValueBase::init(GType) (struct ValueBase * const this, GType type)
{
  struct GValue * D.67982;

  D.67982 = &this->gobject_;
  g_value_init (D.67982, type);
}


void Glib::ValueBase::init(const GValue*) (struct ValueBase * const this, const struct GValue * value)
{
  long unsigned int D.67983;
  struct GValue * D.67984;

  D.67983 = MEM[(struct GValue *)value].g_type;
  D.67984 = &this->gobject_;
  g_value_init (D.67984, D.67983);
  if (value != 0B) goto <D.67985>; else goto <D.67986>;
  <D.67985>:
  D.67984 = &this->gobject_;
  g_value_copy (value, D.67984);
  goto <D.67987>;
  <D.67986>:
  <D.67987>:
}


Glib::ValueBase::ValueBase(const Glib::ValueBase&) (struct ValueBase * const this, const struct ValueBase & other)
{
  struct GValue * D.67988;
  const struct GValue * D.67989;
  long unsigned int D.67990;

  D.67988 = &this->gobject_;
  memset (D.67988, 0, 24);
  D.67989 = &other->gobject_;
  D.67990 = MEM[(struct GValue *)D.67989].g_type;
  D.67988 = &this->gobject_;
  g_value_init (D.67988, D.67990);
  D.67988 = &this->gobject_;
  D.67989 = &other->gobject_;
  g_value_copy (D.67989, D.67988);
}


Glib::ValueBase& Glib::ValueBase::operator=(const Glib::ValueBase&) (struct ValueBase * const this, const struct ValueBase & other)
{
  struct GValue * D.67991;
  const struct GValue * D.67992;
  struct ValueBase & D.67993;

  D.67991 = &this->gobject_;
  D.67992 = &other->gobject_;
  g_value_copy (D.67992, D.67991);
  D.67993 = this;
  return D.67993;
}


Glib::ValueBase::~ValueBase() (struct ValueBase * const this)
{
  struct GValue * D.67995;

  {
    try
      {
        D.67995 = &this->gobject_;
        g_value_unset (D.67995);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.67107>:
}


void Glib::ValueBase::reset() (struct ValueBase * const this)
{
  struct GValue * D.67997;

  D.67997 = &this->gobject_;
  g_value_reset (D.67997);
}


static GType Glib::ValueBase_Boxed::value_type() ()
{
  GType D.67998;

  D.67998 = 72;
  return D.67998;
}


void Glib::ValueBase_Boxed::set_boxed(const void*) (struct ValueBase_Boxed * const this, const void * data)
{
  struct GValue * D.68000;

  D.68000 = &this->D.34518.gobject_;
  g_value_set_boxed (D.68000, data);
}


void* Glib::ValueBase_Boxed::get_boxed() const (const struct ValueBase_Boxed * const this)
{
  void * D.68001;
  const struct GValue * D.68002;

  D.68002 = &this->D.34518.gobject_;
  D.68001 = g_value_get_boxed (D.68002);
  return D.68001;
}


GParamSpec* Glib::ValueBase_Boxed::create_param_spec(const Glib::ustring&) const (const struct ValueBase_Boxed * const this, const struct ustring & name)
{
  struct GParamSpec * D.68005;
  const struct GValue * D.68006;
  long unsigned int D.68007;
  const char * D.68008;

  D.68006 = &this->D.34518.gobject_;
  D.68007 = MEM[(struct GValue *)D.68006].g_type;
  D.68008 = Glib::ustring::c_str (name);
  D.68005 = g_param_spec_boxed (D.68008, 0B, 0B, D.68007, 3);
  return D.68005;
}


static GType Glib::ValueBase_Object::value_type() ()
{
  GType D.68012;

  D.68012 = 80;
  return D.68012;
}


void Glib::ValueBase_Object::set_object(Glib::ObjectBase*) (struct ValueBase_Object * const this, struct ObjectBase * data)
{
  struct GObject * iftmp.0;
  struct GValue * D.68018;

  if (data != 0B) goto <D.68015>; else goto <D.68016>;
  <D.68015>:
  iftmp.0 = Glib::ObjectBase::gobj (data);
  goto <D.68017>;
  <D.68016>:
  iftmp.0 = 0B;
  <D.68017>:
  D.68018 = &this->D.34534.gobject_;
  g_value_set_object (D.68018, iftmp.0);
}


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

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


Glib::ObjectBase* Glib::ValueBase_Object::get_object() const (const struct ValueBase_Object * const this)
{
  const struct GValue * D.68021;
  struct ObjectBase * D.68022;
  struct GObject * const data;

  D.68021 = &this->D.34534.gobject_;
  data = g_value_get_object (D.68021);
  D.68022 = Glib::wrap_auto (data, 0);
  return D.68022;
}


Glib::RefPtr<Glib::ObjectBase> Glib::ValueBase_Object::get_object_copy() const (const struct ValueBase_Object * const this)
{
  const struct GValue * D.68027;
  struct ObjectBase * D.68028;
  struct GObject * const data;

  D.68027 = &this->D.34534.gobject_;
  data = g_value_get_object (D.68027);
  D.68028 = Glib::wrap_auto (data, 1);
  Glib::RefPtr<Glib::ObjectBase>::RefPtr (<retval>, D.68028);
  return <retval>;
}


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


GParamSpec* Glib::ValueBase_Object::create_param_spec(const Glib::ustring&) const (const struct ValueBase_Object * const this, const struct ustring & name)
{
  bool retval.1;
  gboolean retval.2;
  long unsigned int D.68037;
  struct GParamSpec * D.68043;
  const struct GValue * D.68044;
  long unsigned int D.68045;
  const char * D.68046;
  bool retval.3;
  int retval.4;
  bool retval.5;
  gboolean retval.6;
  long unsigned int D.68054;
  long int D.68061;
  long int D.68062;
  const char * D.68066;
  static const char __PRETTY_FUNCTION__[82] = "GParamSpec* Glib::ValueBase_Object::create_param_spec(const Glib::ustring&) const";

  {
    {
      struct GValue * __val;
      GType __t;
      gboolean __r;

      __val = &this->D.34534.gobject_;
      __t = 80;
      if (__val == 0B) goto <D.68034>; else goto <D.68035>;
      <D.68034>:
      __r = 0;
      goto <D.68036>;
      <D.68035>:
      D.68037 = __val->g_type;
      if (D.68037 == __t) goto <D.68038>; else goto <D.68039>;
      <D.68038>:
      __r = 1;
      goto <D.68040>;
      <D.68039>:
      __r = g_type_check_value_holds (__val, __t);
      <D.68040>:
      <D.68036>:
      retval.2 = __r;
    }
    retval.1 = retval.2 != 0;
    if (retval.1 != 0) goto <D.68041>; else goto <D.68042>;
    <D.68041>:
    D.68044 = &this->D.34534.gobject_;
    D.68045 = MEM[(struct GValue *)D.68044].g_type;
    D.68046 = Glib::ustring::c_str (name);
    D.68043 = g_param_spec_object (D.68046, 0B, 0B, D.68045, 3);
    return D.68043;
    <D.68042>:
    {
      {
        {
          {
            int _g_boolean_var_;

            {
              {
                struct GValue * __val;
                GType __t;
                gboolean __r;

                __val = &this->D.34534.gobject_;
                __t = 68;
                if (__val == 0B) goto <D.68051>; else goto <D.68052>;
                <D.68051>:
                __r = 0;
                goto <D.68053>;
                <D.68052>:
                D.68054 = __val->g_type;
                if (D.68054 == __t) goto <D.68055>; else goto <D.68056>;
                <D.68055>:
                __r = 1;
                goto <D.68057>;
                <D.68056>:
                __r = g_type_check_value_holds (__val, __t);
                <D.68057>:
                <D.68053>:
                retval.6 = __r;
              }
              retval.5 = retval.6 != 0;
              if (retval.5 != 0) goto <D.68058>; else goto <D.68059>;
              <D.68058>:
              _g_boolean_var_ = 1;
              goto <D.68060>;
              <D.68059>:
              _g_boolean_var_ = 0;
              <D.68060>:
            }
            retval.4 = _g_boolean_var_;
          }
          D.68061 = (long int) retval.4;
          D.68062 = __builtin_expect (D.68061, 1);
          retval.3 = D.68062 != 0;
          if (retval.3 != 0) goto <D.68063>; else goto <D.68064>;
          <D.68063>:
          goto <D.68065>;
          <D.68064>:
          g_return_if_fail_warning ("glibmm", &__PRETTY_FUNCTION__, "G_VALUE_HOLDS_POINTER(&gobject_)");
          D.68043 = 0B;
          return D.68043;
          <D.68065>:
        }
      }
      D.68066 = Glib::ustring::c_str (name);
      D.68043 = g_param_spec_pointer (D.68066, 0B, 0B, 3);
      return D.68043;
    }
  }
}


static GType Glib::ValueBase_Enum::value_type() ()
{
  GType D.68074;

  D.68074 = 48;
  return D.68074;
}


void Glib::ValueBase_Enum::set_enum(int) (struct ValueBase_Enum * const this, int data)
{
  struct GValue * D.68076;

  D.68076 = &this->D.34548.gobject_;
  g_value_set_enum (D.68076, data);
}


int Glib::ValueBase_Enum::get_enum() const (const struct ValueBase_Enum * const this)
{
  int D.68077;
  const struct GValue * D.68078;

  D.68078 = &this->D.34548.gobject_;
  D.68077 = g_value_get_enum (D.68078);
  return D.68077;
}


GParamSpec* Glib::ValueBase_Enum::create_param_spec(const Glib::ustring&) const (const struct ValueBase_Enum * const this, const struct ustring & name)
{
  struct GParamSpec * D.68081;
  const struct GValue * D.68082;
  int D.68083;
  long unsigned int D.68084;
  const char * D.68085;

  D.68082 = &this->D.34548.gobject_;
  D.68083 = g_value_get_enum (D.68082);
  D.68082 = &this->D.34548.gobject_;
  D.68084 = MEM[(struct GValue *)D.68082].g_type;
  D.68085 = Glib::ustring::c_str (name);
  D.68081 = g_param_spec_enum (D.68085, 0B, 0B, D.68084, D.68083, 3);
  return D.68081;
}


static GType Glib::ValueBase_Flags::value_type() ()
{
  GType D.68090;

  D.68090 = 52;
  return D.68090;
}


void Glib::ValueBase_Flags::set_flags(unsigned int) (struct ValueBase_Flags * const this, unsigned int data)
{
  struct GValue * D.68092;

  D.68092 = &this->D.34562.gobject_;
  g_value_set_flags (D.68092, data);
}


unsigned int Glib::ValueBase_Flags::get_flags() const (const struct ValueBase_Flags * const this)
{
  unsigned int D.68093;
  const struct GValue * D.68094;

  D.68094 = &this->D.34562.gobject_;
  D.68093 = g_value_get_flags (D.68094);
  return D.68093;
}


GParamSpec* Glib::ValueBase_Flags::create_param_spec(const Glib::ustring&) const (const struct ValueBase_Flags * const this, const struct ustring & name)
{
  struct GParamSpec * D.68097;
  const struct GValue * D.68098;
  unsigned int D.68099;
  long unsigned int D.68100;
  const char * D.68101;

  D.68098 = &this->D.34562.gobject_;
  D.68099 = g_value_get_flags (D.68098);
  D.68098 = &this->D.34562.gobject_;
  D.68100 = MEM[(struct GValue *)D.68098].g_type;
  D.68101 = Glib::ustring::c_str (name);
  D.68097 = g_param_spec_flags (D.68101, 0B, 0B, D.68100, D.68099, 3);
  return D.68097;
}


static GType Glib::ValueBase_String::value_type() ()
{
  GType D.68106;

  D.68106 = 64;
  return D.68106;
}


void Glib::ValueBase_String::set_cstring(const char*) (struct ValueBase_String * const this, const char * data)
{
  struct GValue * D.68108;

  D.68108 = &this->D.34576.gobject_;
  g_value_set_string (D.68108, data);
}


const char* Glib::ValueBase_String::get_cstring() const (const struct ValueBase_String * const this)
{
  const struct GValue * D.68109;
  const char * D.68112;

  {
    const char * const data;

    D.68109 = &this->D.34576.gobject_;
    data = g_value_get_string (D.68109);
    if (data != 0B) goto <D.68110>; else goto <D.68111>;
    <D.68110>:
    D.68112 = data;
    return D.68112;
    <D.68111>:
    D.68112 = "";
    return D.68112;
  }
}


GParamSpec* Glib::ValueBase_String::create_param_spec(const Glib::ustring&) const (const struct ValueBase_String * const this, const struct ustring & name)
{
  struct GParamSpec * D.68115;
  const char * D.68116;
  const char * D.68117;

  D.68116 = Glib::ValueBase_String::get_cstring (this);
  D.68117 = Glib::ustring::c_str (name);
  D.68115 = g_param_spec_string (D.68117, 0B, 0B, D.68116, 3);
  return D.68115;
}


void Glib::Value<std::basic_string<char> >::set(const string&) (struct Value * const this, const struct string & data)
{
  const char * D.68122;
  struct GValue * D.68123;

  D.68122 = std::basic_string<char>::c_str (data);
  D.68123 = &this->D.35152.D.34576.gobject_;
  g_value_set_string (D.68123, D.68122);
}


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

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


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

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


void Glib::Value<Glib::ustring>::set(const Glib::ustring&) (struct Value * const this, const struct ustring & data)
{
  const char * D.68130;
  struct GValue * D.68131;

  D.68130 = Glib::ustring::c_str (data);
  D.68131 = &this->D.35166.D.34576.gobject_;
  g_value_set_string (D.68131, D.68130);
}