Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108383;
  const void * * iftmp.0;
  struct ObjectBase * D.108391;
  struct ConstructParams D.101628;
  const char * iftmp.1;
  bool D.108394;
  const char * iftmp.2;
  bool D.108399;
  const char * iftmp.3;
  bool D.108404;
  struct BaseObjectType * D.108408;
  int flags.4;
  struct BaseObjectType * D.108410;
  const struct Class & D.108411;
  const void * * iftmp.5;
  struct Object * D.108416;
  const void * * iftmp.6;
  struct Initable * D.108421;
  const void * * iftmp.7;
  struct AsyncInitable * D.108426;
  int (*__vtbl_ptr_type) () * iftmp.8;
  sizetype iftmp.9;
  int (*__vtbl_ptr_type) () * D.108434;
  int (*__vtbl_ptr_type) () * D.108435;
  long int D.108436;
  struct ObjectBase * D.108438;
  int (*__vtbl_ptr_type) () * iftmp.10;
  int (*__vtbl_ptr_type) () * iftmp.11;
  int (*__vtbl_ptr_type) () * iftmp.12;
  const void * * iftmp.13;
  const void * * iftmp.14;
  const void * * iftmp.15;
  const void * * iftmp.16;

  if (0 != 0) goto <D.108381>; else goto <D.108382>;
  <D.108381>:
  D.108383 = &this->D.101154;
  sigc::trackable::trackable (D.108383);
  goto <D.108384>;
  <D.108382>:
  <D.108384>:
  try
    {
      if (0 != 0) goto <D.108385>; else goto <D.108386>;
      <D.108385>:
      if (0 == 0) goto <D.108388>; else goto <D.108389>;
      <D.108388>:
      iftmp.0 = __vtt_parm + 112;
      goto <D.108390>;
      <D.108389>:
      iftmp.0 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108390>:
      D.108391 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108391, iftmp.0, 0B);
      goto <D.108392>;
      <D.108386>:
      <D.108392>:
      try
        {
          D.108394 = Glib::ustring::empty (interface_name);
          if (D.108394 != 0) goto <D.108395>; else goto <D.108396>;
          <D.108395>:
          iftmp.1 = 0B;
          goto <D.108397>;
          <D.108396>:
          iftmp.1 = Glib::ustring::c_str (interface_name);
          <D.108397>:
          D.108399 = Glib::ustring::empty (object_path);
          if (D.108399 != 0) goto <D.108400>; else goto <D.108401>;
          <D.108400>:
          iftmp.2 = 0B;
          goto <D.108402>;
          <D.108401>:
          iftmp.2 = Glib::ustring::c_str (object_path);
          <D.108402>:
          D.108404 = Glib::ustring::empty (name);
          if (D.108404 != 0) goto <D.108405>; else goto <D.108406>;
          <D.108405>:
          iftmp.3 = 0B;
          goto <D.108407>;
          <D.108406>:
          iftmp.3 = Glib::ustring::c_str (name);
          <D.108407>:
          D.108408 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.4 = (int) flags;
          D.108410 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108411 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101628, D.108411, "g-connection", D.108410, "g-flags", flags.4, "g-interface-info", D.108408, "g-name", iftmp.3, "g-object-path", iftmp.2, "g-interface-name", iftmp.1, 0B);
          try
            {
              if (0 == 0) goto <D.108413>; else goto <D.108414>;
              <D.108413>:
              iftmp.5 = __vtt_parm + 8;
              goto <D.108415>;
              <D.108414>:
              iftmp.5 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108415>:
              D.108416 = &this->D.101147;
              Glib::Object::Object (D.108416, iftmp.5, &D.101628);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101628);
              D.101628 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.108418>; else goto <D.108419>;
              <D.108418>:
              iftmp.6 = __vtt_parm + 24;
              goto <D.108420>;
              <D.108419>:
              iftmp.6 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108420>:
              D.108421 = &this->D.101148;
              Gio::Initable::Initable (D.108421, iftmp.6);
              try
                {
                  if (0 == 0) goto <D.108423>; else goto <D.108424>;
                  <D.108423>:
                  iftmp.7 = __vtt_parm + 56;
                  goto <D.108425>;
                  <D.108424>:
                  iftmp.7 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108425>:
                  D.108426 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108426, iftmp.7);
                  try
                    {
                      if (0 == 0) goto <D.108428>; else goto <D.108429>;
                      <D.108428>:
                      iftmp.8 = *__vtt_parm;
                      goto <D.108430>;
                      <D.108429>:
                      iftmp.8 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.108430>:
                      this->D.101147._vptr.Object = iftmp.8;
                      if (0 == 0) goto <D.108432>; else goto <D.108433>;
                      <D.108432>:
                      D.108434 = this->D.101147._vptr.Object;
                      D.108435 = D.108434 + 18446744073709551592;
                      D.108436 = MEM[(long int *)D.108435];
                      iftmp.9 = (sizetype) D.108436;
                      goto <D.108437>;
                      <D.108433>:
                      iftmp.9 = 24;
                      <D.108437>:
                      D.108438 = this + iftmp.9;
                      if (0 == 0) goto <D.108440>; else goto <D.108441>;
                      <D.108440>:
                      iftmp.10 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.108442>;
                      <D.108441>:
                      iftmp.10 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.108442>:
                      D.108438->_vptr.ObjectBase = iftmp.10;
                      if (0 == 0) goto <D.108444>; else goto <D.108445>;
                      <D.108444>:
                      iftmp.11 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.108446>;
                      <D.108445>:
                      iftmp.11 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.108446>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.11;
                      if (0 == 0) goto <D.108448>; else goto <D.108449>;
                      <D.108448>:
                      iftmp.12 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.108450>;
                      <D.108449>:
                      iftmp.12 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.108450>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.12;
                      D.108426 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.108426, slot, cancellable, 0);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.108452>; else goto <D.108453>;
                      <D.108452>:
                      iftmp.13 = __vtt_parm + 56;
                      goto <D.108454>;
                      <D.108453>:
                      iftmp.13 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.108454>:
                      D.108426 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108426, iftmp.13);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.108456>; else goto <D.108457>;
                  <D.108456>:
                  iftmp.14 = __vtt_parm + 24;
                  goto <D.108458>;
                  <D.108457>:
                  iftmp.14 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.108458>:
                  D.108421 = &this->D.101148;
                  Gio::Initable::~Initable (D.108421, iftmp.14);
                }
            }
          catch
            {
              if (0 == 0) goto <D.108460>; else goto <D.108461>;
              <D.108460>:
              iftmp.15 = __vtt_parm + 8;
              goto <D.108462>;
              <D.108461>:
              iftmp.15 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108462>:
              D.108416 = &this->D.101147;
              Glib::Object::~Object (D.108416, iftmp.15);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108463>; else goto <D.108464>;
          <D.108463>:
          if (0 == 0) goto <D.108466>; else goto <D.108467>;
          <D.108466>:
          iftmp.16 = __vtt_parm + 112;
          goto <D.108468>;
          <D.108467>:
          iftmp.16 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.108468>:
          D.108391 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108391, iftmp.16);
          goto <D.108469>;
          <D.108464>:
          <D.108469>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108470>; else goto <D.108471>;
      <D.108470>:
      D.108383 = &this->D.101154;
      sigc::trackable::~trackable (D.108383);
      goto <D.108472>;
      <D.108471>:
      <D.108472>:
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::DBus::InterfaceInfo; typename T::BaseObjectType = _GDBusInterfaceInfo] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.108489;
  struct BaseObjectType * iftmp.17;
  bool D.108491;
  struct InterfaceInfo * D.108494;

  D.108491 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator bool (ptr);
  if (D.108491 != 0) goto <D.108492>; else goto <D.108493>;
  <D.108492>:
  D.108494 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator-> (ptr);
  iftmp.17 = Gio::DBus::InterfaceInfo::gobj (D.108494);
  goto <D.108495>;
  <D.108493>:
  iftmp.17 = 0B;
  <D.108495>:
  D.108489 = iftmp.17;
  return D.108489;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::DBus::InterfaceInfo] (const struct RefPtr * const this)
{
  bool D.108498;
  struct InterfaceInfo * D.108499;

  D.108499 = this->pCppObject_;
  D.108498 = D.108499 != 0B;
  return D.108498;
}


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

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


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::DBus::Connection; typename T::BaseObjectType = _GDBusConnection] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.108503;
  struct BaseObjectType * iftmp.18;
  bool D.108505;
  struct Connection * D.108508;

  D.108505 = Glib::RefPtr<Gio::DBus::Connection>::operator bool (ptr);
  if (D.108505 != 0) goto <D.108506>; else goto <D.108507>;
  <D.108506>:
  D.108508 = Glib::RefPtr<Gio::DBus::Connection>::operator-> (ptr);
  iftmp.18 = Gio::DBus::Connection::gobj (D.108508);
  goto <D.108509>;
  <D.108507>:
  iftmp.18 = 0B;
  <D.108509>:
  D.108503 = iftmp.18;
  return D.108503;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::DBus::Connection] (const struct RefPtr * const this)
{
  bool D.108511;
  struct Connection * D.108512;

  D.108512 = this->pCppObject_;
  D.108511 = D.108512 != 0B;
  return D.108511;
}


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

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


GDBusConnection* Gio::DBus::Connection::gobj() (struct Connection * const this)
{
  struct GDBusConnection * D.108516;
  int (*__vtbl_ptr_type) () * D.108517;
  int (*__vtbl_ptr_type) () * D.108518;
  long int D.108519;
  sizetype D.108520;
  struct ObjectBase * D.108521;

  D.108517 = this->D.100492._vptr.Object;
  D.108518 = D.108517 + 18446744073709551592;
  D.108519 = MEM[(long int *)D.108518];
  D.108520 = (sizetype) D.108519;
  D.108521 = this + D.108520;
  D.108516 = D.108521->gobject_;
  return D.108516;
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108525;
  const void * * iftmp.19;
  struct ObjectBase * D.108533;
  struct ConstructParams D.101630;
  const char * iftmp.20;
  bool D.108536;
  const char * iftmp.21;
  bool D.108541;
  const char * iftmp.22;
  bool D.108546;
  struct BaseObjectType * D.108550;
  int flags.23;
  struct BaseObjectType * D.108552;
  const struct Class & D.108553;
  const void * * iftmp.24;
  struct Object * D.108558;
  const void * * iftmp.25;
  struct Initable * D.108563;
  const void * * iftmp.26;
  struct AsyncInitable * D.108568;
  int (*__vtbl_ptr_type) () * iftmp.27;
  const void * * D.108572;
  sizetype iftmp.28;
  int (*__vtbl_ptr_type) () * D.108577;
  int (*__vtbl_ptr_type) () * D.108578;
  long int D.108579;
  struct ObjectBase * D.108581;
  int (*__vtbl_ptr_type) () * iftmp.29;
  int (*__vtbl_ptr_type) () * iftmp.30;
  int (*__vtbl_ptr_type) () * iftmp.31;
  const void * * iftmp.32;
  const void * * iftmp.33;
  const void * * iftmp.34;
  const void * * iftmp.35;

  if (1 != 0) goto <D.108523>; else goto <D.108524>;
  <D.108523>:
  D.108525 = &this->D.101154;
  sigc::trackable::trackable (D.108525);
  goto <D.108526>;
  <D.108524>:
  <D.108526>:
  try
    {
      if (1 != 0) goto <D.108527>; else goto <D.108528>;
      <D.108527>:
      if (1 == 0) goto <D.108530>; else goto <D.108531>;
      <D.108530>:
      iftmp.19 = 112B;
      goto <D.108532>;
      <D.108531>:
      iftmp.19 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108532>:
      D.108533 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108533, iftmp.19, 0B);
      goto <D.108534>;
      <D.108528>:
      <D.108534>:
      try
        {
          D.108536 = Glib::ustring::empty (interface_name);
          if (D.108536 != 0) goto <D.108537>; else goto <D.108538>;
          <D.108537>:
          iftmp.20 = 0B;
          goto <D.108539>;
          <D.108538>:
          iftmp.20 = Glib::ustring::c_str (interface_name);
          <D.108539>:
          D.108541 = Glib::ustring::empty (object_path);
          if (D.108541 != 0) goto <D.108542>; else goto <D.108543>;
          <D.108542>:
          iftmp.21 = 0B;
          goto <D.108544>;
          <D.108543>:
          iftmp.21 = Glib::ustring::c_str (object_path);
          <D.108544>:
          D.108546 = Glib::ustring::empty (name);
          if (D.108546 != 0) goto <D.108547>; else goto <D.108548>;
          <D.108547>:
          iftmp.22 = 0B;
          goto <D.108549>;
          <D.108548>:
          iftmp.22 = Glib::ustring::c_str (name);
          <D.108549>:
          D.108550 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.23 = (int) flags;
          D.108552 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108553 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101630, D.108553, "g-connection", D.108552, "g-flags", flags.23, "g-interface-info", D.108550, "g-name", iftmp.22, "g-object-path", iftmp.21, "g-interface-name", iftmp.20, 0B);
          try
            {
              if (1 == 0) goto <D.108555>; else goto <D.108556>;
              <D.108555>:
              iftmp.24 = 8B;
              goto <D.108557>;
              <D.108556>:
              iftmp.24 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108557>:
              D.108558 = &this->D.101147;
              Glib::Object::Object (D.108558, iftmp.24, &D.101630);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101630);
              D.101630 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.108560>; else goto <D.108561>;
              <D.108560>:
              iftmp.25 = 24B;
              goto <D.108562>;
              <D.108561>:
              iftmp.25 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108562>:
              D.108563 = &this->D.101148;
              Gio::Initable::Initable (D.108563, iftmp.25);
              try
                {
                  if (1 == 0) goto <D.108565>; else goto <D.108566>;
                  <D.108565>:
                  iftmp.26 = 56B;
                  goto <D.108567>;
                  <D.108566>:
                  iftmp.26 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108567>:
                  D.108568 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108568, iftmp.26);
                  try
                    {
                      if (1 == 0) goto <D.108570>; else goto <D.108571>;
                      <D.108570>:
                      D.108572 = 0B;
                      iftmp.27 = *D.108572;
                      goto <D.108573>;
                      <D.108571>:
                      iftmp.27 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.108573>:
                      this->D.101147._vptr.Object = iftmp.27;
                      if (1 == 0) goto <D.108575>; else goto <D.108576>;
                      <D.108575>:
                      D.108577 = this->D.101147._vptr.Object;
                      D.108578 = D.108577 + 18446744073709551592;
                      D.108579 = MEM[(long int *)D.108578];
                      iftmp.28 = (sizetype) D.108579;
                      goto <D.108580>;
                      <D.108576>:
                      iftmp.28 = 24;
                      <D.108580>:
                      D.108581 = this + iftmp.28;
                      if (1 == 0) goto <D.108583>; else goto <D.108584>;
                      <D.108583>:
                      iftmp.29 = MEM[(const void * *)0B + 88B];
                      goto <D.108585>;
                      <D.108584>:
                      iftmp.29 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.108585>:
                      D.108581->_vptr.ObjectBase = iftmp.29;
                      if (1 == 0) goto <D.108587>; else goto <D.108588>;
                      <D.108587>:
                      iftmp.30 = MEM[(const void * *)0B + 96B];
                      goto <D.108589>;
                      <D.108588>:
                      iftmp.30 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.108589>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.30;
                      if (1 == 0) goto <D.108591>; else goto <D.108592>;
                      <D.108591>:
                      iftmp.31 = MEM[(const void * *)0B + 104B];
                      goto <D.108593>;
                      <D.108592>:
                      iftmp.31 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.108593>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.31;
                      D.108568 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.108568, slot, cancellable, 0);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.108595>; else goto <D.108596>;
                      <D.108595>:
                      iftmp.32 = 56B;
                      goto <D.108597>;
                      <D.108596>:
                      iftmp.32 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.108597>:
                      D.108568 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108568, iftmp.32);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.108599>; else goto <D.108600>;
                  <D.108599>:
                  iftmp.33 = 24B;
                  goto <D.108601>;
                  <D.108600>:
                  iftmp.33 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.108601>:
                  D.108563 = &this->D.101148;
                  Gio::Initable::~Initable (D.108563, iftmp.33);
                }
            }
          catch
            {
              if (1 == 0) goto <D.108603>; else goto <D.108604>;
              <D.108603>:
              iftmp.34 = 8B;
              goto <D.108605>;
              <D.108604>:
              iftmp.34 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108605>:
              D.108558 = &this->D.101147;
              Glib::Object::~Object (D.108558, iftmp.34);
            }
        }
      catch
        {
          if (1 != 0) goto <D.108606>; else goto <D.108607>;
          <D.108606>:
          if (1 == 0) goto <D.108609>; else goto <D.108610>;
          <D.108609>:
          iftmp.35 = 112B;
          goto <D.108611>;
          <D.108610>:
          iftmp.35 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.108611>:
          D.108533 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108533, iftmp.35);
          goto <D.108612>;
          <D.108607>:
          <D.108612>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.108613>; else goto <D.108614>;
      <D.108613>:
      D.108525 = &this->D.101154;
      sigc::trackable::~trackable (D.108525);
      goto <D.108615>;
      <D.108614>:
      <D.108615>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108633;
  const void * * iftmp.36;
  struct ObjectBase * D.108641;
  struct ConstructParams D.101645;
  const char * iftmp.37;
  bool D.108644;
  const char * iftmp.38;
  bool D.108649;
  const char * iftmp.39;
  bool D.108654;
  struct BaseObjectType * D.108658;
  int flags.40;
  struct BaseObjectType * D.108660;
  const struct Class & D.108661;
  const void * * iftmp.41;
  struct Object * D.108666;
  const void * * iftmp.42;
  struct Initable * D.108671;
  const void * * iftmp.43;
  struct AsyncInitable * D.108676;
  int (*__vtbl_ptr_type) () * iftmp.44;
  sizetype iftmp.45;
  int (*__vtbl_ptr_type) () * D.108684;
  int (*__vtbl_ptr_type) () * D.108685;
  long int D.108686;
  struct ObjectBase * D.108688;
  int (*__vtbl_ptr_type) () * iftmp.46;
  int (*__vtbl_ptr_type) () * iftmp.47;
  int (*__vtbl_ptr_type) () * iftmp.48;
  const void * * iftmp.49;
  const void * * iftmp.50;
  const void * * iftmp.51;
  const void * * iftmp.52;

  if (0 != 0) goto <D.108631>; else goto <D.108632>;
  <D.108631>:
  D.108633 = &this->D.101154;
  sigc::trackable::trackable (D.108633);
  goto <D.108634>;
  <D.108632>:
  <D.108634>:
  try
    {
      if (0 != 0) goto <D.108635>; else goto <D.108636>;
      <D.108635>:
      if (0 == 0) goto <D.108638>; else goto <D.108639>;
      <D.108638>:
      iftmp.36 = __vtt_parm + 112;
      goto <D.108640>;
      <D.108639>:
      iftmp.36 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108640>:
      D.108641 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108641, iftmp.36, 0B);
      goto <D.108642>;
      <D.108636>:
      <D.108642>:
      try
        {
          D.108644 = Glib::ustring::empty (interface_name);
          if (D.108644 != 0) goto <D.108645>; else goto <D.108646>;
          <D.108645>:
          iftmp.37 = 0B;
          goto <D.108647>;
          <D.108646>:
          iftmp.37 = Glib::ustring::c_str (interface_name);
          <D.108647>:
          D.108649 = Glib::ustring::empty (object_path);
          if (D.108649 != 0) goto <D.108650>; else goto <D.108651>;
          <D.108650>:
          iftmp.38 = 0B;
          goto <D.108652>;
          <D.108651>:
          iftmp.38 = Glib::ustring::c_str (object_path);
          <D.108652>:
          D.108654 = Glib::ustring::empty (name);
          if (D.108654 != 0) goto <D.108655>; else goto <D.108656>;
          <D.108655>:
          iftmp.39 = 0B;
          goto <D.108657>;
          <D.108656>:
          iftmp.39 = Glib::ustring::c_str (name);
          <D.108657>:
          D.108658 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.40 = (int) flags;
          D.108660 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108661 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101645, D.108661, "g-connection", D.108660, "g-flags", flags.40, "g-interface-info", D.108658, "g-name", iftmp.39, "g-object-path", iftmp.38, "g-interface-name", iftmp.37, 0B);
          try
            {
              if (0 == 0) goto <D.108663>; else goto <D.108664>;
              <D.108663>:
              iftmp.41 = __vtt_parm + 8;
              goto <D.108665>;
              <D.108664>:
              iftmp.41 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108665>:
              D.108666 = &this->D.101147;
              Glib::Object::Object (D.108666, iftmp.41, &D.101645);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101645);
              D.101645 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.108668>; else goto <D.108669>;
              <D.108668>:
              iftmp.42 = __vtt_parm + 24;
              goto <D.108670>;
              <D.108669>:
              iftmp.42 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108670>:
              D.108671 = &this->D.101148;
              Gio::Initable::Initable (D.108671, iftmp.42);
              try
                {
                  if (0 == 0) goto <D.108673>; else goto <D.108674>;
                  <D.108673>:
                  iftmp.43 = __vtt_parm + 56;
                  goto <D.108675>;
                  <D.108674>:
                  iftmp.43 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108675>:
                  D.108676 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108676, iftmp.43);
                  try
                    {
                      if (0 == 0) goto <D.108678>; else goto <D.108679>;
                      <D.108678>:
                      iftmp.44 = *__vtt_parm;
                      goto <D.108680>;
                      <D.108679>:
                      iftmp.44 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.108680>:
                      this->D.101147._vptr.Object = iftmp.44;
                      if (0 == 0) goto <D.108682>; else goto <D.108683>;
                      <D.108682>:
                      D.108684 = this->D.101147._vptr.Object;
                      D.108685 = D.108684 + 18446744073709551592;
                      D.108686 = MEM[(long int *)D.108685];
                      iftmp.45 = (sizetype) D.108686;
                      goto <D.108687>;
                      <D.108683>:
                      iftmp.45 = 24;
                      <D.108687>:
                      D.108688 = this + iftmp.45;
                      if (0 == 0) goto <D.108690>; else goto <D.108691>;
                      <D.108690>:
                      iftmp.46 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.108692>;
                      <D.108691>:
                      iftmp.46 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.108692>:
                      D.108688->_vptr.ObjectBase = iftmp.46;
                      if (0 == 0) goto <D.108694>; else goto <D.108695>;
                      <D.108694>:
                      iftmp.47 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.108696>;
                      <D.108695>:
                      iftmp.47 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.108696>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.47;
                      if (0 == 0) goto <D.108698>; else goto <D.108699>;
                      <D.108698>:
                      iftmp.48 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.108700>;
                      <D.108699>:
                      iftmp.48 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.108700>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.48;
                      D.108676 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.108676, slot, 0);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.108702>; else goto <D.108703>;
                      <D.108702>:
                      iftmp.49 = __vtt_parm + 56;
                      goto <D.108704>;
                      <D.108703>:
                      iftmp.49 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.108704>:
                      D.108676 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108676, iftmp.49);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.108706>; else goto <D.108707>;
                  <D.108706>:
                  iftmp.50 = __vtt_parm + 24;
                  goto <D.108708>;
                  <D.108707>:
                  iftmp.50 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.108708>:
                  D.108671 = &this->D.101148;
                  Gio::Initable::~Initable (D.108671, iftmp.50);
                }
            }
          catch
            {
              if (0 == 0) goto <D.108710>; else goto <D.108711>;
              <D.108710>:
              iftmp.51 = __vtt_parm + 8;
              goto <D.108712>;
              <D.108711>:
              iftmp.51 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108712>:
              D.108666 = &this->D.101147;
              Glib::Object::~Object (D.108666, iftmp.51);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108713>; else goto <D.108714>;
          <D.108713>:
          if (0 == 0) goto <D.108716>; else goto <D.108717>;
          <D.108716>:
          iftmp.52 = __vtt_parm + 112;
          goto <D.108718>;
          <D.108717>:
          iftmp.52 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.108718>:
          D.108641 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108641, iftmp.52);
          goto <D.108719>;
          <D.108714>:
          <D.108719>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108720>; else goto <D.108721>;
      <D.108720>:
      D.108633 = &this->D.101154;
      sigc::trackable::~trackable (D.108633);
      goto <D.108722>;
      <D.108721>:
      <D.108722>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108740;
  const void * * iftmp.53;
  struct ObjectBase * D.108748;
  struct ConstructParams D.101647;
  const char * iftmp.54;
  bool D.108751;
  const char * iftmp.55;
  bool D.108756;
  const char * iftmp.56;
  bool D.108761;
  struct BaseObjectType * D.108765;
  int flags.57;
  struct BaseObjectType * D.108767;
  const struct Class & D.108768;
  const void * * iftmp.58;
  struct Object * D.108773;
  const void * * iftmp.59;
  struct Initable * D.108778;
  const void * * iftmp.60;
  struct AsyncInitable * D.108783;
  int (*__vtbl_ptr_type) () * iftmp.61;
  const void * * D.108787;
  sizetype iftmp.62;
  int (*__vtbl_ptr_type) () * D.108792;
  int (*__vtbl_ptr_type) () * D.108793;
  long int D.108794;
  struct ObjectBase * D.108796;
  int (*__vtbl_ptr_type) () * iftmp.63;
  int (*__vtbl_ptr_type) () * iftmp.64;
  int (*__vtbl_ptr_type) () * iftmp.65;
  const void * * iftmp.66;
  const void * * iftmp.67;
  const void * * iftmp.68;
  const void * * iftmp.69;

  if (1 != 0) goto <D.108738>; else goto <D.108739>;
  <D.108738>:
  D.108740 = &this->D.101154;
  sigc::trackable::trackable (D.108740);
  goto <D.108741>;
  <D.108739>:
  <D.108741>:
  try
    {
      if (1 != 0) goto <D.108742>; else goto <D.108743>;
      <D.108742>:
      if (1 == 0) goto <D.108745>; else goto <D.108746>;
      <D.108745>:
      iftmp.53 = 112B;
      goto <D.108747>;
      <D.108746>:
      iftmp.53 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108747>:
      D.108748 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108748, iftmp.53, 0B);
      goto <D.108749>;
      <D.108743>:
      <D.108749>:
      try
        {
          D.108751 = Glib::ustring::empty (interface_name);
          if (D.108751 != 0) goto <D.108752>; else goto <D.108753>;
          <D.108752>:
          iftmp.54 = 0B;
          goto <D.108754>;
          <D.108753>:
          iftmp.54 = Glib::ustring::c_str (interface_name);
          <D.108754>:
          D.108756 = Glib::ustring::empty (object_path);
          if (D.108756 != 0) goto <D.108757>; else goto <D.108758>;
          <D.108757>:
          iftmp.55 = 0B;
          goto <D.108759>;
          <D.108758>:
          iftmp.55 = Glib::ustring::c_str (object_path);
          <D.108759>:
          D.108761 = Glib::ustring::empty (name);
          if (D.108761 != 0) goto <D.108762>; else goto <D.108763>;
          <D.108762>:
          iftmp.56 = 0B;
          goto <D.108764>;
          <D.108763>:
          iftmp.56 = Glib::ustring::c_str (name);
          <D.108764>:
          D.108765 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.57 = (int) flags;
          D.108767 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108768 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101647, D.108768, "g-connection", D.108767, "g-flags", flags.57, "g-interface-info", D.108765, "g-name", iftmp.56, "g-object-path", iftmp.55, "g-interface-name", iftmp.54, 0B);
          try
            {
              if (1 == 0) goto <D.108770>; else goto <D.108771>;
              <D.108770>:
              iftmp.58 = 8B;
              goto <D.108772>;
              <D.108771>:
              iftmp.58 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108772>:
              D.108773 = &this->D.101147;
              Glib::Object::Object (D.108773, iftmp.58, &D.101647);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101647);
              D.101647 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.108775>; else goto <D.108776>;
              <D.108775>:
              iftmp.59 = 24B;
              goto <D.108777>;
              <D.108776>:
              iftmp.59 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108777>:
              D.108778 = &this->D.101148;
              Gio::Initable::Initable (D.108778, iftmp.59);
              try
                {
                  if (1 == 0) goto <D.108780>; else goto <D.108781>;
                  <D.108780>:
                  iftmp.60 = 56B;
                  goto <D.108782>;
                  <D.108781>:
                  iftmp.60 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108782>:
                  D.108783 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108783, iftmp.60);
                  try
                    {
                      if (1 == 0) goto <D.108785>; else goto <D.108786>;
                      <D.108785>:
                      D.108787 = 0B;
                      iftmp.61 = *D.108787;
                      goto <D.108788>;
                      <D.108786>:
                      iftmp.61 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.108788>:
                      this->D.101147._vptr.Object = iftmp.61;
                      if (1 == 0) goto <D.108790>; else goto <D.108791>;
                      <D.108790>:
                      D.108792 = this->D.101147._vptr.Object;
                      D.108793 = D.108792 + 18446744073709551592;
                      D.108794 = MEM[(long int *)D.108793];
                      iftmp.62 = (sizetype) D.108794;
                      goto <D.108795>;
                      <D.108791>:
                      iftmp.62 = 24;
                      <D.108795>:
                      D.108796 = this + iftmp.62;
                      if (1 == 0) goto <D.108798>; else goto <D.108799>;
                      <D.108798>:
                      iftmp.63 = MEM[(const void * *)0B + 88B];
                      goto <D.108800>;
                      <D.108799>:
                      iftmp.63 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.108800>:
                      D.108796->_vptr.ObjectBase = iftmp.63;
                      if (1 == 0) goto <D.108802>; else goto <D.108803>;
                      <D.108802>:
                      iftmp.64 = MEM[(const void * *)0B + 96B];
                      goto <D.108804>;
                      <D.108803>:
                      iftmp.64 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.108804>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.64;
                      if (1 == 0) goto <D.108806>; else goto <D.108807>;
                      <D.108806>:
                      iftmp.65 = MEM[(const void * *)0B + 104B];
                      goto <D.108808>;
                      <D.108807>:
                      iftmp.65 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.108808>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.65;
                      D.108783 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.108783, slot, 0);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.108810>; else goto <D.108811>;
                      <D.108810>:
                      iftmp.66 = 56B;
                      goto <D.108812>;
                      <D.108811>:
                      iftmp.66 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.108812>:
                      D.108783 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108783, iftmp.66);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.108814>; else goto <D.108815>;
                  <D.108814>:
                  iftmp.67 = 24B;
                  goto <D.108816>;
                  <D.108815>:
                  iftmp.67 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.108816>:
                  D.108778 = &this->D.101148;
                  Gio::Initable::~Initable (D.108778, iftmp.67);
                }
            }
          catch
            {
              if (1 == 0) goto <D.108818>; else goto <D.108819>;
              <D.108818>:
              iftmp.68 = 8B;
              goto <D.108820>;
              <D.108819>:
              iftmp.68 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108820>:
              D.108773 = &this->D.101147;
              Glib::Object::~Object (D.108773, iftmp.68);
            }
        }
      catch
        {
          if (1 != 0) goto <D.108821>; else goto <D.108822>;
          <D.108821>:
          if (1 == 0) goto <D.108824>; else goto <D.108825>;
          <D.108824>:
          iftmp.69 = 112B;
          goto <D.108826>;
          <D.108825>:
          iftmp.69 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.108826>:
          D.108748 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108748, iftmp.69);
          goto <D.108827>;
          <D.108822>:
          <D.108827>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.108828>; else goto <D.108829>;
      <D.108828>:
      D.108740 = &this->D.101154;
      sigc::trackable::~trackable (D.108740);
      goto <D.108830>;
      <D.108829>:
      <D.108830>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108848;
  const void * * iftmp.70;
  struct ObjectBase * D.108856;
  struct ConstructParams D.101662;
  const char * iftmp.71;
  bool D.108859;
  const char * iftmp.72;
  bool D.108864;
  const char * iftmp.73;
  bool D.108869;
  struct BaseObjectType * D.108873;
  int flags.74;
  struct BaseObjectType * D.108875;
  const struct Class & D.108876;
  const void * * iftmp.75;
  struct Object * D.108881;
  const void * * iftmp.76;
  struct Initable * D.108886;
  const void * * iftmp.77;
  struct AsyncInitable * D.108891;
  int (*__vtbl_ptr_type) () * iftmp.78;
  sizetype iftmp.79;
  int (*__vtbl_ptr_type) () * D.108899;
  int (*__vtbl_ptr_type) () * D.108900;
  long int D.108901;
  struct ObjectBase * D.108903;
  int (*__vtbl_ptr_type) () * iftmp.80;
  int (*__vtbl_ptr_type) () * iftmp.81;
  int (*__vtbl_ptr_type) () * iftmp.82;
  const void * * iftmp.83;
  const void * * iftmp.84;
  const void * * iftmp.85;
  const void * * iftmp.86;

  if (0 != 0) goto <D.108846>; else goto <D.108847>;
  <D.108846>:
  D.108848 = &this->D.101154;
  sigc::trackable::trackable (D.108848);
  goto <D.108849>;
  <D.108847>:
  <D.108849>:
  try
    {
      if (0 != 0) goto <D.108850>; else goto <D.108851>;
      <D.108850>:
      if (0 == 0) goto <D.108853>; else goto <D.108854>;
      <D.108853>:
      iftmp.70 = __vtt_parm + 112;
      goto <D.108855>;
      <D.108854>:
      iftmp.70 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108855>:
      D.108856 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108856, iftmp.70, 0B);
      goto <D.108857>;
      <D.108851>:
      <D.108857>:
      try
        {
          D.108859 = Glib::ustring::empty (interface_name);
          if (D.108859 != 0) goto <D.108860>; else goto <D.108861>;
          <D.108860>:
          iftmp.71 = 0B;
          goto <D.108862>;
          <D.108861>:
          iftmp.71 = Glib::ustring::c_str (interface_name);
          <D.108862>:
          D.108864 = Glib::ustring::empty (object_path);
          if (D.108864 != 0) goto <D.108865>; else goto <D.108866>;
          <D.108865>:
          iftmp.72 = 0B;
          goto <D.108867>;
          <D.108866>:
          iftmp.72 = Glib::ustring::c_str (object_path);
          <D.108867>:
          D.108869 = Glib::ustring::empty (name);
          if (D.108869 != 0) goto <D.108870>; else goto <D.108871>;
          <D.108870>:
          iftmp.73 = 0B;
          goto <D.108872>;
          <D.108871>:
          iftmp.73 = Glib::ustring::c_str (name);
          <D.108872>:
          D.108873 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.74 = (int) flags;
          D.108875 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108876 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101662, D.108876, "g-connection", D.108875, "g-flags", flags.74, "g-interface-info", D.108873, "g-name", iftmp.73, "g-object-path", iftmp.72, "g-interface-name", iftmp.71, 0B);
          try
            {
              if (0 == 0) goto <D.108878>; else goto <D.108879>;
              <D.108878>:
              iftmp.75 = __vtt_parm + 8;
              goto <D.108880>;
              <D.108879>:
              iftmp.75 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108880>:
              D.108881 = &this->D.101147;
              Glib::Object::Object (D.108881, iftmp.75, &D.101662);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101662);
              D.101662 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.108883>; else goto <D.108884>;
              <D.108883>:
              iftmp.76 = __vtt_parm + 24;
              goto <D.108885>;
              <D.108884>:
              iftmp.76 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108885>:
              D.108886 = &this->D.101148;
              Gio::Initable::Initable (D.108886, iftmp.76);
              try
                {
                  if (0 == 0) goto <D.108888>; else goto <D.108889>;
                  <D.108888>:
                  iftmp.77 = __vtt_parm + 56;
                  goto <D.108890>;
                  <D.108889>:
                  iftmp.77 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108890>:
                  D.108891 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108891, iftmp.77);
                  try
                    {
                      if (0 == 0) goto <D.108893>; else goto <D.108894>;
                      <D.108893>:
                      iftmp.78 = *__vtt_parm;
                      goto <D.108895>;
                      <D.108894>:
                      iftmp.78 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.108895>:
                      this->D.101147._vptr.Object = iftmp.78;
                      if (0 == 0) goto <D.108897>; else goto <D.108898>;
                      <D.108897>:
                      D.108899 = this->D.101147._vptr.Object;
                      D.108900 = D.108899 + 18446744073709551592;
                      D.108901 = MEM[(long int *)D.108900];
                      iftmp.79 = (sizetype) D.108901;
                      goto <D.108902>;
                      <D.108898>:
                      iftmp.79 = 24;
                      <D.108902>:
                      D.108903 = this + iftmp.79;
                      if (0 == 0) goto <D.108905>; else goto <D.108906>;
                      <D.108905>:
                      iftmp.80 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.108907>;
                      <D.108906>:
                      iftmp.80 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.108907>:
                      D.108903->_vptr.ObjectBase = iftmp.80;
                      if (0 == 0) goto <D.108909>; else goto <D.108910>;
                      <D.108909>:
                      iftmp.81 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.108911>;
                      <D.108910>:
                      iftmp.81 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.108911>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.81;
                      if (0 == 0) goto <D.108913>; else goto <D.108914>;
                      <D.108913>:
                      iftmp.82 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.108915>;
                      <D.108914>:
                      iftmp.82 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.108915>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.82;
                      D.108886 = &this->D.101148;
                      Gio::Initable::init (D.108886, cancellable);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.108917>; else goto <D.108918>;
                      <D.108917>:
                      iftmp.83 = __vtt_parm + 56;
                      goto <D.108919>;
                      <D.108918>:
                      iftmp.83 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.108919>:
                      D.108891 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108891, iftmp.83);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.108921>; else goto <D.108922>;
                  <D.108921>:
                  iftmp.84 = __vtt_parm + 24;
                  goto <D.108923>;
                  <D.108922>:
                  iftmp.84 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.108923>:
                  D.108886 = &this->D.101148;
                  Gio::Initable::~Initable (D.108886, iftmp.84);
                }
            }
          catch
            {
              if (0 == 0) goto <D.108925>; else goto <D.108926>;
              <D.108925>:
              iftmp.85 = __vtt_parm + 8;
              goto <D.108927>;
              <D.108926>:
              iftmp.85 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108927>:
              D.108881 = &this->D.101147;
              Glib::Object::~Object (D.108881, iftmp.85);
            }
        }
      catch
        {
          if (0 != 0) goto <D.108928>; else goto <D.108929>;
          <D.108928>:
          if (0 == 0) goto <D.108931>; else goto <D.108932>;
          <D.108931>:
          iftmp.86 = __vtt_parm + 112;
          goto <D.108933>;
          <D.108932>:
          iftmp.86 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.108933>:
          D.108856 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108856, iftmp.86);
          goto <D.108934>;
          <D.108929>:
          <D.108934>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.108935>; else goto <D.108936>;
      <D.108935>:
      D.108848 = &this->D.101154;
      sigc::trackable::~trackable (D.108848);
      goto <D.108937>;
      <D.108936>:
      <D.108937>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.108955;
  const void * * iftmp.87;
  struct ObjectBase * D.108963;
  struct ConstructParams D.101664;
  const char * iftmp.88;
  bool D.108966;
  const char * iftmp.89;
  bool D.108971;
  const char * iftmp.90;
  bool D.108976;
  struct BaseObjectType * D.108980;
  int flags.91;
  struct BaseObjectType * D.108982;
  const struct Class & D.108983;
  const void * * iftmp.92;
  struct Object * D.108988;
  const void * * iftmp.93;
  struct Initable * D.108993;
  const void * * iftmp.94;
  struct AsyncInitable * D.108998;
  int (*__vtbl_ptr_type) () * iftmp.95;
  const void * * D.109002;
  sizetype iftmp.96;
  int (*__vtbl_ptr_type) () * D.109007;
  int (*__vtbl_ptr_type) () * D.109008;
  long int D.109009;
  struct ObjectBase * D.109011;
  int (*__vtbl_ptr_type) () * iftmp.97;
  int (*__vtbl_ptr_type) () * iftmp.98;
  int (*__vtbl_ptr_type) () * iftmp.99;
  const void * * iftmp.100;
  const void * * iftmp.101;
  const void * * iftmp.102;
  const void * * iftmp.103;

  if (1 != 0) goto <D.108953>; else goto <D.108954>;
  <D.108953>:
  D.108955 = &this->D.101154;
  sigc::trackable::trackable (D.108955);
  goto <D.108956>;
  <D.108954>:
  <D.108956>:
  try
    {
      if (1 != 0) goto <D.108957>; else goto <D.108958>;
      <D.108957>:
      if (1 == 0) goto <D.108960>; else goto <D.108961>;
      <D.108960>:
      iftmp.87 = 112B;
      goto <D.108962>;
      <D.108961>:
      iftmp.87 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.108962>:
      D.108963 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.108963, iftmp.87, 0B);
      goto <D.108964>;
      <D.108958>:
      <D.108964>:
      try
        {
          D.108966 = Glib::ustring::empty (interface_name);
          if (D.108966 != 0) goto <D.108967>; else goto <D.108968>;
          <D.108967>:
          iftmp.88 = 0B;
          goto <D.108969>;
          <D.108968>:
          iftmp.88 = Glib::ustring::c_str (interface_name);
          <D.108969>:
          D.108971 = Glib::ustring::empty (object_path);
          if (D.108971 != 0) goto <D.108972>; else goto <D.108973>;
          <D.108972>:
          iftmp.89 = 0B;
          goto <D.108974>;
          <D.108973>:
          iftmp.89 = Glib::ustring::c_str (object_path);
          <D.108974>:
          D.108976 = Glib::ustring::empty (name);
          if (D.108976 != 0) goto <D.108977>; else goto <D.108978>;
          <D.108977>:
          iftmp.90 = 0B;
          goto <D.108979>;
          <D.108978>:
          iftmp.90 = Glib::ustring::c_str (name);
          <D.108979>:
          D.108980 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.91 = (int) flags;
          D.108982 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.108983 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101664, D.108983, "g-connection", D.108982, "g-flags", flags.91, "g-interface-info", D.108980, "g-name", iftmp.90, "g-object-path", iftmp.89, "g-interface-name", iftmp.88, 0B);
          try
            {
              if (1 == 0) goto <D.108985>; else goto <D.108986>;
              <D.108985>:
              iftmp.92 = 8B;
              goto <D.108987>;
              <D.108986>:
              iftmp.92 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.108987>:
              D.108988 = &this->D.101147;
              Glib::Object::Object (D.108988, iftmp.92, &D.101664);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101664);
              D.101664 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.108990>; else goto <D.108991>;
              <D.108990>:
              iftmp.93 = 24B;
              goto <D.108992>;
              <D.108991>:
              iftmp.93 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.108992>:
              D.108993 = &this->D.101148;
              Gio::Initable::Initable (D.108993, iftmp.93);
              try
                {
                  if (1 == 0) goto <D.108995>; else goto <D.108996>;
                  <D.108995>:
                  iftmp.94 = 56B;
                  goto <D.108997>;
                  <D.108996>:
                  iftmp.94 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.108997>:
                  D.108998 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.108998, iftmp.94);
                  try
                    {
                      if (1 == 0) goto <D.109000>; else goto <D.109001>;
                      <D.109000>:
                      D.109002 = 0B;
                      iftmp.95 = *D.109002;
                      goto <D.109003>;
                      <D.109001>:
                      iftmp.95 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109003>:
                      this->D.101147._vptr.Object = iftmp.95;
                      if (1 == 0) goto <D.109005>; else goto <D.109006>;
                      <D.109005>:
                      D.109007 = this->D.101147._vptr.Object;
                      D.109008 = D.109007 + 18446744073709551592;
                      D.109009 = MEM[(long int *)D.109008];
                      iftmp.96 = (sizetype) D.109009;
                      goto <D.109010>;
                      <D.109006>:
                      iftmp.96 = 24;
                      <D.109010>:
                      D.109011 = this + iftmp.96;
                      if (1 == 0) goto <D.109013>; else goto <D.109014>;
                      <D.109013>:
                      iftmp.97 = MEM[(const void * *)0B + 88B];
                      goto <D.109015>;
                      <D.109014>:
                      iftmp.97 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109015>:
                      D.109011->_vptr.ObjectBase = iftmp.97;
                      if (1 == 0) goto <D.109017>; else goto <D.109018>;
                      <D.109017>:
                      iftmp.98 = MEM[(const void * *)0B + 96B];
                      goto <D.109019>;
                      <D.109018>:
                      iftmp.98 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109019>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.98;
                      if (1 == 0) goto <D.109021>; else goto <D.109022>;
                      <D.109021>:
                      iftmp.99 = MEM[(const void * *)0B + 104B];
                      goto <D.109023>;
                      <D.109022>:
                      iftmp.99 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109023>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.99;
                      D.108993 = &this->D.101148;
                      Gio::Initable::init (D.108993, cancellable);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.109025>; else goto <D.109026>;
                      <D.109025>:
                      iftmp.100 = 56B;
                      goto <D.109027>;
                      <D.109026>:
                      iftmp.100 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109027>:
                      D.108998 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.108998, iftmp.100);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.109029>; else goto <D.109030>;
                  <D.109029>:
                  iftmp.101 = 24B;
                  goto <D.109031>;
                  <D.109030>:
                  iftmp.101 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109031>:
                  D.108993 = &this->D.101148;
                  Gio::Initable::~Initable (D.108993, iftmp.101);
                }
            }
          catch
            {
              if (1 == 0) goto <D.109033>; else goto <D.109034>;
              <D.109033>:
              iftmp.102 = 8B;
              goto <D.109035>;
              <D.109034>:
              iftmp.102 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109035>:
              D.108988 = &this->D.101147;
              Glib::Object::~Object (D.108988, iftmp.102);
            }
        }
      catch
        {
          if (1 != 0) goto <D.109036>; else goto <D.109037>;
          <D.109036>:
          if (1 == 0) goto <D.109039>; else goto <D.109040>;
          <D.109039>:
          iftmp.103 = 112B;
          goto <D.109041>;
          <D.109040>:
          iftmp.103 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109041>:
          D.108963 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.108963, iftmp.103);
          goto <D.109042>;
          <D.109037>:
          <D.109042>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.109043>; else goto <D.109044>;
      <D.109043>:
      D.108955 = &this->D.101154;
      sigc::trackable::~trackable (D.108955);
      goto <D.109045>;
      <D.109044>:
      <D.109045>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109063;
  const void * * iftmp.104;
  struct ObjectBase * D.109071;
  struct ConstructParams D.101678;
  const char * iftmp.105;
  bool D.109074;
  const char * iftmp.106;
  bool D.109079;
  const char * iftmp.107;
  bool D.109084;
  struct BaseObjectType * D.109088;
  int flags.108;
  struct BaseObjectType * D.109090;
  const struct Class & D.109091;
  const void * * iftmp.109;
  struct Object * D.109096;
  const void * * iftmp.110;
  struct Initable * D.109101;
  const void * * iftmp.111;
  struct AsyncInitable * D.109106;
  int (*__vtbl_ptr_type) () * iftmp.112;
  sizetype iftmp.113;
  int (*__vtbl_ptr_type) () * D.109114;
  int (*__vtbl_ptr_type) () * D.109115;
  long int D.109116;
  struct ObjectBase * D.109118;
  int (*__vtbl_ptr_type) () * iftmp.114;
  int (*__vtbl_ptr_type) () * iftmp.115;
  int (*__vtbl_ptr_type) () * iftmp.116;
  const void * * iftmp.117;
  const void * * iftmp.118;
  const void * * iftmp.119;
  const void * * iftmp.120;

  if (0 != 0) goto <D.109061>; else goto <D.109062>;
  <D.109061>:
  D.109063 = &this->D.101154;
  sigc::trackable::trackable (D.109063);
  goto <D.109064>;
  <D.109062>:
  <D.109064>:
  try
    {
      if (0 != 0) goto <D.109065>; else goto <D.109066>;
      <D.109065>:
      if (0 == 0) goto <D.109068>; else goto <D.109069>;
      <D.109068>:
      iftmp.104 = __vtt_parm + 112;
      goto <D.109070>;
      <D.109069>:
      iftmp.104 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109070>:
      D.109071 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109071, iftmp.104, 0B);
      goto <D.109072>;
      <D.109066>:
      <D.109072>:
      try
        {
          D.109074 = Glib::ustring::empty (interface_name);
          if (D.109074 != 0) goto <D.109075>; else goto <D.109076>;
          <D.109075>:
          iftmp.105 = 0B;
          goto <D.109077>;
          <D.109076>:
          iftmp.105 = Glib::ustring::c_str (interface_name);
          <D.109077>:
          D.109079 = Glib::ustring::empty (object_path);
          if (D.109079 != 0) goto <D.109080>; else goto <D.109081>;
          <D.109080>:
          iftmp.106 = 0B;
          goto <D.109082>;
          <D.109081>:
          iftmp.106 = Glib::ustring::c_str (object_path);
          <D.109082>:
          D.109084 = Glib::ustring::empty (name);
          if (D.109084 != 0) goto <D.109085>; else goto <D.109086>;
          <D.109085>:
          iftmp.107 = 0B;
          goto <D.109087>;
          <D.109086>:
          iftmp.107 = Glib::ustring::c_str (name);
          <D.109087>:
          D.109088 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.108 = (int) flags;
          D.109090 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.109091 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101678, D.109091, "g-connection", D.109090, "g-flags", flags.108, "g-interface-info", D.109088, "g-name", iftmp.107, "g-object-path", iftmp.106, "g-interface-name", iftmp.105, 0B);
          try
            {
              if (0 == 0) goto <D.109093>; else goto <D.109094>;
              <D.109093>:
              iftmp.109 = __vtt_parm + 8;
              goto <D.109095>;
              <D.109094>:
              iftmp.109 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109095>:
              D.109096 = &this->D.101147;
              Glib::Object::Object (D.109096, iftmp.109, &D.101678);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101678);
              D.101678 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.109098>; else goto <D.109099>;
              <D.109098>:
              iftmp.110 = __vtt_parm + 24;
              goto <D.109100>;
              <D.109099>:
              iftmp.110 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109100>:
              D.109101 = &this->D.101148;
              Gio::Initable::Initable (D.109101, iftmp.110);
              try
                {
                  if (0 == 0) goto <D.109103>; else goto <D.109104>;
                  <D.109103>:
                  iftmp.111 = __vtt_parm + 56;
                  goto <D.109105>;
                  <D.109104>:
                  iftmp.111 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109105>:
                  D.109106 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109106, iftmp.111);
                  try
                    {
                      if (0 == 0) goto <D.109108>; else goto <D.109109>;
                      <D.109108>:
                      iftmp.112 = *__vtt_parm;
                      goto <D.109110>;
                      <D.109109>:
                      iftmp.112 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109110>:
                      this->D.101147._vptr.Object = iftmp.112;
                      if (0 == 0) goto <D.109112>; else goto <D.109113>;
                      <D.109112>:
                      D.109114 = this->D.101147._vptr.Object;
                      D.109115 = D.109114 + 18446744073709551592;
                      D.109116 = MEM[(long int *)D.109115];
                      iftmp.113 = (sizetype) D.109116;
                      goto <D.109117>;
                      <D.109113>:
                      iftmp.113 = 24;
                      <D.109117>:
                      D.109118 = this + iftmp.113;
                      if (0 == 0) goto <D.109120>; else goto <D.109121>;
                      <D.109120>:
                      iftmp.114 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.109122>;
                      <D.109121>:
                      iftmp.114 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109122>:
                      D.109118->_vptr.ObjectBase = iftmp.114;
                      if (0 == 0) goto <D.109124>; else goto <D.109125>;
                      <D.109124>:
                      iftmp.115 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.109126>;
                      <D.109125>:
                      iftmp.115 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109126>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.115;
                      if (0 == 0) goto <D.109128>; else goto <D.109129>;
                      <D.109128>:
                      iftmp.116 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.109130>;
                      <D.109129>:
                      iftmp.116 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109130>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.116;
                      D.109101 = &this->D.101148;
                      Gio::Initable::init (D.109101);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.109132>; else goto <D.109133>;
                      <D.109132>:
                      iftmp.117 = __vtt_parm + 56;
                      goto <D.109134>;
                      <D.109133>:
                      iftmp.117 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109134>:
                      D.109106 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109106, iftmp.117);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.109136>; else goto <D.109137>;
                  <D.109136>:
                  iftmp.118 = __vtt_parm + 24;
                  goto <D.109138>;
                  <D.109137>:
                  iftmp.118 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109138>:
                  D.109101 = &this->D.101148;
                  Gio::Initable::~Initable (D.109101, iftmp.118);
                }
            }
          catch
            {
              if (0 == 0) goto <D.109140>; else goto <D.109141>;
              <D.109140>:
              iftmp.119 = __vtt_parm + 8;
              goto <D.109142>;
              <D.109141>:
              iftmp.119 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109142>:
              D.109096 = &this->D.101147;
              Glib::Object::~Object (D.109096, iftmp.119);
            }
        }
      catch
        {
          if (0 != 0) goto <D.109143>; else goto <D.109144>;
          <D.109143>:
          if (0 == 0) goto <D.109146>; else goto <D.109147>;
          <D.109146>:
          iftmp.120 = __vtt_parm + 112;
          goto <D.109148>;
          <D.109147>:
          iftmp.120 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109148>:
          D.109071 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109071, iftmp.120);
          goto <D.109149>;
          <D.109144>:
          <D.109149>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.109150>; else goto <D.109151>;
      <D.109150>:
      D.109063 = &this->D.101154;
      sigc::trackable::~trackable (D.109063);
      goto <D.109152>;
      <D.109151>:
      <D.109152>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109170;
  const void * * iftmp.121;
  struct ObjectBase * D.109178;
  struct ConstructParams D.101680;
  const char * iftmp.122;
  bool D.109181;
  const char * iftmp.123;
  bool D.109186;
  const char * iftmp.124;
  bool D.109191;
  struct BaseObjectType * D.109195;
  int flags.125;
  struct BaseObjectType * D.109197;
  const struct Class & D.109198;
  const void * * iftmp.126;
  struct Object * D.109203;
  const void * * iftmp.127;
  struct Initable * D.109208;
  const void * * iftmp.128;
  struct AsyncInitable * D.109213;
  int (*__vtbl_ptr_type) () * iftmp.129;
  const void * * D.109217;
  sizetype iftmp.130;
  int (*__vtbl_ptr_type) () * D.109222;
  int (*__vtbl_ptr_type) () * D.109223;
  long int D.109224;
  struct ObjectBase * D.109226;
  int (*__vtbl_ptr_type) () * iftmp.131;
  int (*__vtbl_ptr_type) () * iftmp.132;
  int (*__vtbl_ptr_type) () * iftmp.133;
  const void * * iftmp.134;
  const void * * iftmp.135;
  const void * * iftmp.136;
  const void * * iftmp.137;

  if (1 != 0) goto <D.109168>; else goto <D.109169>;
  <D.109168>:
  D.109170 = &this->D.101154;
  sigc::trackable::trackable (D.109170);
  goto <D.109171>;
  <D.109169>:
  <D.109171>:
  try
    {
      if (1 != 0) goto <D.109172>; else goto <D.109173>;
      <D.109172>:
      if (1 == 0) goto <D.109175>; else goto <D.109176>;
      <D.109175>:
      iftmp.121 = 112B;
      goto <D.109177>;
      <D.109176>:
      iftmp.121 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109177>:
      D.109178 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109178, iftmp.121, 0B);
      goto <D.109179>;
      <D.109173>:
      <D.109179>:
      try
        {
          D.109181 = Glib::ustring::empty (interface_name);
          if (D.109181 != 0) goto <D.109182>; else goto <D.109183>;
          <D.109182>:
          iftmp.122 = 0B;
          goto <D.109184>;
          <D.109183>:
          iftmp.122 = Glib::ustring::c_str (interface_name);
          <D.109184>:
          D.109186 = Glib::ustring::empty (object_path);
          if (D.109186 != 0) goto <D.109187>; else goto <D.109188>;
          <D.109187>:
          iftmp.123 = 0B;
          goto <D.109189>;
          <D.109188>:
          iftmp.123 = Glib::ustring::c_str (object_path);
          <D.109189>:
          D.109191 = Glib::ustring::empty (name);
          if (D.109191 != 0) goto <D.109192>; else goto <D.109193>;
          <D.109192>:
          iftmp.124 = 0B;
          goto <D.109194>;
          <D.109193>:
          iftmp.124 = Glib::ustring::c_str (name);
          <D.109194>:
          D.109195 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.125 = (int) flags;
          D.109197 = Glib::unwrap<Gio::DBus::Connection> (connection);
          D.109198 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101680, D.109198, "g-connection", D.109197, "g-flags", flags.125, "g-interface-info", D.109195, "g-name", iftmp.124, "g-object-path", iftmp.123, "g-interface-name", iftmp.122, 0B);
          try
            {
              if (1 == 0) goto <D.109200>; else goto <D.109201>;
              <D.109200>:
              iftmp.126 = 8B;
              goto <D.109202>;
              <D.109201>:
              iftmp.126 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109202>:
              D.109203 = &this->D.101147;
              Glib::Object::Object (D.109203, iftmp.126, &D.101680);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101680);
              D.101680 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.109205>; else goto <D.109206>;
              <D.109205>:
              iftmp.127 = 24B;
              goto <D.109207>;
              <D.109206>:
              iftmp.127 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109207>:
              D.109208 = &this->D.101148;
              Gio::Initable::Initable (D.109208, iftmp.127);
              try
                {
                  if (1 == 0) goto <D.109210>; else goto <D.109211>;
                  <D.109210>:
                  iftmp.128 = 56B;
                  goto <D.109212>;
                  <D.109211>:
                  iftmp.128 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109212>:
                  D.109213 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109213, iftmp.128);
                  try
                    {
                      if (1 == 0) goto <D.109215>; else goto <D.109216>;
                      <D.109215>:
                      D.109217 = 0B;
                      iftmp.129 = *D.109217;
                      goto <D.109218>;
                      <D.109216>:
                      iftmp.129 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109218>:
                      this->D.101147._vptr.Object = iftmp.129;
                      if (1 == 0) goto <D.109220>; else goto <D.109221>;
                      <D.109220>:
                      D.109222 = this->D.101147._vptr.Object;
                      D.109223 = D.109222 + 18446744073709551592;
                      D.109224 = MEM[(long int *)D.109223];
                      iftmp.130 = (sizetype) D.109224;
                      goto <D.109225>;
                      <D.109221>:
                      iftmp.130 = 24;
                      <D.109225>:
                      D.109226 = this + iftmp.130;
                      if (1 == 0) goto <D.109228>; else goto <D.109229>;
                      <D.109228>:
                      iftmp.131 = MEM[(const void * *)0B + 88B];
                      goto <D.109230>;
                      <D.109229>:
                      iftmp.131 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109230>:
                      D.109226->_vptr.ObjectBase = iftmp.131;
                      if (1 == 0) goto <D.109232>; else goto <D.109233>;
                      <D.109232>:
                      iftmp.132 = MEM[(const void * *)0B + 96B];
                      goto <D.109234>;
                      <D.109233>:
                      iftmp.132 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109234>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.132;
                      if (1 == 0) goto <D.109236>; else goto <D.109237>;
                      <D.109236>:
                      iftmp.133 = MEM[(const void * *)0B + 104B];
                      goto <D.109238>;
                      <D.109237>:
                      iftmp.133 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109238>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.133;
                      D.109208 = &this->D.101148;
                      Gio::Initable::init (D.109208);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.109240>; else goto <D.109241>;
                      <D.109240>:
                      iftmp.134 = 56B;
                      goto <D.109242>;
                      <D.109241>:
                      iftmp.134 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109242>:
                      D.109213 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109213, iftmp.134);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.109244>; else goto <D.109245>;
                  <D.109244>:
                  iftmp.135 = 24B;
                  goto <D.109246>;
                  <D.109245>:
                  iftmp.135 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109246>:
                  D.109208 = &this->D.101148;
                  Gio::Initable::~Initable (D.109208, iftmp.135);
                }
            }
          catch
            {
              if (1 == 0) goto <D.109248>; else goto <D.109249>;
              <D.109248>:
              iftmp.136 = 8B;
              goto <D.109250>;
              <D.109249>:
              iftmp.136 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109250>:
              D.109203 = &this->D.101147;
              Glib::Object::~Object (D.109203, iftmp.136);
            }
        }
      catch
        {
          if (1 != 0) goto <D.109251>; else goto <D.109252>;
          <D.109251>:
          if (1 == 0) goto <D.109254>; else goto <D.109255>;
          <D.109254>:
          iftmp.137 = 112B;
          goto <D.109256>;
          <D.109255>:
          iftmp.137 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109256>:
          D.109178 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109178, iftmp.137);
          goto <D.109257>;
          <D.109252>:
          <D.109257>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.109258>; else goto <D.109259>;
      <D.109258>:
      D.109170 = &this->D.101154;
      sigc::trackable::~trackable (D.109170);
      goto <D.109260>;
      <D.109259>:
      <D.109260>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109278;
  const void * * iftmp.138;
  struct ObjectBase * D.109286;
  struct ConstructParams D.101696;
  const char * iftmp.139;
  bool D.109289;
  const char * iftmp.140;
  bool D.109294;
  const char * iftmp.141;
  bool D.109299;
  struct BaseObjectType * D.109303;
  int flags.142;
  const struct Class & D.109305;
  const void * * iftmp.143;
  struct Object * D.109310;
  const void * * iftmp.144;
  struct Initable * D.109315;
  const void * * iftmp.145;
  struct AsyncInitable * D.109320;
  int (*__vtbl_ptr_type) () * iftmp.146;
  sizetype iftmp.147;
  int (*__vtbl_ptr_type) () * D.109328;
  int (*__vtbl_ptr_type) () * D.109329;
  long int D.109330;
  struct ObjectBase * D.109332;
  int (*__vtbl_ptr_type) () * iftmp.148;
  int (*__vtbl_ptr_type) () * iftmp.149;
  int (*__vtbl_ptr_type) () * iftmp.150;
  const void * * iftmp.151;
  const void * * iftmp.152;
  const void * * iftmp.153;
  const void * * iftmp.154;

  if (0 != 0) goto <D.109276>; else goto <D.109277>;
  <D.109276>:
  D.109278 = &this->D.101154;
  sigc::trackable::trackable (D.109278);
  goto <D.109279>;
  <D.109277>:
  <D.109279>:
  try
    {
      if (0 != 0) goto <D.109280>; else goto <D.109281>;
      <D.109280>:
      if (0 == 0) goto <D.109283>; else goto <D.109284>;
      <D.109283>:
      iftmp.138 = __vtt_parm + 112;
      goto <D.109285>;
      <D.109284>:
      iftmp.138 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109285>:
      D.109286 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109286, iftmp.138, 0B);
      goto <D.109287>;
      <D.109281>:
      <D.109287>:
      try
        {
          D.109289 = Glib::ustring::empty (interface_name);
          if (D.109289 != 0) goto <D.109290>; else goto <D.109291>;
          <D.109290>:
          iftmp.139 = 0B;
          goto <D.109292>;
          <D.109291>:
          iftmp.139 = Glib::ustring::c_str (interface_name);
          <D.109292>:
          D.109294 = Glib::ustring::empty (object_path);
          if (D.109294 != 0) goto <D.109295>; else goto <D.109296>;
          <D.109295>:
          iftmp.140 = 0B;
          goto <D.109297>;
          <D.109296>:
          iftmp.140 = Glib::ustring::c_str (object_path);
          <D.109297>:
          D.109299 = Glib::ustring::empty (name);
          if (D.109299 != 0) goto <D.109300>; else goto <D.109301>;
          <D.109300>:
          iftmp.141 = 0B;
          goto <D.109302>;
          <D.109301>:
          iftmp.141 = Glib::ustring::c_str (name);
          <D.109302>:
          D.109303 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.142 = (int) flags;
          D.109305 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101696, D.109305, "g-bus-type", bus_type, "g-flags", flags.142, "g-interface-info", D.109303, "g-name", iftmp.141, "g-object-path", iftmp.140, "g-interface-name", iftmp.139, 0B);
          try
            {
              if (0 == 0) goto <D.109307>; else goto <D.109308>;
              <D.109307>:
              iftmp.143 = __vtt_parm + 8;
              goto <D.109309>;
              <D.109308>:
              iftmp.143 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109309>:
              D.109310 = &this->D.101147;
              Glib::Object::Object (D.109310, iftmp.143, &D.101696);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101696);
              D.101696 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.109312>; else goto <D.109313>;
              <D.109312>:
              iftmp.144 = __vtt_parm + 24;
              goto <D.109314>;
              <D.109313>:
              iftmp.144 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109314>:
              D.109315 = &this->D.101148;
              Gio::Initable::Initable (D.109315, iftmp.144);
              try
                {
                  if (0 == 0) goto <D.109317>; else goto <D.109318>;
                  <D.109317>:
                  iftmp.145 = __vtt_parm + 56;
                  goto <D.109319>;
                  <D.109318>:
                  iftmp.145 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109319>:
                  D.109320 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109320, iftmp.145);
                  try
                    {
                      if (0 == 0) goto <D.109322>; else goto <D.109323>;
                      <D.109322>:
                      iftmp.146 = *__vtt_parm;
                      goto <D.109324>;
                      <D.109323>:
                      iftmp.146 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109324>:
                      this->D.101147._vptr.Object = iftmp.146;
                      if (0 == 0) goto <D.109326>; else goto <D.109327>;
                      <D.109326>:
                      D.109328 = this->D.101147._vptr.Object;
                      D.109329 = D.109328 + 18446744073709551592;
                      D.109330 = MEM[(long int *)D.109329];
                      iftmp.147 = (sizetype) D.109330;
                      goto <D.109331>;
                      <D.109327>:
                      iftmp.147 = 24;
                      <D.109331>:
                      D.109332 = this + iftmp.147;
                      if (0 == 0) goto <D.109334>; else goto <D.109335>;
                      <D.109334>:
                      iftmp.148 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.109336>;
                      <D.109335>:
                      iftmp.148 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109336>:
                      D.109332->_vptr.ObjectBase = iftmp.148;
                      if (0 == 0) goto <D.109338>; else goto <D.109339>;
                      <D.109338>:
                      iftmp.149 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.109340>;
                      <D.109339>:
                      iftmp.149 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109340>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.149;
                      if (0 == 0) goto <D.109342>; else goto <D.109343>;
                      <D.109342>:
                      iftmp.150 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.109344>;
                      <D.109343>:
                      iftmp.150 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109344>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.150;
                      D.109320 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.109320, slot, cancellable, 0);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.109346>; else goto <D.109347>;
                      <D.109346>:
                      iftmp.151 = __vtt_parm + 56;
                      goto <D.109348>;
                      <D.109347>:
                      iftmp.151 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109348>:
                      D.109320 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109320, iftmp.151);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.109350>; else goto <D.109351>;
                  <D.109350>:
                  iftmp.152 = __vtt_parm + 24;
                  goto <D.109352>;
                  <D.109351>:
                  iftmp.152 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109352>:
                  D.109315 = &this->D.101148;
                  Gio::Initable::~Initable (D.109315, iftmp.152);
                }
            }
          catch
            {
              if (0 == 0) goto <D.109354>; else goto <D.109355>;
              <D.109354>:
              iftmp.153 = __vtt_parm + 8;
              goto <D.109356>;
              <D.109355>:
              iftmp.153 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109356>:
              D.109310 = &this->D.101147;
              Glib::Object::~Object (D.109310, iftmp.153);
            }
        }
      catch
        {
          if (0 != 0) goto <D.109357>; else goto <D.109358>;
          <D.109357>:
          if (0 == 0) goto <D.109360>; else goto <D.109361>;
          <D.109360>:
          iftmp.154 = __vtt_parm + 112;
          goto <D.109362>;
          <D.109361>:
          iftmp.154 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109362>:
          D.109286 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109286, iftmp.154);
          goto <D.109363>;
          <D.109358>:
          <D.109363>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.109364>; else goto <D.109365>;
      <D.109364>:
      D.109278 = &this->D.101154;
      sigc::trackable::~trackable (D.109278);
      goto <D.109366>;
      <D.109365>:
      <D.109366>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109383;
  const void * * iftmp.155;
  struct ObjectBase * D.109391;
  struct ConstructParams D.101698;
  const char * iftmp.156;
  bool D.109394;
  const char * iftmp.157;
  bool D.109399;
  const char * iftmp.158;
  bool D.109404;
  struct BaseObjectType * D.109408;
  int flags.159;
  const struct Class & D.109410;
  const void * * iftmp.160;
  struct Object * D.109415;
  const void * * iftmp.161;
  struct Initable * D.109420;
  const void * * iftmp.162;
  struct AsyncInitable * D.109425;
  int (*__vtbl_ptr_type) () * iftmp.163;
  const void * * D.109429;
  sizetype iftmp.164;
  int (*__vtbl_ptr_type) () * D.109434;
  int (*__vtbl_ptr_type) () * D.109435;
  long int D.109436;
  struct ObjectBase * D.109438;
  int (*__vtbl_ptr_type) () * iftmp.165;
  int (*__vtbl_ptr_type) () * iftmp.166;
  int (*__vtbl_ptr_type) () * iftmp.167;
  const void * * iftmp.168;
  const void * * iftmp.169;
  const void * * iftmp.170;
  const void * * iftmp.171;

  if (1 != 0) goto <D.109381>; else goto <D.109382>;
  <D.109381>:
  D.109383 = &this->D.101154;
  sigc::trackable::trackable (D.109383);
  goto <D.109384>;
  <D.109382>:
  <D.109384>:
  try
    {
      if (1 != 0) goto <D.109385>; else goto <D.109386>;
      <D.109385>:
      if (1 == 0) goto <D.109388>; else goto <D.109389>;
      <D.109388>:
      iftmp.155 = 112B;
      goto <D.109390>;
      <D.109389>:
      iftmp.155 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109390>:
      D.109391 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109391, iftmp.155, 0B);
      goto <D.109392>;
      <D.109386>:
      <D.109392>:
      try
        {
          D.109394 = Glib::ustring::empty (interface_name);
          if (D.109394 != 0) goto <D.109395>; else goto <D.109396>;
          <D.109395>:
          iftmp.156 = 0B;
          goto <D.109397>;
          <D.109396>:
          iftmp.156 = Glib::ustring::c_str (interface_name);
          <D.109397>:
          D.109399 = Glib::ustring::empty (object_path);
          if (D.109399 != 0) goto <D.109400>; else goto <D.109401>;
          <D.109400>:
          iftmp.157 = 0B;
          goto <D.109402>;
          <D.109401>:
          iftmp.157 = Glib::ustring::c_str (object_path);
          <D.109402>:
          D.109404 = Glib::ustring::empty (name);
          if (D.109404 != 0) goto <D.109405>; else goto <D.109406>;
          <D.109405>:
          iftmp.158 = 0B;
          goto <D.109407>;
          <D.109406>:
          iftmp.158 = Glib::ustring::c_str (name);
          <D.109407>:
          D.109408 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.159 = (int) flags;
          D.109410 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101698, D.109410, "g-bus-type", bus_type, "g-flags", flags.159, "g-interface-info", D.109408, "g-name", iftmp.158, "g-object-path", iftmp.157, "g-interface-name", iftmp.156, 0B);
          try
            {
              if (1 == 0) goto <D.109412>; else goto <D.109413>;
              <D.109412>:
              iftmp.160 = 8B;
              goto <D.109414>;
              <D.109413>:
              iftmp.160 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109414>:
              D.109415 = &this->D.101147;
              Glib::Object::Object (D.109415, iftmp.160, &D.101698);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101698);
              D.101698 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.109417>; else goto <D.109418>;
              <D.109417>:
              iftmp.161 = 24B;
              goto <D.109419>;
              <D.109418>:
              iftmp.161 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109419>:
              D.109420 = &this->D.101148;
              Gio::Initable::Initable (D.109420, iftmp.161);
              try
                {
                  if (1 == 0) goto <D.109422>; else goto <D.109423>;
                  <D.109422>:
                  iftmp.162 = 56B;
                  goto <D.109424>;
                  <D.109423>:
                  iftmp.162 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109424>:
                  D.109425 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109425, iftmp.162);
                  try
                    {
                      if (1 == 0) goto <D.109427>; else goto <D.109428>;
                      <D.109427>:
                      D.109429 = 0B;
                      iftmp.163 = *D.109429;
                      goto <D.109430>;
                      <D.109428>:
                      iftmp.163 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109430>:
                      this->D.101147._vptr.Object = iftmp.163;
                      if (1 == 0) goto <D.109432>; else goto <D.109433>;
                      <D.109432>:
                      D.109434 = this->D.101147._vptr.Object;
                      D.109435 = D.109434 + 18446744073709551592;
                      D.109436 = MEM[(long int *)D.109435];
                      iftmp.164 = (sizetype) D.109436;
                      goto <D.109437>;
                      <D.109433>:
                      iftmp.164 = 24;
                      <D.109437>:
                      D.109438 = this + iftmp.164;
                      if (1 == 0) goto <D.109440>; else goto <D.109441>;
                      <D.109440>:
                      iftmp.165 = MEM[(const void * *)0B + 88B];
                      goto <D.109442>;
                      <D.109441>:
                      iftmp.165 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109442>:
                      D.109438->_vptr.ObjectBase = iftmp.165;
                      if (1 == 0) goto <D.109444>; else goto <D.109445>;
                      <D.109444>:
                      iftmp.166 = MEM[(const void * *)0B + 96B];
                      goto <D.109446>;
                      <D.109445>:
                      iftmp.166 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109446>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.166;
                      if (1 == 0) goto <D.109448>; else goto <D.109449>;
                      <D.109448>:
                      iftmp.167 = MEM[(const void * *)0B + 104B];
                      goto <D.109450>;
                      <D.109449>:
                      iftmp.167 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109450>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.167;
                      D.109425 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.109425, slot, cancellable, 0);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.109452>; else goto <D.109453>;
                      <D.109452>:
                      iftmp.168 = 56B;
                      goto <D.109454>;
                      <D.109453>:
                      iftmp.168 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109454>:
                      D.109425 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109425, iftmp.168);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.109456>; else goto <D.109457>;
                  <D.109456>:
                  iftmp.169 = 24B;
                  goto <D.109458>;
                  <D.109457>:
                  iftmp.169 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109458>:
                  D.109420 = &this->D.101148;
                  Gio::Initable::~Initable (D.109420, iftmp.169);
                }
            }
          catch
            {
              if (1 == 0) goto <D.109460>; else goto <D.109461>;
              <D.109460>:
              iftmp.170 = 8B;
              goto <D.109462>;
              <D.109461>:
              iftmp.170 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109462>:
              D.109415 = &this->D.101147;
              Glib::Object::~Object (D.109415, iftmp.170);
            }
        }
      catch
        {
          if (1 != 0) goto <D.109463>; else goto <D.109464>;
          <D.109463>:
          if (1 == 0) goto <D.109466>; else goto <D.109467>;
          <D.109466>:
          iftmp.171 = 112B;
          goto <D.109468>;
          <D.109467>:
          iftmp.171 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109468>:
          D.109391 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109391, iftmp.171);
          goto <D.109469>;
          <D.109464>:
          <D.109469>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.109470>; else goto <D.109471>;
      <D.109470>:
      D.109383 = &this->D.101154;
      sigc::trackable::~trackable (D.109383);
      goto <D.109472>;
      <D.109471>:
      <D.109472>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109489;
  const void * * iftmp.172;
  struct ObjectBase * D.109497;
  struct ConstructParams D.101713;
  const char * iftmp.173;
  bool D.109500;
  const char * iftmp.174;
  bool D.109505;
  const char * iftmp.175;
  bool D.109510;
  struct BaseObjectType * D.109514;
  int flags.176;
  const struct Class & D.109516;
  const void * * iftmp.177;
  struct Object * D.109521;
  const void * * iftmp.178;
  struct Initable * D.109526;
  const void * * iftmp.179;
  struct AsyncInitable * D.109531;
  int (*__vtbl_ptr_type) () * iftmp.180;
  sizetype iftmp.181;
  int (*__vtbl_ptr_type) () * D.109539;
  int (*__vtbl_ptr_type) () * D.109540;
  long int D.109541;
  struct ObjectBase * D.109543;
  int (*__vtbl_ptr_type) () * iftmp.182;
  int (*__vtbl_ptr_type) () * iftmp.183;
  int (*__vtbl_ptr_type) () * iftmp.184;
  const void * * iftmp.185;
  const void * * iftmp.186;
  const void * * iftmp.187;
  const void * * iftmp.188;

  if (0 != 0) goto <D.109487>; else goto <D.109488>;
  <D.109487>:
  D.109489 = &this->D.101154;
  sigc::trackable::trackable (D.109489);
  goto <D.109490>;
  <D.109488>:
  <D.109490>:
  try
    {
      if (0 != 0) goto <D.109491>; else goto <D.109492>;
      <D.109491>:
      if (0 == 0) goto <D.109494>; else goto <D.109495>;
      <D.109494>:
      iftmp.172 = __vtt_parm + 112;
      goto <D.109496>;
      <D.109495>:
      iftmp.172 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109496>:
      D.109497 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109497, iftmp.172, 0B);
      goto <D.109498>;
      <D.109492>:
      <D.109498>:
      try
        {
          D.109500 = Glib::ustring::empty (interface_name);
          if (D.109500 != 0) goto <D.109501>; else goto <D.109502>;
          <D.109501>:
          iftmp.173 = 0B;
          goto <D.109503>;
          <D.109502>:
          iftmp.173 = Glib::ustring::c_str (interface_name);
          <D.109503>:
          D.109505 = Glib::ustring::empty (object_path);
          if (D.109505 != 0) goto <D.109506>; else goto <D.109507>;
          <D.109506>:
          iftmp.174 = 0B;
          goto <D.109508>;
          <D.109507>:
          iftmp.174 = Glib::ustring::c_str (object_path);
          <D.109508>:
          D.109510 = Glib::ustring::empty (name);
          if (D.109510 != 0) goto <D.109511>; else goto <D.109512>;
          <D.109511>:
          iftmp.175 = 0B;
          goto <D.109513>;
          <D.109512>:
          iftmp.175 = Glib::ustring::c_str (name);
          <D.109513>:
          D.109514 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.176 = (int) flags;
          D.109516 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101713, D.109516, "g-bus-type", bus_type, "g-flags", flags.176, "g-interface-info", D.109514, "g-name", iftmp.175, "g-object-path", iftmp.174, "g-interface-name", iftmp.173, 0B);
          try
            {
              if (0 == 0) goto <D.109518>; else goto <D.109519>;
              <D.109518>:
              iftmp.177 = __vtt_parm + 8;
              goto <D.109520>;
              <D.109519>:
              iftmp.177 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109520>:
              D.109521 = &this->D.101147;
              Glib::Object::Object (D.109521, iftmp.177, &D.101713);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101713);
              D.101713 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.109523>; else goto <D.109524>;
              <D.109523>:
              iftmp.178 = __vtt_parm + 24;
              goto <D.109525>;
              <D.109524>:
              iftmp.178 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109525>:
              D.109526 = &this->D.101148;
              Gio::Initable::Initable (D.109526, iftmp.178);
              try
                {
                  if (0 == 0) goto <D.109528>; else goto <D.109529>;
                  <D.109528>:
                  iftmp.179 = __vtt_parm + 56;
                  goto <D.109530>;
                  <D.109529>:
                  iftmp.179 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109530>:
                  D.109531 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109531, iftmp.179);
                  try
                    {
                      if (0 == 0) goto <D.109533>; else goto <D.109534>;
                      <D.109533>:
                      iftmp.180 = *__vtt_parm;
                      goto <D.109535>;
                      <D.109534>:
                      iftmp.180 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109535>:
                      this->D.101147._vptr.Object = iftmp.180;
                      if (0 == 0) goto <D.109537>; else goto <D.109538>;
                      <D.109537>:
                      D.109539 = this->D.101147._vptr.Object;
                      D.109540 = D.109539 + 18446744073709551592;
                      D.109541 = MEM[(long int *)D.109540];
                      iftmp.181 = (sizetype) D.109541;
                      goto <D.109542>;
                      <D.109538>:
                      iftmp.181 = 24;
                      <D.109542>:
                      D.109543 = this + iftmp.181;
                      if (0 == 0) goto <D.109545>; else goto <D.109546>;
                      <D.109545>:
                      iftmp.182 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.109547>;
                      <D.109546>:
                      iftmp.182 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109547>:
                      D.109543->_vptr.ObjectBase = iftmp.182;
                      if (0 == 0) goto <D.109549>; else goto <D.109550>;
                      <D.109549>:
                      iftmp.183 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.109551>;
                      <D.109550>:
                      iftmp.183 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109551>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.183;
                      if (0 == 0) goto <D.109553>; else goto <D.109554>;
                      <D.109553>:
                      iftmp.184 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.109555>;
                      <D.109554>:
                      iftmp.184 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109555>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.184;
                      D.109531 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.109531, slot, 0);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.109557>; else goto <D.109558>;
                      <D.109557>:
                      iftmp.185 = __vtt_parm + 56;
                      goto <D.109559>;
                      <D.109558>:
                      iftmp.185 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109559>:
                      D.109531 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109531, iftmp.185);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.109561>; else goto <D.109562>;
                  <D.109561>:
                  iftmp.186 = __vtt_parm + 24;
                  goto <D.109563>;
                  <D.109562>:
                  iftmp.186 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109563>:
                  D.109526 = &this->D.101148;
                  Gio::Initable::~Initable (D.109526, iftmp.186);
                }
            }
          catch
            {
              if (0 == 0) goto <D.109565>; else goto <D.109566>;
              <D.109565>:
              iftmp.187 = __vtt_parm + 8;
              goto <D.109567>;
              <D.109566>:
              iftmp.187 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109567>:
              D.109521 = &this->D.101147;
              Glib::Object::~Object (D.109521, iftmp.187);
            }
        }
      catch
        {
          if (0 != 0) goto <D.109568>; else goto <D.109569>;
          <D.109568>:
          if (0 == 0) goto <D.109571>; else goto <D.109572>;
          <D.109571>:
          iftmp.188 = __vtt_parm + 112;
          goto <D.109573>;
          <D.109572>:
          iftmp.188 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109573>:
          D.109497 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109497, iftmp.188);
          goto <D.109574>;
          <D.109569>:
          <D.109574>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.109575>; else goto <D.109576>;
      <D.109575>:
      D.109489 = &this->D.101154;
      sigc::trackable::~trackable (D.109489);
      goto <D.109577>;
      <D.109576>:
      <D.109577>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109594;
  const void * * iftmp.189;
  struct ObjectBase * D.109602;
  struct ConstructParams D.101715;
  const char * iftmp.190;
  bool D.109605;
  const char * iftmp.191;
  bool D.109610;
  const char * iftmp.192;
  bool D.109615;
  struct BaseObjectType * D.109619;
  int flags.193;
  const struct Class & D.109621;
  const void * * iftmp.194;
  struct Object * D.109626;
  const void * * iftmp.195;
  struct Initable * D.109631;
  const void * * iftmp.196;
  struct AsyncInitable * D.109636;
  int (*__vtbl_ptr_type) () * iftmp.197;
  const void * * D.109640;
  sizetype iftmp.198;
  int (*__vtbl_ptr_type) () * D.109645;
  int (*__vtbl_ptr_type) () * D.109646;
  long int D.109647;
  struct ObjectBase * D.109649;
  int (*__vtbl_ptr_type) () * iftmp.199;
  int (*__vtbl_ptr_type) () * iftmp.200;
  int (*__vtbl_ptr_type) () * iftmp.201;
  const void * * iftmp.202;
  const void * * iftmp.203;
  const void * * iftmp.204;
  const void * * iftmp.205;

  if (1 != 0) goto <D.109592>; else goto <D.109593>;
  <D.109592>:
  D.109594 = &this->D.101154;
  sigc::trackable::trackable (D.109594);
  goto <D.109595>;
  <D.109593>:
  <D.109595>:
  try
    {
      if (1 != 0) goto <D.109596>; else goto <D.109597>;
      <D.109596>:
      if (1 == 0) goto <D.109599>; else goto <D.109600>;
      <D.109599>:
      iftmp.189 = 112B;
      goto <D.109601>;
      <D.109600>:
      iftmp.189 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109601>:
      D.109602 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109602, iftmp.189, 0B);
      goto <D.109603>;
      <D.109597>:
      <D.109603>:
      try
        {
          D.109605 = Glib::ustring::empty (interface_name);
          if (D.109605 != 0) goto <D.109606>; else goto <D.109607>;
          <D.109606>:
          iftmp.190 = 0B;
          goto <D.109608>;
          <D.109607>:
          iftmp.190 = Glib::ustring::c_str (interface_name);
          <D.109608>:
          D.109610 = Glib::ustring::empty (object_path);
          if (D.109610 != 0) goto <D.109611>; else goto <D.109612>;
          <D.109611>:
          iftmp.191 = 0B;
          goto <D.109613>;
          <D.109612>:
          iftmp.191 = Glib::ustring::c_str (object_path);
          <D.109613>:
          D.109615 = Glib::ustring::empty (name);
          if (D.109615 != 0) goto <D.109616>; else goto <D.109617>;
          <D.109616>:
          iftmp.192 = 0B;
          goto <D.109618>;
          <D.109617>:
          iftmp.192 = Glib::ustring::c_str (name);
          <D.109618>:
          D.109619 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.193 = (int) flags;
          D.109621 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101715, D.109621, "g-bus-type", bus_type, "g-flags", flags.193, "g-interface-info", D.109619, "g-name", iftmp.192, "g-object-path", iftmp.191, "g-interface-name", iftmp.190, 0B);
          try
            {
              if (1 == 0) goto <D.109623>; else goto <D.109624>;
              <D.109623>:
              iftmp.194 = 8B;
              goto <D.109625>;
              <D.109624>:
              iftmp.194 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109625>:
              D.109626 = &this->D.101147;
              Glib::Object::Object (D.109626, iftmp.194, &D.101715);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101715);
              D.101715 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.109628>; else goto <D.109629>;
              <D.109628>:
              iftmp.195 = 24B;
              goto <D.109630>;
              <D.109629>:
              iftmp.195 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109630>:
              D.109631 = &this->D.101148;
              Gio::Initable::Initable (D.109631, iftmp.195);
              try
                {
                  if (1 == 0) goto <D.109633>; else goto <D.109634>;
                  <D.109633>:
                  iftmp.196 = 56B;
                  goto <D.109635>;
                  <D.109634>:
                  iftmp.196 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109635>:
                  D.109636 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109636, iftmp.196);
                  try
                    {
                      if (1 == 0) goto <D.109638>; else goto <D.109639>;
                      <D.109638>:
                      D.109640 = 0B;
                      iftmp.197 = *D.109640;
                      goto <D.109641>;
                      <D.109639>:
                      iftmp.197 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109641>:
                      this->D.101147._vptr.Object = iftmp.197;
                      if (1 == 0) goto <D.109643>; else goto <D.109644>;
                      <D.109643>:
                      D.109645 = this->D.101147._vptr.Object;
                      D.109646 = D.109645 + 18446744073709551592;
                      D.109647 = MEM[(long int *)D.109646];
                      iftmp.198 = (sizetype) D.109647;
                      goto <D.109648>;
                      <D.109644>:
                      iftmp.198 = 24;
                      <D.109648>:
                      D.109649 = this + iftmp.198;
                      if (1 == 0) goto <D.109651>; else goto <D.109652>;
                      <D.109651>:
                      iftmp.199 = MEM[(const void * *)0B + 88B];
                      goto <D.109653>;
                      <D.109652>:
                      iftmp.199 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109653>:
                      D.109649->_vptr.ObjectBase = iftmp.199;
                      if (1 == 0) goto <D.109655>; else goto <D.109656>;
                      <D.109655>:
                      iftmp.200 = MEM[(const void * *)0B + 96B];
                      goto <D.109657>;
                      <D.109656>:
                      iftmp.200 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109657>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.200;
                      if (1 == 0) goto <D.109659>; else goto <D.109660>;
                      <D.109659>:
                      iftmp.201 = MEM[(const void * *)0B + 104B];
                      goto <D.109661>;
                      <D.109660>:
                      iftmp.201 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109661>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.201;
                      D.109636 = &this->D.101149;
                      Gio::AsyncInitable::init_async (D.109636, slot, 0);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.109663>; else goto <D.109664>;
                      <D.109663>:
                      iftmp.202 = 56B;
                      goto <D.109665>;
                      <D.109664>:
                      iftmp.202 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109665>:
                      D.109636 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109636, iftmp.202);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.109667>; else goto <D.109668>;
                  <D.109667>:
                  iftmp.203 = 24B;
                  goto <D.109669>;
                  <D.109668>:
                  iftmp.203 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109669>:
                  D.109631 = &this->D.101148;
                  Gio::Initable::~Initable (D.109631, iftmp.203);
                }
            }
          catch
            {
              if (1 == 0) goto <D.109671>; else goto <D.109672>;
              <D.109671>:
              iftmp.204 = 8B;
              goto <D.109673>;
              <D.109672>:
              iftmp.204 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109673>:
              D.109626 = &this->D.101147;
              Glib::Object::~Object (D.109626, iftmp.204);
            }
        }
      catch
        {
          if (1 != 0) goto <D.109674>; else goto <D.109675>;
          <D.109674>:
          if (1 == 0) goto <D.109677>; else goto <D.109678>;
          <D.109677>:
          iftmp.205 = 112B;
          goto <D.109679>;
          <D.109678>:
          iftmp.205 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109679>:
          D.109602 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109602, iftmp.205);
          goto <D.109680>;
          <D.109675>:
          <D.109680>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.109681>; else goto <D.109682>;
      <D.109681>:
      D.109594 = &this->D.101154;
      sigc::trackable::~trackable (D.109594);
      goto <D.109683>;
      <D.109682>:
      <D.109683>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109700;
  const void * * iftmp.206;
  struct ObjectBase * D.109708;
  struct ConstructParams D.101730;
  const char * iftmp.207;
  bool D.109711;
  const char * iftmp.208;
  bool D.109716;
  const char * iftmp.209;
  bool D.109721;
  struct BaseObjectType * D.109725;
  int flags.210;
  const struct Class & D.109727;
  const void * * iftmp.211;
  struct Object * D.109732;
  const void * * iftmp.212;
  struct Initable * D.109737;
  const void * * iftmp.213;
  struct AsyncInitable * D.109742;
  int (*__vtbl_ptr_type) () * iftmp.214;
  sizetype iftmp.215;
  int (*__vtbl_ptr_type) () * D.109750;
  int (*__vtbl_ptr_type) () * D.109751;
  long int D.109752;
  struct ObjectBase * D.109754;
  int (*__vtbl_ptr_type) () * iftmp.216;
  int (*__vtbl_ptr_type) () * iftmp.217;
  int (*__vtbl_ptr_type) () * iftmp.218;
  const void * * iftmp.219;
  const void * * iftmp.220;
  const void * * iftmp.221;
  const void * * iftmp.222;

  if (0 != 0) goto <D.109698>; else goto <D.109699>;
  <D.109698>:
  D.109700 = &this->D.101154;
  sigc::trackable::trackable (D.109700);
  goto <D.109701>;
  <D.109699>:
  <D.109701>:
  try
    {
      if (0 != 0) goto <D.109702>; else goto <D.109703>;
      <D.109702>:
      if (0 == 0) goto <D.109705>; else goto <D.109706>;
      <D.109705>:
      iftmp.206 = __vtt_parm + 112;
      goto <D.109707>;
      <D.109706>:
      iftmp.206 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109707>:
      D.109708 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109708, iftmp.206, 0B);
      goto <D.109709>;
      <D.109703>:
      <D.109709>:
      try
        {
          D.109711 = Glib::ustring::empty (interface_name);
          if (D.109711 != 0) goto <D.109712>; else goto <D.109713>;
          <D.109712>:
          iftmp.207 = 0B;
          goto <D.109714>;
          <D.109713>:
          iftmp.207 = Glib::ustring::c_str (interface_name);
          <D.109714>:
          D.109716 = Glib::ustring::empty (object_path);
          if (D.109716 != 0) goto <D.109717>; else goto <D.109718>;
          <D.109717>:
          iftmp.208 = 0B;
          goto <D.109719>;
          <D.109718>:
          iftmp.208 = Glib::ustring::c_str (object_path);
          <D.109719>:
          D.109721 = Glib::ustring::empty (name);
          if (D.109721 != 0) goto <D.109722>; else goto <D.109723>;
          <D.109722>:
          iftmp.209 = 0B;
          goto <D.109724>;
          <D.109723>:
          iftmp.209 = Glib::ustring::c_str (name);
          <D.109724>:
          D.109725 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.210 = (int) flags;
          D.109727 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101730, D.109727, "g-bus-type", bus_type, "g-flags", flags.210, "g-interface-info", D.109725, "g-name", iftmp.209, "g-object-path", iftmp.208, "g-interface-name", iftmp.207, 0B);
          try
            {
              if (0 == 0) goto <D.109729>; else goto <D.109730>;
              <D.109729>:
              iftmp.211 = __vtt_parm + 8;
              goto <D.109731>;
              <D.109730>:
              iftmp.211 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109731>:
              D.109732 = &this->D.101147;
              Glib::Object::Object (D.109732, iftmp.211, &D.101730);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101730);
              D.101730 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.109734>; else goto <D.109735>;
              <D.109734>:
              iftmp.212 = __vtt_parm + 24;
              goto <D.109736>;
              <D.109735>:
              iftmp.212 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109736>:
              D.109737 = &this->D.101148;
              Gio::Initable::Initable (D.109737, iftmp.212);
              try
                {
                  if (0 == 0) goto <D.109739>; else goto <D.109740>;
                  <D.109739>:
                  iftmp.213 = __vtt_parm + 56;
                  goto <D.109741>;
                  <D.109740>:
                  iftmp.213 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109741>:
                  D.109742 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109742, iftmp.213);
                  try
                    {
                      if (0 == 0) goto <D.109744>; else goto <D.109745>;
                      <D.109744>:
                      iftmp.214 = *__vtt_parm;
                      goto <D.109746>;
                      <D.109745>:
                      iftmp.214 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109746>:
                      this->D.101147._vptr.Object = iftmp.214;
                      if (0 == 0) goto <D.109748>; else goto <D.109749>;
                      <D.109748>:
                      D.109750 = this->D.101147._vptr.Object;
                      D.109751 = D.109750 + 18446744073709551592;
                      D.109752 = MEM[(long int *)D.109751];
                      iftmp.215 = (sizetype) D.109752;
                      goto <D.109753>;
                      <D.109749>:
                      iftmp.215 = 24;
                      <D.109753>:
                      D.109754 = this + iftmp.215;
                      if (0 == 0) goto <D.109756>; else goto <D.109757>;
                      <D.109756>:
                      iftmp.216 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.109758>;
                      <D.109757>:
                      iftmp.216 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109758>:
                      D.109754->_vptr.ObjectBase = iftmp.216;
                      if (0 == 0) goto <D.109760>; else goto <D.109761>;
                      <D.109760>:
                      iftmp.217 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.109762>;
                      <D.109761>:
                      iftmp.217 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109762>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.217;
                      if (0 == 0) goto <D.109764>; else goto <D.109765>;
                      <D.109764>:
                      iftmp.218 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.109766>;
                      <D.109765>:
                      iftmp.218 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109766>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.218;
                      D.109737 = &this->D.101148;
                      Gio::Initable::init (D.109737, cancellable);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.109768>; else goto <D.109769>;
                      <D.109768>:
                      iftmp.219 = __vtt_parm + 56;
                      goto <D.109770>;
                      <D.109769>:
                      iftmp.219 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109770>:
                      D.109742 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109742, iftmp.219);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.109772>; else goto <D.109773>;
                  <D.109772>:
                  iftmp.220 = __vtt_parm + 24;
                  goto <D.109774>;
                  <D.109773>:
                  iftmp.220 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109774>:
                  D.109737 = &this->D.101148;
                  Gio::Initable::~Initable (D.109737, iftmp.220);
                }
            }
          catch
            {
              if (0 == 0) goto <D.109776>; else goto <D.109777>;
              <D.109776>:
              iftmp.221 = __vtt_parm + 8;
              goto <D.109778>;
              <D.109777>:
              iftmp.221 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109778>:
              D.109732 = &this->D.101147;
              Glib::Object::~Object (D.109732, iftmp.221);
            }
        }
      catch
        {
          if (0 != 0) goto <D.109779>; else goto <D.109780>;
          <D.109779>:
          if (0 == 0) goto <D.109782>; else goto <D.109783>;
          <D.109782>:
          iftmp.222 = __vtt_parm + 112;
          goto <D.109784>;
          <D.109783>:
          iftmp.222 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109784>:
          D.109708 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109708, iftmp.222);
          goto <D.109785>;
          <D.109780>:
          <D.109785>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.109786>; else goto <D.109787>;
      <D.109786>:
      D.109700 = &this->D.101154;
      sigc::trackable::~trackable (D.109700);
      goto <D.109788>;
      <D.109787>:
      <D.109788>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109805;
  const void * * iftmp.223;
  struct ObjectBase * D.109813;
  struct ConstructParams D.101732;
  const char * iftmp.224;
  bool D.109816;
  const char * iftmp.225;
  bool D.109821;
  const char * iftmp.226;
  bool D.109826;
  struct BaseObjectType * D.109830;
  int flags.227;
  const struct Class & D.109832;
  const void * * iftmp.228;
  struct Object * D.109837;
  const void * * iftmp.229;
  struct Initable * D.109842;
  const void * * iftmp.230;
  struct AsyncInitable * D.109847;
  int (*__vtbl_ptr_type) () * iftmp.231;
  const void * * D.109851;
  sizetype iftmp.232;
  int (*__vtbl_ptr_type) () * D.109856;
  int (*__vtbl_ptr_type) () * D.109857;
  long int D.109858;
  struct ObjectBase * D.109860;
  int (*__vtbl_ptr_type) () * iftmp.233;
  int (*__vtbl_ptr_type) () * iftmp.234;
  int (*__vtbl_ptr_type) () * iftmp.235;
  const void * * iftmp.236;
  const void * * iftmp.237;
  const void * * iftmp.238;
  const void * * iftmp.239;

  if (1 != 0) goto <D.109803>; else goto <D.109804>;
  <D.109803>:
  D.109805 = &this->D.101154;
  sigc::trackable::trackable (D.109805);
  goto <D.109806>;
  <D.109804>:
  <D.109806>:
  try
    {
      if (1 != 0) goto <D.109807>; else goto <D.109808>;
      <D.109807>:
      if (1 == 0) goto <D.109810>; else goto <D.109811>;
      <D.109810>:
      iftmp.223 = 112B;
      goto <D.109812>;
      <D.109811>:
      iftmp.223 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109812>:
      D.109813 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109813, iftmp.223, 0B);
      goto <D.109814>;
      <D.109808>:
      <D.109814>:
      try
        {
          D.109816 = Glib::ustring::empty (interface_name);
          if (D.109816 != 0) goto <D.109817>; else goto <D.109818>;
          <D.109817>:
          iftmp.224 = 0B;
          goto <D.109819>;
          <D.109818>:
          iftmp.224 = Glib::ustring::c_str (interface_name);
          <D.109819>:
          D.109821 = Glib::ustring::empty (object_path);
          if (D.109821 != 0) goto <D.109822>; else goto <D.109823>;
          <D.109822>:
          iftmp.225 = 0B;
          goto <D.109824>;
          <D.109823>:
          iftmp.225 = Glib::ustring::c_str (object_path);
          <D.109824>:
          D.109826 = Glib::ustring::empty (name);
          if (D.109826 != 0) goto <D.109827>; else goto <D.109828>;
          <D.109827>:
          iftmp.226 = 0B;
          goto <D.109829>;
          <D.109828>:
          iftmp.226 = Glib::ustring::c_str (name);
          <D.109829>:
          D.109830 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.227 = (int) flags;
          D.109832 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101732, D.109832, "g-bus-type", bus_type, "g-flags", flags.227, "g-interface-info", D.109830, "g-name", iftmp.226, "g-object-path", iftmp.225, "g-interface-name", iftmp.224, 0B);
          try
            {
              if (1 == 0) goto <D.109834>; else goto <D.109835>;
              <D.109834>:
              iftmp.228 = 8B;
              goto <D.109836>;
              <D.109835>:
              iftmp.228 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109836>:
              D.109837 = &this->D.101147;
              Glib::Object::Object (D.109837, iftmp.228, &D.101732);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101732);
              D.101732 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.109839>; else goto <D.109840>;
              <D.109839>:
              iftmp.229 = 24B;
              goto <D.109841>;
              <D.109840>:
              iftmp.229 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109841>:
              D.109842 = &this->D.101148;
              Gio::Initable::Initable (D.109842, iftmp.229);
              try
                {
                  if (1 == 0) goto <D.109844>; else goto <D.109845>;
                  <D.109844>:
                  iftmp.230 = 56B;
                  goto <D.109846>;
                  <D.109845>:
                  iftmp.230 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109846>:
                  D.109847 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109847, iftmp.230);
                  try
                    {
                      if (1 == 0) goto <D.109849>; else goto <D.109850>;
                      <D.109849>:
                      D.109851 = 0B;
                      iftmp.231 = *D.109851;
                      goto <D.109852>;
                      <D.109850>:
                      iftmp.231 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109852>:
                      this->D.101147._vptr.Object = iftmp.231;
                      if (1 == 0) goto <D.109854>; else goto <D.109855>;
                      <D.109854>:
                      D.109856 = this->D.101147._vptr.Object;
                      D.109857 = D.109856 + 18446744073709551592;
                      D.109858 = MEM[(long int *)D.109857];
                      iftmp.232 = (sizetype) D.109858;
                      goto <D.109859>;
                      <D.109855>:
                      iftmp.232 = 24;
                      <D.109859>:
                      D.109860 = this + iftmp.232;
                      if (1 == 0) goto <D.109862>; else goto <D.109863>;
                      <D.109862>:
                      iftmp.233 = MEM[(const void * *)0B + 88B];
                      goto <D.109864>;
                      <D.109863>:
                      iftmp.233 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109864>:
                      D.109860->_vptr.ObjectBase = iftmp.233;
                      if (1 == 0) goto <D.109866>; else goto <D.109867>;
                      <D.109866>:
                      iftmp.234 = MEM[(const void * *)0B + 96B];
                      goto <D.109868>;
                      <D.109867>:
                      iftmp.234 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109868>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.234;
                      if (1 == 0) goto <D.109870>; else goto <D.109871>;
                      <D.109870>:
                      iftmp.235 = MEM[(const void * *)0B + 104B];
                      goto <D.109872>;
                      <D.109871>:
                      iftmp.235 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109872>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.235;
                      D.109842 = &this->D.101148;
                      Gio::Initable::init (D.109842, cancellable);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.109874>; else goto <D.109875>;
                      <D.109874>:
                      iftmp.236 = 56B;
                      goto <D.109876>;
                      <D.109875>:
                      iftmp.236 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109876>:
                      D.109847 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109847, iftmp.236);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.109878>; else goto <D.109879>;
                  <D.109878>:
                  iftmp.237 = 24B;
                  goto <D.109880>;
                  <D.109879>:
                  iftmp.237 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109880>:
                  D.109842 = &this->D.101148;
                  Gio::Initable::~Initable (D.109842, iftmp.237);
                }
            }
          catch
            {
              if (1 == 0) goto <D.109882>; else goto <D.109883>;
              <D.109882>:
              iftmp.238 = 8B;
              goto <D.109884>;
              <D.109883>:
              iftmp.238 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109884>:
              D.109837 = &this->D.101147;
              Glib::Object::~Object (D.109837, iftmp.238);
            }
        }
      catch
        {
          if (1 != 0) goto <D.109885>; else goto <D.109886>;
          <D.109885>:
          if (1 == 0) goto <D.109888>; else goto <D.109889>;
          <D.109888>:
          iftmp.239 = 112B;
          goto <D.109890>;
          <D.109889>:
          iftmp.239 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109890>:
          D.109813 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109813, iftmp.239);
          goto <D.109891>;
          <D.109886>:
          <D.109891>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.109892>; else goto <D.109893>;
      <D.109892>:
      D.109805 = &this->D.101154;
      sigc::trackable::~trackable (D.109805);
      goto <D.109894>;
      <D.109893>:
      <D.109894>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, const void * * __vtt_parm, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.109911;
  const void * * iftmp.240;
  struct ObjectBase * D.109919;
  struct ConstructParams D.101746;
  const char * iftmp.241;
  bool D.109922;
  const char * iftmp.242;
  bool D.109927;
  const char * iftmp.243;
  bool D.109932;
  struct BaseObjectType * D.109936;
  int flags.244;
  const struct Class & D.109938;
  const void * * iftmp.245;
  struct Object * D.109943;
  const void * * iftmp.246;
  struct Initable * D.109948;
  const void * * iftmp.247;
  struct AsyncInitable * D.109953;
  int (*__vtbl_ptr_type) () * iftmp.248;
  sizetype iftmp.249;
  int (*__vtbl_ptr_type) () * D.109961;
  int (*__vtbl_ptr_type) () * D.109962;
  long int D.109963;
  struct ObjectBase * D.109965;
  int (*__vtbl_ptr_type) () * iftmp.250;
  int (*__vtbl_ptr_type) () * iftmp.251;
  int (*__vtbl_ptr_type) () * iftmp.252;
  const void * * iftmp.253;
  const void * * iftmp.254;
  const void * * iftmp.255;
  const void * * iftmp.256;

  if (0 != 0) goto <D.109909>; else goto <D.109910>;
  <D.109909>:
  D.109911 = &this->D.101154;
  sigc::trackable::trackable (D.109911);
  goto <D.109912>;
  <D.109910>:
  <D.109912>:
  try
    {
      if (0 != 0) goto <D.109913>; else goto <D.109914>;
      <D.109913>:
      if (0 == 0) goto <D.109916>; else goto <D.109917>;
      <D.109916>:
      iftmp.240 = __vtt_parm + 112;
      goto <D.109918>;
      <D.109917>:
      iftmp.240 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.109918>:
      D.109919 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.109919, iftmp.240, 0B);
      goto <D.109920>;
      <D.109914>:
      <D.109920>:
      try
        {
          D.109922 = Glib::ustring::empty (interface_name);
          if (D.109922 != 0) goto <D.109923>; else goto <D.109924>;
          <D.109923>:
          iftmp.241 = 0B;
          goto <D.109925>;
          <D.109924>:
          iftmp.241 = Glib::ustring::c_str (interface_name);
          <D.109925>:
          D.109927 = Glib::ustring::empty (object_path);
          if (D.109927 != 0) goto <D.109928>; else goto <D.109929>;
          <D.109928>:
          iftmp.242 = 0B;
          goto <D.109930>;
          <D.109929>:
          iftmp.242 = Glib::ustring::c_str (object_path);
          <D.109930>:
          D.109932 = Glib::ustring::empty (name);
          if (D.109932 != 0) goto <D.109933>; else goto <D.109934>;
          <D.109933>:
          iftmp.243 = 0B;
          goto <D.109935>;
          <D.109934>:
          iftmp.243 = Glib::ustring::c_str (name);
          <D.109935>:
          D.109936 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.244 = (int) flags;
          D.109938 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101746, D.109938, "g-bus-type", bus_type, "g-flags", flags.244, "g-interface-info", D.109936, "g-name", iftmp.243, "g-object-path", iftmp.242, "g-interface-name", iftmp.241, 0B);
          try
            {
              if (0 == 0) goto <D.109940>; else goto <D.109941>;
              <D.109940>:
              iftmp.245 = __vtt_parm + 8;
              goto <D.109942>;
              <D.109941>:
              iftmp.245 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109942>:
              D.109943 = &this->D.101147;
              Glib::Object::Object (D.109943, iftmp.245, &D.101746);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101746);
              D.101746 = {CLOBBER};
            }
          try
            {
              if (0 == 0) goto <D.109945>; else goto <D.109946>;
              <D.109945>:
              iftmp.246 = __vtt_parm + 24;
              goto <D.109947>;
              <D.109946>:
              iftmp.246 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.109947>:
              D.109948 = &this->D.101148;
              Gio::Initable::Initable (D.109948, iftmp.246);
              try
                {
                  if (0 == 0) goto <D.109950>; else goto <D.109951>;
                  <D.109950>:
                  iftmp.247 = __vtt_parm + 56;
                  goto <D.109952>;
                  <D.109951>:
                  iftmp.247 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.109952>:
                  D.109953 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.109953, iftmp.247);
                  try
                    {
                      if (0 == 0) goto <D.109955>; else goto <D.109956>;
                      <D.109955>:
                      iftmp.248 = *__vtt_parm;
                      goto <D.109957>;
                      <D.109956>:
                      iftmp.248 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.109957>:
                      this->D.101147._vptr.Object = iftmp.248;
                      if (0 == 0) goto <D.109959>; else goto <D.109960>;
                      <D.109959>:
                      D.109961 = this->D.101147._vptr.Object;
                      D.109962 = D.109961 + 18446744073709551592;
                      D.109963 = MEM[(long int *)D.109962];
                      iftmp.249 = (sizetype) D.109963;
                      goto <D.109964>;
                      <D.109960>:
                      iftmp.249 = 24;
                      <D.109964>:
                      D.109965 = this + iftmp.249;
                      if (0 == 0) goto <D.109967>; else goto <D.109968>;
                      <D.109967>:
                      iftmp.250 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.109969>;
                      <D.109968>:
                      iftmp.250 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.109969>:
                      D.109965->_vptr.ObjectBase = iftmp.250;
                      if (0 == 0) goto <D.109971>; else goto <D.109972>;
                      <D.109971>:
                      iftmp.251 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.109973>;
                      <D.109972>:
                      iftmp.251 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.109973>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.251;
                      if (0 == 0) goto <D.109975>; else goto <D.109976>;
                      <D.109975>:
                      iftmp.252 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.109977>;
                      <D.109976>:
                      iftmp.252 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.109977>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.252;
                      D.109948 = &this->D.101148;
                      Gio::Initable::init (D.109948);
                    }
                  catch
                    {
                      if (0 == 0) goto <D.109979>; else goto <D.109980>;
                      <D.109979>:
                      iftmp.253 = __vtt_parm + 56;
                      goto <D.109981>;
                      <D.109980>:
                      iftmp.253 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.109981>:
                      D.109953 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.109953, iftmp.253);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.109983>; else goto <D.109984>;
                  <D.109983>:
                  iftmp.254 = __vtt_parm + 24;
                  goto <D.109985>;
                  <D.109984>:
                  iftmp.254 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.109985>:
                  D.109948 = &this->D.101148;
                  Gio::Initable::~Initable (D.109948, iftmp.254);
                }
            }
          catch
            {
              if (0 == 0) goto <D.109987>; else goto <D.109988>;
              <D.109987>:
              iftmp.255 = __vtt_parm + 8;
              goto <D.109989>;
              <D.109988>:
              iftmp.255 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.109989>:
              D.109943 = &this->D.101147;
              Glib::Object::~Object (D.109943, iftmp.255);
            }
        }
      catch
        {
          if (0 != 0) goto <D.109990>; else goto <D.109991>;
          <D.109990>:
          if (0 == 0) goto <D.109993>; else goto <D.109994>;
          <D.109993>:
          iftmp.256 = __vtt_parm + 112;
          goto <D.109995>;
          <D.109994>:
          iftmp.256 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.109995>:
          D.109919 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.109919, iftmp.256);
          goto <D.109996>;
          <D.109991>:
          <D.109996>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.109997>; else goto <D.109998>;
      <D.109997>:
      D.109911 = &this->D.101154;
      sigc::trackable::~trackable (D.109911);
      goto <D.109999>;
      <D.109998>:
      <D.109999>:
    }
}


Gio::DBus::Proxy::Proxy(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (struct Proxy * const this, BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  struct trackable * D.110016;
  const void * * iftmp.257;
  struct ObjectBase * D.110024;
  struct ConstructParams D.101748;
  const char * iftmp.258;
  bool D.110027;
  const char * iftmp.259;
  bool D.110032;
  const char * iftmp.260;
  bool D.110037;
  struct BaseObjectType * D.110041;
  int flags.261;
  const struct Class & D.110043;
  const void * * iftmp.262;
  struct Object * D.110048;
  const void * * iftmp.263;
  struct Initable * D.110053;
  const void * * iftmp.264;
  struct AsyncInitable * D.110058;
  int (*__vtbl_ptr_type) () * iftmp.265;
  const void * * D.110062;
  sizetype iftmp.266;
  int (*__vtbl_ptr_type) () * D.110067;
  int (*__vtbl_ptr_type) () * D.110068;
  long int D.110069;
  struct ObjectBase * D.110071;
  int (*__vtbl_ptr_type) () * iftmp.267;
  int (*__vtbl_ptr_type) () * iftmp.268;
  int (*__vtbl_ptr_type) () * iftmp.269;
  const void * * iftmp.270;
  const void * * iftmp.271;
  const void * * iftmp.272;
  const void * * iftmp.273;

  if (1 != 0) goto <D.110014>; else goto <D.110015>;
  <D.110014>:
  D.110016 = &this->D.101154;
  sigc::trackable::trackable (D.110016);
  goto <D.110017>;
  <D.110015>:
  <D.110017>:
  try
    {
      if (1 != 0) goto <D.110018>; else goto <D.110019>;
      <D.110018>:
      if (1 == 0) goto <D.110021>; else goto <D.110022>;
      <D.110021>:
      iftmp.257 = 112B;
      goto <D.110023>;
      <D.110022>:
      iftmp.257 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.110023>:
      D.110024 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.110024, iftmp.257, 0B);
      goto <D.110025>;
      <D.110019>:
      <D.110025>:
      try
        {
          D.110027 = Glib::ustring::empty (interface_name);
          if (D.110027 != 0) goto <D.110028>; else goto <D.110029>;
          <D.110028>:
          iftmp.258 = 0B;
          goto <D.110030>;
          <D.110029>:
          iftmp.258 = Glib::ustring::c_str (interface_name);
          <D.110030>:
          D.110032 = Glib::ustring::empty (object_path);
          if (D.110032 != 0) goto <D.110033>; else goto <D.110034>;
          <D.110033>:
          iftmp.259 = 0B;
          goto <D.110035>;
          <D.110034>:
          iftmp.259 = Glib::ustring::c_str (object_path);
          <D.110035>:
          D.110037 = Glib::ustring::empty (name);
          if (D.110037 != 0) goto <D.110038>; else goto <D.110039>;
          <D.110038>:
          iftmp.260 = 0B;
          goto <D.110040>;
          <D.110039>:
          iftmp.260 = Glib::ustring::c_str (name);
          <D.110040>:
          D.110041 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
          flags.261 = (int) flags;
          D.110043 = Gio::DBus::Proxy_Class::init (&proxy_class_);
          Glib::ConstructParams::ConstructParams (&D.101748, D.110043, "g-bus-type", bus_type, "g-flags", flags.261, "g-interface-info", D.110041, "g-name", iftmp.260, "g-object-path", iftmp.259, "g-interface-name", iftmp.258, 0B);
          try
            {
              if (1 == 0) goto <D.110045>; else goto <D.110046>;
              <D.110045>:
              iftmp.262 = 8B;
              goto <D.110047>;
              <D.110046>:
              iftmp.262 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.110047>:
              D.110048 = &this->D.101147;
              Glib::Object::Object (D.110048, iftmp.262, &D.101748);
            }
          finally
            {
              Glib::ConstructParams::~ConstructParams (&D.101748);
              D.101748 = {CLOBBER};
            }
          try
            {
              if (1 == 0) goto <D.110050>; else goto <D.110051>;
              <D.110050>:
              iftmp.263 = 24B;
              goto <D.110052>;
              <D.110051>:
              iftmp.263 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.110052>:
              D.110053 = &this->D.101148;
              Gio::Initable::Initable (D.110053, iftmp.263);
              try
                {
                  if (1 == 0) goto <D.110055>; else goto <D.110056>;
                  <D.110055>:
                  iftmp.264 = 56B;
                  goto <D.110057>;
                  <D.110056>:
                  iftmp.264 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.110057>:
                  D.110058 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.110058, iftmp.264);
                  try
                    {
                      if (1 == 0) goto <D.110060>; else goto <D.110061>;
                      <D.110060>:
                      D.110062 = 0B;
                      iftmp.265 = *D.110062;
                      goto <D.110063>;
                      <D.110061>:
                      iftmp.265 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.110063>:
                      this->D.101147._vptr.Object = iftmp.265;
                      if (1 == 0) goto <D.110065>; else goto <D.110066>;
                      <D.110065>:
                      D.110067 = this->D.101147._vptr.Object;
                      D.110068 = D.110067 + 18446744073709551592;
                      D.110069 = MEM[(long int *)D.110068];
                      iftmp.266 = (sizetype) D.110069;
                      goto <D.110070>;
                      <D.110066>:
                      iftmp.266 = 24;
                      <D.110070>:
                      D.110071 = this + iftmp.266;
                      if (1 == 0) goto <D.110073>; else goto <D.110074>;
                      <D.110073>:
                      iftmp.267 = MEM[(const void * *)0B + 88B];
                      goto <D.110075>;
                      <D.110074>:
                      iftmp.267 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.110075>:
                      D.110071->_vptr.ObjectBase = iftmp.267;
                      if (1 == 0) goto <D.110077>; else goto <D.110078>;
                      <D.110077>:
                      iftmp.268 = MEM[(const void * *)0B + 96B];
                      goto <D.110079>;
                      <D.110078>:
                      iftmp.268 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.110079>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.268;
                      if (1 == 0) goto <D.110081>; else goto <D.110082>;
                      <D.110081>:
                      iftmp.269 = MEM[(const void * *)0B + 104B];
                      goto <D.110083>;
                      <D.110082>:
                      iftmp.269 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.110083>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.269;
                      D.110053 = &this->D.101148;
                      Gio::Initable::init (D.110053);
                    }
                  catch
                    {
                      if (1 == 0) goto <D.110085>; else goto <D.110086>;
                      <D.110085>:
                      iftmp.270 = 56B;
                      goto <D.110087>;
                      <D.110086>:
                      iftmp.270 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.110087>:
                      D.110058 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.110058, iftmp.270);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.110089>; else goto <D.110090>;
                  <D.110089>:
                  iftmp.271 = 24B;
                  goto <D.110091>;
                  <D.110090>:
                  iftmp.271 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.110091>:
                  D.110053 = &this->D.101148;
                  Gio::Initable::~Initable (D.110053, iftmp.271);
                }
            }
          catch
            {
              if (1 == 0) goto <D.110093>; else goto <D.110094>;
              <D.110093>:
              iftmp.272 = 8B;
              goto <D.110095>;
              <D.110094>:
              iftmp.272 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.110095>:
              D.110048 = &this->D.101147;
              Glib::Object::~Object (D.110048, iftmp.272);
            }
        }
      catch
        {
          if (1 != 0) goto <D.110096>; else goto <D.110097>;
          <D.110096>:
          if (1 == 0) goto <D.110099>; else goto <D.110100>;
          <D.110099>:
          iftmp.273 = 112B;
          goto <D.110101>;
          <D.110100>:
          iftmp.273 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.110101>:
          D.110024 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.110024, iftmp.273);
          goto <D.110102>;
          <D.110097>:
          <D.110102>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.110103>; else goto <D.110104>;
      <D.110103>:
      D.110016 = &this->D.101154;
      sigc::trackable::~trackable (D.110016);
      goto <D.110105>;
      <D.110104>:
      <D.110105>:
    }
}


static void Gio::DBus::Proxy::create(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct Proxy D.101760;

  Gio::DBus::Proxy::Proxy (&D.101760, connection, name, object_path, interface_name, slot, cancellable, info, flags);
  Gio::DBus::Proxy::~Proxy (&D.101760);
  D.101760 = {CLOBBER};
}


static void Gio::DBus::Proxy::create(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct Proxy D.101881;

  Gio::DBus::Proxy::Proxy (&D.101881, connection, name, object_path, interface_name, slot, info, flags);
  Gio::DBus::Proxy::~Proxy (&D.101881);
  D.101881 = {CLOBBER};
}


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_sync(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  void * D.102016;

  D.102016 = operator new (64);
  try
    {
      Gio::DBus::Proxy::Proxy (D.102016, connection, name, object_path, interface_name, cancellable, info, flags);
    }
  catch
    {
      operator delete (D.102016);
    }
  Glib::RefPtr<Gio::DBus::Proxy>::RefPtr (<retval>, D.102016);
  return <retval>;
}


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


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_sync(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (const struct RefPtr & connection, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  void * D.102045;

  D.102045 = operator new (64);
  try
    {
      Gio::DBus::Proxy::Proxy (D.102045, connection, name, object_path, interface_name, info, flags);
    }
  catch
    {
      operator delete (D.102045);
    }
  Glib::RefPtr<Gio::DBus::Proxy>::RefPtr (<retval>, D.102045);
  return <retval>;
}


static void Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  struct Proxy D.102067;

  Gio::DBus::Proxy::Proxy (&D.102067, bus_type, name, object_path, interface_name, slot, cancellable, info, flags);
  Gio::DBus::Proxy::~Proxy (&D.102067);
  D.102067 = {CLOBBER};
}


static void Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct SlotAsyncReady & slot, const struct RefPtr & info, ProxyFlags flags)
{
  struct Proxy D.102078;

  Gio::DBus::Proxy::Proxy (&D.102078, bus_type, name, object_path, interface_name, slot, info, flags);
  Gio::DBus::Proxy::~Proxy (&D.102078);
  D.102078 = {CLOBBER};
}


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_for_bus_sync(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & cancellable, const struct RefPtr & info, ProxyFlags flags)
{
  void * D.102089;

  D.102089 = operator new (64);
  try
    {
      Gio::DBus::Proxy::Proxy (D.102089, bus_type, name, object_path, interface_name, cancellable, info, flags);
    }
  catch
    {
      operator delete (D.102089);
    }
  Glib::RefPtr<Gio::DBus::Proxy>::RefPtr (<retval>, D.102089);
  return <retval>;
}


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_for_bus_sync(Gio::DBus::BusType, const Glib::ustring&, const Glib::ustring&, const Glib::ustring&, const Glib::RefPtr<Gio::DBus::InterfaceInfo>&, Gio::DBus::ProxyFlags) (BusType bus_type, const struct ustring & name, const struct ustring & object_path, const struct ustring & interface_name, const struct RefPtr & info, ProxyFlags flags)
{
  void * D.102100;

  D.102100 = operator new (64);
  try
    {
      Gio::DBus::Proxy::Proxy (D.102100, bus_type, name, object_path, interface_name, info, flags);
    }
  catch
    {
      operator delete (D.102100);
    }
  Glib::RefPtr<Gio::DBus::Proxy>::RefPtr (<retval>, D.102100);
  return <retval>;
}


void Gio::DBus::Proxy::get_cached_property(Glib::VariantBase&, const Glib::ustring&) const (const struct Proxy * const this, struct VariantBase & property, const struct ustring & property_name)
{
  const char * D.110136;
  const struct GDBusProxy * D.110137;
  struct GVariant * const g_variant;

  D.110136 = Glib::ustring::c_str (property_name);
  D.110137 = Gio::DBus::Proxy::gobj (this);
  g_variant = g_dbus_proxy_get_cached_property (D.110137, D.110136);
  Glib::VariantBase::init (property, g_variant, 0);
}


const GDBusProxy* Gio::DBus::Proxy::gobj() const (const struct Proxy * const this)
{
  const struct GDBusProxy * D.110140;
  int (*__vtbl_ptr_type) () * D.110141;
  int (*__vtbl_ptr_type) () * D.110142;
  long int D.110143;
  sizetype D.110144;
  const struct ObjectBase * D.110145;

  D.110141 = this->D.101147._vptr.Object;
  D.110142 = D.110141 + 18446744073709551592;
  D.110143 = MEM[(long int *)D.110142];
  D.110144 = (sizetype) D.110143;
  D.110145 = this + D.110144;
  D.110140 = D.110145->gobject_;
  return D.110140;
}


void Gio::DBus::Proxy::call(const Glib::ustring&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::VariantContainerBase&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct VariantContainerBase & parameters, int timeout_msec, CallFlags flags)
{
  void * slot_copy.274;
  struct BaseObjectType * D.110147;
  const struct VariantBase * D.110148;
  const struct GVariant * D.110149;
  const char * D.110150;
  struct GDBusProxy * D.110151;
  struct SlotAsyncReady * slot_copy;

  slot_copy.274 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.274, slot);
    }
  catch
    {
      operator delete (slot_copy.274);
    }
  slot_copy = slot_copy.274;
  D.110147 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.110148 = &parameters->D.66789;
  D.110149 = Glib::VariantBase::gobj (D.110148);
  D.110150 = Glib::ustring::c_str (method_name);
  D.110151 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_call (D.110151, D.110150, D.110149, flags, timeout_msec, D.110147, SignalProxy_async_callback, slot_copy);
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.110156;

  D.110156 = &this->D.101879;
  sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::slot1 (D.110156, src);
  try
    {

    }
  catch
    {
      D.110156 = &this->D.101879;
      sigc::slot1<void, Glib::RefPtr<Gio::AsyncResult>&>::~slot1 (D.110156);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = void; T_arg1 = Glib::RefPtr<Gio::AsyncResult>&] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.110157;
  struct slot_base * D.110158;

  D.110157 = &src->D.101837;
  D.110158 = &this->D.101837;
  sigc::slot_base::slot_base (D.110158, D.110157);
  try
    {

    }
  catch
    {
      D.110158 = &this->D.101837;
      sigc::slot_base::~slot_base (D.110158);
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::Cancellable; typename T::BaseObjectType = _GCancellable] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.110159;
  struct BaseObjectType * iftmp.275;
  bool D.110161;
  struct Cancellable * D.110164;

  D.110161 = Glib::RefPtr<Gio::Cancellable>::operator bool (ptr);
  if (D.110161 != 0) goto <D.110162>; else goto <D.110163>;
  <D.110162>:
  D.110164 = Glib::RefPtr<Gio::Cancellable>::operator-> (ptr);
  iftmp.275 = Gio::Cancellable::gobj (D.110164);
  goto <D.110165>;
  <D.110163>:
  iftmp.275 = 0B;
  <D.110165>:
  D.110159 = iftmp.275;
  return D.110159;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::Cancellable] (const struct RefPtr * const this)
{
  bool D.110167;
  struct Cancellable * D.110168;

  D.110168 = this->pCppObject_;
  D.110167 = D.110168 != 0B;
  return D.110167;
}


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

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


GCancellable* Gio::Cancellable::gobj() (struct Cancellable * const this)
{
  struct GCancellable * D.110172;
  int (*__vtbl_ptr_type) () * D.110173;
  int (*__vtbl_ptr_type) () * D.110174;
  long int D.110175;
  sizetype D.110176;
  struct ObjectBase * D.110177;

  D.110173 = this->D.96949._vptr.Object;
  D.110174 = D.110173 + 18446744073709551592;
  D.110175 = MEM[(long int *)D.110174];
  D.110176 = (sizetype) D.110175;
  D.110177 = this + D.110176;
  D.110172 = D.110177->gobject_;
  return D.110172;
}


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

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


GDBusProxy* Gio::DBus::Proxy::gobj() (struct Proxy * const this)
{
  struct GDBusProxy * D.110181;
  int (*__vtbl_ptr_type) () * D.110182;
  int (*__vtbl_ptr_type) () * D.110183;
  long int D.110184;
  sizetype D.110185;
  struct ObjectBase * D.110186;

  D.110182 = this->D.101147._vptr.Object;
  D.110183 = D.110182 + 18446744073709551592;
  D.110184 = MEM[(long int *)D.110183];
  D.110185 = (sizetype) D.110184;
  D.110186 = this + D.110185;
  D.110181 = D.110186->gobject_;
  return D.110181;
}


void Gio::DBus::Proxy::call(const Glib::ustring&, const SlotAsyncReady&, const Glib::VariantContainerBase&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct SlotAsyncReady & slot, const struct VariantContainerBase & parameters, int timeout_msec, CallFlags flags)
{
  void * slot_copy.276;
  const struct VariantBase * D.110188;
  const struct GVariant * D.110189;
  const char * D.110190;
  struct GDBusProxy * D.110191;
  struct SlotAsyncReady * slot_copy;

  slot_copy.276 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.276, slot);
    }
  catch
    {
      operator delete (slot_copy.276);
    }
  slot_copy = slot_copy.276;
  D.110188 = &parameters->D.66789;
  D.110189 = Glib::VariantBase::gobj (D.110188);
  D.110190 = Glib::ustring::c_str (method_name);
  D.110191 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_call (D.110191, D.110190, D.110189, flags, timeout_msec, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_sync(const Glib::ustring&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::VariantContainerBase&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct RefPtr & cancellable, const struct VariantContainerBase & parameters, int timeout_msec, CallFlags flags)
{
  struct BaseObjectType * D.110196;
  const struct VariantBase * D.110197;
  const struct GVariant * D.110198;
  const char * D.110199;
  struct GDBusProxy * D.110200;
  struct GError * g_error.277;
  struct GError * g_error;
  struct GVariant * const gvariant;

  try
    {
      g_error = 0B;
      D.110196 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.110197 = &parameters->D.66789;
      D.110198 = Glib::VariantBase::gobj (D.110197);
      D.110199 = Glib::ustring::c_str (method_name);
      D.110200 = Gio::DBus::Proxy::gobj (this);
      gvariant = g_dbus_proxy_call_sync (D.110200, D.110199, D.110198, flags, timeout_msec, D.110196, &g_error);
      g_error.277 = g_error;
      if (g_error.277 != 0B) goto <D.110202>; else goto <D.110203>;
      <D.110202>:
      g_error.277 = g_error;
      Glib::Error::throw_exception (g_error.277);
      <D.110203>:
      Glib::VariantContainerBase::VariantContainerBase (<retval>, gvariant, 0);
      return <retval>;
    }
  finally
    {
      g_error = {CLOBBER};
    }
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_sync(const Glib::ustring&, const Glib::VariantContainerBase&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct VariantContainerBase & parameters, int timeout_msec, CallFlags flags)
{
  const struct VariantBase * D.110211;
  const struct GVariant * D.110212;
  const char * D.110213;
  struct GDBusProxy * D.110214;
  struct GError * g_error.278;
  struct GError * g_error;
  struct GVariant * const gvariant;

  try
    {
      g_error = 0B;
      D.110211 = &parameters->D.66789;
      D.110212 = Glib::VariantBase::gobj (D.110211);
      D.110213 = Glib::ustring::c_str (method_name);
      D.110214 = Gio::DBus::Proxy::gobj (this);
      gvariant = g_dbus_proxy_call_sync (D.110214, D.110213, D.110212, flags, timeout_msec, 0B, &g_error);
      g_error.278 = g_error;
      if (g_error.278 != 0B) goto <D.110216>; else goto <D.110217>;
      <D.110216>:
      g_error.278 = g_error;
      Glib::Error::throw_exception (g_error.278);
      <D.110217>:
      Glib::VariantContainerBase::VariantContainerBase (<retval>, gvariant, 0);
      return <retval>;
    }
  finally
    {
      g_error = {CLOBBER};
    }
}


void Gio::DBus::Proxy::call(const Glib::ustring&, const Glib::VariantContainerBase&, const SlotAsyncReady&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::UnixFDList>&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct VariantContainerBase & parameters, const struct SlotAsyncReady & slot, const struct RefPtr & cancellable, const struct RefPtr & fd_list, int timeout_msec, CallFlags flags)
{
  void * slot_copy.279;
  struct BaseObjectType * D.110223;
  struct BaseObjectType * D.110224;
  const struct VariantBase * D.110225;
  const struct GVariant * D.110226;
  const char * D.110227;
  struct GDBusProxy * D.110228;
  struct SlotAsyncReady * slot_copy;

  slot_copy.279 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.279, slot);
    }
  catch
    {
      operator delete (slot_copy.279);
    }
  slot_copy = slot_copy.279;
  D.110223 = Glib::unwrap<Gio::Cancellable> (cancellable);
  D.110224 = Glib::unwrap<Gio::UnixFDList> (fd_list);
  D.110225 = &parameters->D.66789;
  D.110226 = Glib::VariantBase::gobj (D.110225);
  D.110227 = Glib::ustring::c_str (method_name);
  D.110228 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_call_with_unix_fd_list (D.110228, D.110227, D.110226, flags, timeout_msec, D.110224, D.110223, SignalProxy_async_callback, slot_copy);
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::UnixFDList; typename T::BaseObjectType = _GUnixFDList] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.110234;
  struct BaseObjectType * iftmp.280;
  bool D.110236;
  struct UnixFDList * D.110239;

  D.110236 = Glib::RefPtr<Gio::UnixFDList>::operator bool (ptr);
  if (D.110236 != 0) goto <D.110237>; else goto <D.110238>;
  <D.110237>:
  D.110239 = Glib::RefPtr<Gio::UnixFDList>::operator-> (ptr);
  iftmp.280 = Gio::UnixFDList::gobj (D.110239);
  goto <D.110240>;
  <D.110238>:
  iftmp.280 = 0B;
  <D.110240>:
  D.110234 = iftmp.280;
  return D.110234;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::UnixFDList] (const struct RefPtr * const this)
{
  bool D.110242;
  struct UnixFDList * D.110243;

  D.110243 = this->pCppObject_;
  D.110242 = D.110243 != 0B;
  return D.110242;
}


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

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


GUnixFDList* Gio::UnixFDList::gobj() (struct UnixFDList * const this)
{
  struct GUnixFDList * D.110247;
  int (*__vtbl_ptr_type) () * D.110248;
  int (*__vtbl_ptr_type) () * D.110249;
  long int D.110250;
  sizetype D.110251;
  struct ObjectBase * D.110252;

  D.110248 = this->D.98265._vptr.Object;
  D.110249 = D.110248 + 18446744073709551592;
  D.110250 = MEM[(long int *)D.110249];
  D.110251 = (sizetype) D.110250;
  D.110252 = this + D.110251;
  D.110247 = D.110252->gobject_;
  return D.110247;
}


void Gio::DBus::Proxy::call(const Glib::ustring&, const Glib::VariantContainerBase&, const SlotAsyncReady&, const Glib::RefPtr<Gio::UnixFDList>&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct VariantContainerBase & parameters, const struct SlotAsyncReady & slot, const struct RefPtr & fd_list, int timeout_msec, CallFlags flags)
{
  void * slot_copy.281;
  struct BaseObjectType * D.110254;
  const struct VariantBase * D.110255;
  const struct GVariant * D.110256;
  const char * D.110257;
  struct GDBusProxy * D.110258;
  struct SlotAsyncReady * slot_copy;

  slot_copy.281 = operator new (16);
  try
    {
      sigc::slot<void, Glib::RefPtr<Gio::AsyncResult>&>::slot (slot_copy.281, slot);
    }
  catch
    {
      operator delete (slot_copy.281);
    }
  slot_copy = slot_copy.281;
  D.110254 = Glib::unwrap<Gio::UnixFDList> (fd_list);
  D.110255 = &parameters->D.66789;
  D.110256 = Glib::VariantBase::gobj (D.110255);
  D.110257 = Glib::ustring::c_str (method_name);
  D.110258 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_call_with_unix_fd_list (D.110258, D.110257, D.110256, flags, timeout_msec, D.110254, 0B, SignalProxy_async_callback, slot_copy);
}


Glib::RefPtr<Gio::DBus::Proxy> Glib::wrap(GDBusProxy*, bool) (struct GDBusProxy * object, bool take_copy)
{
  struct Proxy * iftmp.282;
  int D.110265;
  struct ObjectBase * D.110266;

  D.110265 = (int) take_copy;
  D.110266 = Glib::wrap_auto (object, D.110265);
  if (D.110266 == 0B) goto <D.110267>; else goto <D.110268>;
  <D.110267>:
  iftmp.282 = 0B;
  goto <D.110269>;
  <D.110268>:
  iftmp.282 = __dynamic_cast (D.110266, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus5ProxyE, -1);
  <D.110269>:
  Glib::RefPtr<Gio::DBus::Proxy>::RefPtr (<retval>, iftmp.282);
  return <retval>;
}


const Glib::Class& Gio::DBus::Proxy_Class::init() (struct Proxy_Class * const this)
{
  long unsigned int D.110272;
  long unsigned int D.110275;
  struct Class * D.110276;
  long unsigned int D.110277;
  long unsigned int D.110278;
  const struct Class & D.110280;

  D.110272 = this->D.101354.gtype_;
  if (D.110272 == 0) goto <D.110273>; else goto <D.110274>;
  <D.110273>:
  this->D.101354.class_init_func_ = class_init_function;
  D.110275 = g_dbus_proxy_get_type ();
  D.110276 = &this->D.101354;
  Glib::Class::register_derived_type (D.110276, D.110275);
  D.110276 = &this->D.101354;
  D.110277 = Glib::Class::get_type (D.110276);
  Gio::Initable::add_interface (D.110277);
  D.110276 = &this->D.101354;
  D.110278 = Glib::Class::get_type (D.110276);
  Gio::AsyncInitable::add_interface (D.110278);
  goto <D.110279>;
  <D.110274>:
  <D.110279>:
  D.110280 = &this->D.101354;
  return D.110280;
}


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

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


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

  klass = g_class;
  Glib::Object_Class::class_init_function (klass, class_data);
  klass->g_properties_changed = g_properties_changed_callback;
  klass->g_signal = g_signal_callback;
}


static void Gio::DBus::Proxy_Class::g_properties_changed_callback(GDBusProxy*, GVariant*, const gchar* const*) (struct GDBusProxy * self, struct GVariant * p0, const gchar * const * p1)
{
  bool retval.283;
  bool iftmp.284;
  bool D.110290;
  struct CppObjectType * const iftmp.285;
  int (*__vtbl_ptr_type) () * D.110300;
  int (*__vtbl_ptr_type) () * D.110301;
  int (*__vtbl_ptr_type) () D.110302;
  struct VectorType D.104554;
  struct map D.104553;
  struct Variant D.104552;
  void * D.110303;
  struct GTypeClass * D.110306;
  void (*<T10237>) (struct GDBusProxy *, struct GVariant *, const gchar * const *) D.110309;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.110289>; else goto <D.110287>;
    <D.110289>:
    D.110290 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.110290 != 0) goto <D.110291>; else goto <D.110287>;
    <D.110291>:
    iftmp.284 = 1;
    goto <D.110288>;
    <D.110287>:
    iftmp.284 = 0;
    <D.110288>:
    retval.283 = iftmp.284;
    if (retval.283 != 0) goto <D.110292>; else goto <D.110293>;
    <D.110292>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.110295>; else goto <D.110296>;
      <D.110295>:
      iftmp.285 = 0B;
      goto <D.110297>;
      <D.110296>:
      iftmp.285 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus5ProxyE, -1);
      <D.110297>:
      obj = iftmp.285;
      if (obj != 0B) goto <D.110298>; else goto <D.110299>;
      <D.110298>:
      try
        {
          D.110300 = obj->D.101147._vptr.Object;
          D.110301 = D.110300 + 16;
          D.110302 = *D.110301;
          D.104554 = Glib::ArrayHandler<Glib::ustring>::array_to_vector (p1, 0); [return slot optimization]
          try
            {
              Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::Variant (&D.104552, p0, 1);
              try
                {
                  D.104553 = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::get (&D.104552); [return slot optimization]
                  try
                    {
                      OBJ_TYPE_REF(D.110302;(struct Proxy)obj->2) (obj, &D.104553, &D.104554);
                    }
                  finally
                    {
                      std::map<Glib::ustring, Glib::VariantBase>::~map (&D.104553);
                      D.104553 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::~Variant (&D.104552);
                  D.104552 = {CLOBBER};
                }
            }
          finally
            {
              std::vector<Glib::ustring>::~vector (&D.104554);
              D.104554 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.110303 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.110303);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.110304>;
      <D.110299>:
      <D.110304>:
    }
    goto <D.110305>;
    <D.110293>:
    <D.110305>:
  }
  D.110306 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.110306);
  if (base != 0B) goto <D.110307>; else goto <D.110308>;
  <D.110307>:
  D.110309 = base->g_properties_changed;
  if (D.110309 != 0B) goto <D.110310>; else goto <D.110311>;
  <D.110310>:
  D.110309 = base->g_properties_changed;
  D.110309 (self, p0, p1);
  goto <D.110312>;
  <D.110311>:
  <D.110312>:
  <D.110308>:
}


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

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


std::size_t Glib::Container_Helpers::compute_array_size2(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.110328;
  size_t D.110329;
  long int pend.286;
  long int array.287;
  long int D.110332;
  long int D.110333;

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

      pend = array;
      goto <D.107190>;
      <D.107191>:
      pend = pend + 8;
      <D.107190>:
      D.110328 = *pend;
      if (D.110328 != 0B) goto <D.107191>; else goto <D.107189>;
      <D.107189>:
      pend.286 = (long int) pend;
      array.287 = (long int) array;
      D.110332 = pend.286 - array.287;
      D.110333 = D.110332 /[ex] 8;
      D.110329 = (size_t) D.110333;
      return D.110329;
    }
    <D.110327>:
  }
  D.110329 = 0;
  return D.110329;
}


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

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

      try
        {
          Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayKeeper (&keeper, array, array_size, ownership);
          try
            {
              std::allocator<Glib::ustring>::allocator (&D.107283);
              try
                {
                  D.110338 = array_size * 8;
                  D.110339 = array + D.110338;
                  Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.107266, D.110339);
                  try
                    {
                      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayIterator (&D.107265, array);
                      try
                        {
                          std::vector<Glib::ustring>::vector<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (<retval>, D.107265, D.107266, &D.107283);
                          return <retval>;
                        }
                      finally
                        {
                          D.107265 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.107266 = {CLOBBER};
                    }
                }
              finally
                {
                  std::allocator<Glib::ustring>::~allocator (&D.107283);
                  D.107283 = {CLOBBER};
                }
            }
          finally
            {
              Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::~ArrayKeeper (&keeper);
            }
        }
      finally
        {
          keeper = {CLOBBER};
        }
    }
    <D.110337>:
  }
  std::vector<Glib::ustring>::vector (<retval>);
  return <retval>;
}


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


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

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


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

  try
    {
      {

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


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


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

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

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


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

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

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


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

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


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

  try
    {
      {

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


void std::vector<_Tp, _Alloc>::_M_initialize_dispatch(_InputIterator, _InputIterator, std::__false_type) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct __false_type D.107733)
{
  struct forward_iterator_tag D.108052;
  struct _IterCategory D.108024;
  struct _IterCategory * D.110360;
  struct forward_iterator_tag D.110361;
  typedef struct _IterCategory _IterCategory;

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


void std::vector<_Tp, _Alloc>::_M_range_initialize(_ForwardIterator, _ForwardIterator, std::forward_iterator_tag) [with _ForwardIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this, struct ArrayIterator __first, struct ArrayIterator __last, struct forward_iterator_tag D.108029)
{
  long int D.110363;
  struct _Vector_base * D.110364;
  struct ustring * D.110365;
  struct ustring * D.110366;
  long unsigned int D.110367;
  struct ustring * D.110368;
  struct _Tp_alloc_type & D.110369;
  struct ustring * D.110370;
  const size_type __n;

  D.110363 = std::distance<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> > > (__first, __last);
  __n = (const size_type) D.110363;
  D.110364 = &this->D.104404;
  D.110365 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_allocate (D.110364, __n);
  this->D.104404._M_impl._M_start = D.110365;
  D.110366 = this->D.104404._M_impl._M_start;
  D.110367 = __n * 8;
  D.110368 = D.110366 + D.110367;
  this->D.104404._M_impl._M_end_of_storage = D.110368;
  D.110364 = &this->D.104404;
  D.110369 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.110364);
  D.110366 = this->D.104404._M_impl._M_start;
  D.110370 = std::__uninitialized_copy_a<Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >, Glib::ustring*, Glib::ustring> (__first, __last, D.110366, D.110369);
  this->D.104404._M_impl._M_finish = D.110370;
}


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

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


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

  return D.110380;
}


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

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


Glib::Container_Helpers::ArrayIterator<Tr>::difference_type Glib::Container_Helpers::ArrayIterator<Tr>::operator-(const Glib::Container_Helpers::ArrayIterator<Tr>&) const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::Container_Helpers::ArrayIterator<Tr>::difference_type = long int] (const struct ArrayIterator * const this, const struct ArrayIterator & rhs)
{
  difference_type D.110384;
  const char * const * D.110385;
  long int D.110386;
  const char * const * D.110387;
  long int D.110388;
  long int D.110389;

  D.110385 = this->pos_;
  D.110386 = (long int) D.110385;
  D.110387 = rhs->pos_;
  D.110388 = (long int) D.110387;
  D.110389 = D.110386 - D.110388;
  D.110384 = D.110389 /[ex] 8;
  return D.110384;
}


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.110391;
  struct ustring * iftmp.288;
  struct _Vector_impl * D.110395;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.110393>; else goto <D.110394>;
  <D.110393>:
  D.110395 = &this->_M_impl;
  iftmp.288 = __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::allocate (D.110395, __n);
  goto <D.110396>;
  <D.110394>:
  iftmp.288 = 0B;
  <D.110396>:
  D.110391 = iftmp.288;
  return D.110391;
}


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

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


_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.103717)
{
  bool retval.289;
  long unsigned int D.110403;
  struct ustring * D.110406;
  long unsigned int D.110407;

  D.110403 = __gnu_cxx::new_allocator<Glib::ustring>::max_size (this);
  retval.289 = D.110403 < __n;
  if (retval.289 != 0) goto <D.110404>; else goto <D.110405>;
  <D.110404>:
  std::__throw_bad_alloc ();
  <D.110405>:
  D.110407 = __n * 8;
  D.110406 = operator new (D.110407);
  return D.110406;
}


__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.110410;
  void * D.110411;

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


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

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


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

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


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

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


static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; _ForwardIterator = Glib::ustring*; bool _TrivialValueTypes = false] (struct ArrayIterator __first, struct ArrayIterator __last, struct ustring * __result)
{
  struct value_type D.108361;
  struct ustring * D.110421;
  bool retval.290;
  struct ustring * D.110423;
  void * D.110424;
  struct ustring * __cur;

  __cur = __result;
  try
    {
      goto <D.108365>;
      <D.108364>:
      D.108361 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator* (&__first); [return slot optimization]
      try
        {
          D.110421 = std::__addressof<Glib::ustring> (__cur);
          std::_Construct<Glib::ustring, Glib::ustring> (D.110421, &D.108361);
        }
      finally
        {
          Glib::ustring::~ustring (&D.108361);
          D.108361 = {CLOBBER};
        }
      Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator++ (&__first);
      __cur = __cur + 8;
      <D.108365>:
      retval.290 = Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::operator!= (&__first, &__last);
      if (retval.290 != 0) goto <D.108364>; else goto <D.108362>;
      <D.108362>:
      D.110423 = __cur;
      return D.110423;
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.110424 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.110424);
              std::_Destroy<Glib::ustring*> (__result, __cur);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
}


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

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


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

  if (str != 0B) goto <D.110435>; else goto <D.110436>;
  <D.110435>:
  D.110437 = <retval>;
  Glib::ustring::ustring (D.110437, str);
  goto <D.110438>;
  <D.110436>:
  D.110437 = <retval>;
  Glib::ustring::ustring (D.110437);
  <D.110438>:
  return <retval>;
}


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

  D.110440 = __r;
  return D.110440;
}


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

  D.108339 = __p;
  D.108340 = operator new (8, D.108339);
  if (D.108340 != 0B) goto <D.110443>; else goto <D.110444>;
  <D.110443>:
  try
    {
      Glib::ustring::ustring (D.108340, __value);
    }
  catch
    {
      operator delete (D.108340, D.108339);
    }
  iftmp.291 = D.108340;
  goto <D.110445>;
  <D.110444>:
  iftmp.291 = D.108340;
  <D.110445>:
}


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

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


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

  try
    {

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


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

  D.110451 = this->pos_;
  D.110452 = D.110451 + 8;
  this->pos_ = D.110452;
  D.110453 = this;
  return D.110453;
}


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

  D.110456 = this->pos_;
  D.110457 = rhs->pos_;
  D.110455 = D.110456 != D.110457;
  return D.110455;
}


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

  goto <D.108113>;
  <D.108112>:
  D.110459 = std::__addressof<Glib::ustring> (__first);
  std::_Destroy<Glib::ustring> (D.110459);
  __first = __first + 8;
  <D.108113>:
  if (__first != __last) goto <D.108112>; else goto <D.108110>;
  <D.108110>:
}


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.110460;
  long int D.110461;
  struct ustring * D.110462;
  long int D.110463;
  long int D.110464;
  long int D.110465;
  long unsigned int D.110466;
  struct _Vector_impl * D.110467;

  {
    try
      {
        try
          {
            D.110460 = this->_M_impl._M_end_of_storage;
            D.110461 = (long int) D.110460;
            D.110462 = this->_M_impl._M_start;
            D.110463 = (long int) D.110462;
            D.110464 = D.110461 - D.110463;
            D.110465 = D.110464 /[ex] 8;
            D.110466 = (long unsigned int) D.110465;
            D.110462 = this->_M_impl._M_start;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_deallocate (this, D.110462, D.110466);
          }
        finally
          {
            D.110467 = &this->_M_impl;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_Vector_impl::~_Vector_impl (D.110467);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.107350>:
}


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

  if (__p != 0B) goto <D.110470>; else goto <D.110471>;
  <D.110470>:
  D.110472 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<Glib::ustring> >::deallocate (D.110472, __p, __n);
  goto <D.110473>;
  <D.110471>:
  <D.110473>:
}


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.103721)
{
  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.107345>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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

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


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

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

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


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


Glib::Container_Helpers::ArrayKeeper<Tr>::~ArrayKeeper() [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayKeeper * const this)
{
  const char * * D.110478;
  OwnershipType D.110481;
  long unsigned int D.110486;
  long unsigned int D.110487;
  const char * D.110488;

  {
    try
      {
        {
          {
            D.110478 = this->array_;
            if (D.110478 != 0B) goto <D.110479>; else goto <D.110480>;
            <D.110479>:
            D.110481 = this->ownership_;
            if (D.110481 != 0) goto <D.110482>; else goto <D.110483>;
            <D.110482>:
            {
              {
                D.110481 = this->ownership_;
                if (D.110481 != 1) goto <D.110484>; else goto <D.110485>;
                <D.110484>:
                {
                  const char * const * const array_end;

                  D.110478 = this->array_;
                  D.110486 = this->array_size_;
                  D.110487 = D.110486 * 8;
                  array_end = D.110478 + D.110487;
                  {
                    const char * const * p;

                    p = this->array_;
                    goto <D.106874>;
                    <D.106875>:
                    D.110488 = *p;
                    Glib::Container_Helpers::TypeTraits<Glib::ustring>::release_c_type (D.110488);
                    p = p + 8;
                    <D.106874>:
                    if (p != array_end) goto <D.106875>; else goto <D.106876>;
                    <D.106876>:
                  }
                }
                goto <D.110489>;
                <D.110485>:
                <D.110489>:
              }
              D.110478 = this->array_;
              g_free (D.110478);
            }
            goto <D.110490>;
            <D.110483>:
            <D.110490>:
            <D.110480>:
          }
        }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106877>:
}


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


Glib::Variant<std::map<K, V> >::Variant(GVariant*, bool) [with K = Glib::ustring; V = Glib::VariantBase; GVariant = _GVariant] (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.110492;
  struct VariantContainerBase * D.110493;

  D.110492 = (int) take_a_reference;
  D.110493 = &this->D.102593;
  Glib::VariantContainerBase::VariantContainerBase (D.110493, castitem, D.110492);
  try
    {

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


std::map<K, V> Glib::Variant<std::map<K, V> >::get() const [with K = Glib::ustring; V = Glib::VariantBase] (const struct Variant * const this)
{
  struct pair D.106396;
  const struct value_type D.106280;
  struct pair D.106192;
  bool retval.292;
  struct map result [value-expr: *<retval>];
  struct VariantIter iter;
  struct Variant entry;

  try
    {
      std::map<Glib::ustring, Glib::VariantBase>::map (<retval>);
      try
        {
          iter = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::get_iter (this); [return slot optimization]
          try
            {
              Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::Variant (&entry);
              try
                {
                  goto <D.106399>;
                  <D.106400>:
                  D.106192 = Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::get (&entry); [return slot optimization]
                  try
                    {
                      std::pair<const Glib::ustring, Glib::VariantBase>::pair<Glib::ustring, Glib::VariantBase> (&D.106280, &D.106192);
                      try
                        {
                          D.106396 = std::map<Glib::ustring, Glib::VariantBase>::insert (<retval>, &D.106280);
                        }
                      finally
                        {
                          std::pair<const Glib::ustring, Glib::VariantBase>::~pair (&D.106280);
                          D.106280 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      std::pair<Glib::ustring, Glib::VariantBase>::~pair (&D.106192);
                      D.106192 = {CLOBBER};
                    }
                  <D.106399>:
                  retval.292 = Glib::VariantIter::next_value (&iter, &entry.D.106112.D.66789);
                  if (retval.292 != 0) goto <D.106400>; else goto <D.106398>;
                  <D.106398>:
                  return <retval>;
                }
              finally
                {
                  Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::~Variant (&entry);
                }
            }
          finally
            {
              Glib::VariantIter::~VariantIter (&iter);
            }
        }
      catch
        {
          std::map<Glib::ustring, Glib::VariantBase>::~map (<retval>);
        }
    }
  finally
    {
      iter = {CLOBBER};
      entry = {CLOBBER};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::map() [with _Key = Glib::ustring; _Tp = Glib::VariantBase; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct map * const this)
{
  struct _Rep_type * D.110507;

  D.110507 = &this->_M_t;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree (D.110507);
  try
    {

    }
  catch
    {
      D.110507 = &this->_M_t;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::~_Rb_tree (D.110507);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_impl * D.110508;

  D.110508 = &this->_M_impl;
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::_Rb_tree_impl (D.110508);
  try
    {

    }
  catch
    {
      D.110508 = &this->_M_impl;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl (D.110508);
    }
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_Rb_tree_impl() [with _Key_compare = std::less<Glib::ustring>; bool _Is_pod_comparator = false; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree_impl * const this)
{
  std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::allocator (this);
  try
    {
      this->_M_header._M_color = 0;
      this->_M_header._M_parent = 0B;
      this->_M_header._M_left = 0B;
      this->_M_header._M_right = 0B;
      this->_M_node_count = 0;
      std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::_M_initialize (this);
    }
  catch
    {
      std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::~allocator (this);
    }
}


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

  try
    {
      {
        __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.110509 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.110509);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct new_allocator * const this)
{
  void * D.110510;

  try
    {
      {

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


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Rb_tree_impl<_Key_compare, _Is_pod_comparator>::_M_initialize() [with _Key_compare = std::less<Glib::ustring>; bool _Is_pod_comparator = false; _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree_impl * const this)
{
  struct _Rb_tree_node_base * D.110511;

  this->_M_header._M_color = 0;
  this->_M_header._M_parent = 0B;
  D.110511 = &this->_M_header;
  this->_M_header._M_left = D.110511;
  D.110511 = &this->_M_header;
  this->_M_header._M_right = D.110511;
}


Glib::VariantIter Glib::Variant<std::map<K, V> >::get_iter() const [with K = Glib::ustring; V = Glib::VariantBase] (const struct Variant * const this)
{
  const struct VariantType & D.110513;
  const struct VariantType & D.110514;
  struct GVariantType * D.110515;
  const struct VariantBase * D.110516;
  const struct GVariant * D.110517;
  struct GVariantIter * g_iter.293;
  struct VariantType element_variant_type;
  struct VariantType array_variant_type;
  struct GVariantIter * g_iter;

  try
    {
      D.110513 = Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::variant_type ();
      Glib::VariantType::VariantType (&element_variant_type, D.110513);
      try
        {
          D.110514 = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::variant_type ();
          Glib::VariantType::VariantType (&array_variant_type, D.110514);
          try
            {
              g_iter = 0B;
              D.110515 = Glib::VariantType::gobj (&array_variant_type);
              D.110516 = &this->D.102593.D.66789;
              D.110517 = Glib::VariantBase::gobj (D.110516);
              g_variant_get (D.110517, D.110515, &g_iter);
              g_iter.293 = g_iter;
              Glib::VariantIter::VariantIter (<retval>, g_iter.293, 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};
    }
}


static const Glib::VariantType& Glib::Variant<std::pair<_T1, _T2> >::variant_type() [with K = Glib::ustring; V = Glib::VariantBase] ()
{
  long long int * _ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type.294;
  char D.110529;
  bool retval.295;
  int D.110533;
  bool D.107375;
  const struct VariantType & D.110539;
  const struct GVariantType * D.110540;
  const struct VariantType & D.110541;
  const struct GVariantType * D.110542;
  struct GVariantType * D.110543;
  const struct VariantType & D.110546;
  static struct VariantType type;

  _ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type.294 = &_ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type;
  D.110529 = MEM[(char *)_ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type.294];
  if (D.110529 == 0) goto <D.110530>; else goto <D.110531>;
  <D.110530>:
  D.110533 = __cxa_guard_acquire (&_ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type);
  retval.295 = D.110533 != 0;
  if (retval.295 != 0) goto <D.110534>; else goto <D.110535>;
  <D.110534>:
  D.107375 = 0;
  try
    {
      D.110539 = Glib::Variant<Glib::VariantBase>::variant_type ();
      D.110540 = Glib::VariantType::gobj (D.110539);
      D.110541 = Glib::Variant<Glib::ustring>::variant_type ();
      D.110542 = Glib::VariantType::gobj (D.110541);
      D.110543 = g_variant_type_new_dict_entry (D.110542, D.110540);
      Glib::VariantType::VariantType (&type, D.110543, 0);
      D.107375 = 1;
      __cxa_guard_release (&_ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type);
      __cxa_atexit (__comp_dtor , &type, &__dso_handle);
    }
  catch
    {
      if (D.107375 != 0) goto <D.110536>; else goto <D.110537>;
      <D.110536>:
      goto <D.110538>;
      <D.110537>:
      __cxa_guard_abort (&_ZGVZN4Glib7VariantISt4pairINS_7ustringENS_11VariantBaseEEE12variant_typeEvE4type);
      <D.110538>:
    }
  goto <D.110544>;
  <D.110535>:
  <D.110544>:
  goto <D.110545>;
  <D.110531>:
  <D.110545>:
  D.110546 = &type;
  return D.110546;
}


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

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


static const Glib::VariantType& Glib::Variant<std::map<K, V> >::variant_type() [with K = Glib::ustring; V = Glib::VariantBase] ()
{
  long long int * _ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type.296;
  char D.110555;
  bool retval.297;
  int D.110559;
  bool D.107382;
  const struct VariantType & D.110565;
  const struct VariantType & D.110568;
  static struct VariantType type;

  _ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type.296 = &_ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type;
  D.110555 = MEM[(char *)_ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type.296];
  if (D.110555 == 0) goto <D.110556>; else goto <D.110557>;
  <D.110556>:
  D.110559 = __cxa_guard_acquire (&_ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type);
  retval.297 = D.110559 != 0;
  if (retval.297 != 0) goto <D.110560>; else goto <D.110561>;
  <D.110560>:
  D.107382 = 0;
  try
    {
      D.110565 = Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::variant_type ();
      type = Glib::VariantType::create_array (D.110565); [return slot optimization]
      D.107382 = 1;
      __cxa_guard_release (&_ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type);
      __cxa_atexit (__comp_dtor , &type, &__dso_handle);
    }
  catch
    {
      if (D.107382 != 0) goto <D.110562>; else goto <D.110563>;
      <D.110562>:
      goto <D.110564>;
      <D.110563>:
      __cxa_guard_abort (&_ZGVZN4Glib7VariantISt3mapINS_7ustringENS_11VariantBaseESt4lessIS2_ESaISt4pairIKS2_S3_EEEE12variant_typeEvE4type);
      <D.110564>:
    }
  goto <D.110566>;
  <D.110561>:
  <D.110566>:
  goto <D.110567>;
  <D.110557>:
  <D.110567>:
  D.110568 = &type;
  return D.110568;
}


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

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


Glib::Variant<std::pair<_T1, _T2> >::Variant() [with K = Glib::ustring; V = Glib::VariantBase] (struct Variant * const this)
{
  struct VariantContainerBase * D.110574;

  D.110574 = &this->D.106112;
  Glib::VariantContainerBase::VariantContainerBase (D.110574);
  try
    {

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


std::pair<_T1, _T2> Glib::Variant<std::pair<_T1, _T2> >::get() const [with K = Glib::ustring; V = Glib::VariantBase] (const struct Variant * const this)
{
  const struct VariantContainerBase * D.110576;
  struct VariantBase D.107096;
  struct ustring D.107095;
  struct Variant key;
  struct Variant value;
  struct pair result [value-expr: *<retval>];

  try
    {
      Glib::Variant<Glib::ustring>::Variant (&key);
      try
        {
          D.110576 = &this->D.106112;
          Glib::VariantContainerBase::get_child (D.110576, &key.D.66896.D.66743, 0);
          Glib::Variant<Glib::VariantBase>::Variant (&value);
          try
            {
              D.110576 = &this->D.106112;
              Glib::VariantContainerBase::get_child (D.110576, &value.D.66837.D.66789, 1);
              D.107096 = Glib::Variant<Glib::VariantBase>::get (&value); [return slot optimization]
              try
                {
                  D.107095 = Glib::Variant<Glib::ustring>::get (&key); [return slot optimization]
                  try
                    {
                      std::pair<Glib::ustring, Glib::VariantBase>::pair (<retval>, &D.107095, &D.107096);
                    }
                  finally
                    {
                      try
                        {
                          Glib::ustring::~ustring (&D.107095);
                        }
                      catch
                        {
                          std::pair<Glib::ustring, Glib::VariantBase>::~pair (<retval>);
                        }
                      D.107095 = {CLOBBER};
                    }
                }
              finally
                {
                  try
                    {
                      Glib::VariantBase::~VariantBase (&D.107096);
                    }
                  catch
                    {
                      std::pair<Glib::ustring, Glib::VariantBase>::~pair (<retval>);
                    }
                  D.107096 = {CLOBBER};
                }
              try
                {
                  return <retval>;
                }
              catch
                {
                  std::pair<Glib::ustring, Glib::VariantBase>::~pair (<retval>);
                }
            }
          finally
            {
              Glib::Variant<Glib::VariantBase>::~Variant (&value);
            }
        }
      finally
        {
          Glib::Variant<Glib::ustring>::~Variant (&key);
        }
    }
  finally
    {
      key = {CLOBBER};
      value = {CLOBBER};
    }
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = Glib::ustring; _T2 = Glib::VariantBase] (struct pair * const this, const struct ustring & __a, const struct VariantBase & __b)
{
  struct ustring * D.110588;
  struct VariantBase * D.110589;

  D.110588 = &this->first;
  Glib::ustring::ustring (D.110588, __a);
  try
    {
      D.110589 = &this->second;
      Glib::VariantBase::VariantBase (D.110589, __b);
      try
        {

        }
      catch
        {
          D.110589 = &this->second;
          Glib::VariantBase::~VariantBase (D.110589);
        }
    }
  catch
    {
      D.110588 = &this->first;
      Glib::ustring::~ustring (D.110588);
    }
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110591 = &this->D.66837;
            Glib::VariantContainerBase::~VariantContainerBase (D.110591);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.107091>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110595 = &this->D.66896;
            Glib::VariantStringBase::~VariantStringBase (D.110595);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.107065>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110597 = &this->D.66743;
            Glib::VariantBase::~VariantBase (D.110597);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.107060>:
}


std::pair<_T1, _T2>::pair(const std::pair<_U1, _U2>&) [with _U1 = Glib::ustring; _U2 = Glib::VariantBase; _T1 = const Glib::ustring; _T2 = Glib::VariantBase] (struct pair * const this, const struct pair & __p)
{
  const struct ustring * D.110599;
  const struct ustring * D.110600;
  const struct VariantBase * D.110601;
  struct VariantBase * D.110602;

  D.110599 = &__p->first;
  D.110600 = &this->first;
  Glib::ustring::ustring (D.110600, D.110599);
  try
    {
      D.110601 = &__p->second;
      D.110602 = &this->second;
      Glib::VariantBase::VariantBase (D.110602, D.110601);
      try
        {

        }
      catch
        {
          D.110602 = &this->second;
          Glib::VariantBase::~VariantBase (D.110602);
        }
    }
  catch
    {
      D.110600 = &this->first;
      Glib::ustring::~ustring (D.110600);
    }
}


std::pair<typename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, typename __gnu_cxx::__alloc_traits<_Allocator>::rebind<std::pair<const _Key, _Tp> >::other>::iterator, bool> std::map<_Key, _Tp, _Compare, _Alloc>::insert(const value_type&) [with _Key = Glib::ustring; _Tp = Glib::VariantBase; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; typename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, typename __gnu_cxx::__alloc_traits<_Allocator>::rebind<std::pair<const _Key, _Tp> >::other>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::map<_Key, _Tp, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::VariantBase>] (struct map * const this, const struct value_type & __x)
{
  struct pair D.110604;
  struct _Rep_type * D.110605;

  D.110605 = &this->_M_t;
  D.110604 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_insert_unique (D.110605, __x);
  return D.110604;
}


std::pair<std::_Rb_tree_iterator<_Val>, bool> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_unique(const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree * const this, const struct pair & __v)
{
  struct _Select1st D.107623;
  const struct first_type & D.110607;
  struct _Rb_tree_node_base * D.110608;
  struct pair D.110611;
  struct _Res D.107645;
  const bool D.107644;
  struct iterator D.107643;
  struct _Rb_tree_node_base * D.110612;
  struct _Res D.107648;
  const bool D.107647;
  struct iterator D.107646;
  typedef struct _Res _Res;
  struct pair __res;

  try
    {
      try
        {
          D.110607 = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >::operator() (&D.107623, __v);
          __res = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_get_insert_unique_pos (this, D.110607);
        }
      finally
        {
          D.107623 = {CLOBBER};
        }
      D.110608 = __res.second;
      if (D.110608 != 0B) goto <D.110609>; else goto <D.110610>;
      <D.110609>:
      D.107644 = 1;
      try
        {
          D.110608 = __res.second;
          D.110612 = __res.first;
          D.107643 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_insert_ (this, D.110612, D.110608, __v);
          try
            {
              std::pair<std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >, bool>::pair (&D.107645, &D.107643, &D.107644);
              try
                {
                  D.110611 = D.107645;
                  return D.110611;
                }
              finally
                {
                  D.107645 = {CLOBBER};
                }
            }
          finally
            {
              D.107643 = {CLOBBER};
            }
        }
      finally
        {
          D.107644 = {CLOBBER};
        }
      <D.110610>:
      D.107647 = 0;
      try
        {
          D.110612 = __res.first;
          std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_iterator (&D.107646, D.110612);
          try
            {
              std::pair<std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >, bool>::pair (&D.107648, &D.107646, &D.107647);
              try
                {
                  D.110611 = D.107648;
                  return D.110611;
                }
              finally
                {
                  D.107648 = {CLOBBER};
                }
            }
          finally
            {
              D.107646 = {CLOBBER};
            }
        }
      finally
        {
          D.107647 = {CLOBBER};
        }
    }
  finally
    {
      __res = {CLOBBER};
    }
}


const typename _Pair::first_type& std::_Select1st<_Pair>::operator()(const _Pair&) const [with _Pair = std::pair<const Glib::ustring, Glib::VariantBase>; typename _Pair::first_type = const Glib::ustring] (const struct _Select1st * const this, const struct pair & __x)
{
  const struct first_type & D.110624;

  D.110624 = &__x->first;
  return D.110624;
}


std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_unique_pos(const key_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = Glib::ustring] (struct _Rb_tree * const this, const struct key_type & __k)
{
  const struct ustring & D.110626;
  struct less * D.110627;
  struct _Rb_tree_node * iftmp.298;
  bool retval.299;
  struct iterator D.107926;
  struct pair D.110637;
  struct _Res D.107929;
  struct _Rb_tree_node_base * const D.107928;
  struct _Rb_tree_node_base * const D.107927;
  bool retval.300;
  struct _Rb_tree_node_base * D.110640;
  const struct ustring & D.110641;
  struct _Res D.107932;
  struct _Rb_tree_node_base * const D.107931;
  struct _Rb_tree_node_base * const D.107930;
  struct _Res D.107934;
  struct _Rb_tree_node_base * const D.107933;
  typedef struct _Res _Res;
  struct _Rb_tree_node * __x;
  struct _Rb_tree_node * __y;
  bool __comp;
  struct iterator __j;

  try
    {
      __x = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_begin (this);
      __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_end (this);
      __comp = 1;
      goto <D.107936>;
      <D.107937>:
      __y = __x;
      D.110626 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_key (__x);
      D.110627 = &this->_M_impl._M_key_compare;
      __comp = std::less<Glib::ustring>::operator() (D.110627, __k, D.110626);
      if (__comp != 0) goto <D.110629>; else goto <D.110630>;
      <D.110629>:
      iftmp.298 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_left (__x);
      goto <D.110631>;
      <D.110630>:
      iftmp.298 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_right (__x);
      <D.110631>:
      __x = iftmp.298;
      <D.107936>:
      if (__x != 0B) goto <D.107937>; else goto <D.107935>;
      <D.107935>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_iterator (&__j, __y);
      if (__comp != 0) goto <D.110632>; else goto <D.110633>;
      <D.110632>:
      D.107926 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::begin (this);
      try
        {
          retval.299 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::operator== (&__j, &D.107926);
        }
      finally
        {
          D.107926 = {CLOBBER};
        }
      if (retval.299 != 0) goto <D.110635>; else goto <D.110636>;
      <D.110635>:
      D.107928 = __y;
      try
        {
          D.107927 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.107929, &D.107927, &D.107928);
              try
                {
                  D.110637 = D.107929;
                  return D.110637;
                }
              finally
                {
                  D.107929 = {CLOBBER};
                }
            }
          finally
            {
              D.107927 = {CLOBBER};
            }
        }
      finally
        {
          D.107928 = {CLOBBER};
        }
      <D.110636>:
      std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::operator-- (&__j);
      goto <D.110638>;
      <D.110633>:
      <D.110638>:
      D.110640 = __j._M_node;
      D.110641 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_key (D.110640);
      D.110627 = &this->_M_impl._M_key_compare;
      retval.300 = std::less<Glib::ustring>::operator() (D.110627, D.110641, __k);
      if (retval.300 != 0) goto <D.110642>; else goto <D.110643>;
      <D.110642>:
      D.107931 = __y;
      try
        {
          D.107930 = __x;
          try
            {
              std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.107932, &D.107930, &D.107931);
              try
                {
                  D.110637 = D.107932;
                  return D.110637;
                }
              finally
                {
                  D.107932 = {CLOBBER};
                }
            }
          finally
            {
              D.107930 = {CLOBBER};
            }
        }
      finally
        {
          D.107931 = {CLOBBER};
        }
      <D.110643>:
      D.107933 = 0B;
      try
        {
          std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*>::pair (&D.107934, &__j._M_node, &D.107933);
          try
            {
              D.110637 = D.107934;
              return D.110637;
            }
          finally
            {
              D.107934 = {CLOBBER};
            }
        }
      finally
        {
          D.107933 = {CLOBBER};
        }
    }
  finally
    {
      __j = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.110659;

  D.110659 = this->_M_impl._M_header._M_parent;
  return D.110659;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_end() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.110661;

  D.110661 = &this->_M_impl._M_header;
  return D.110661;
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (const struct _Rb_tree_node * __x)
{
  const struct ustring & D.110663;
  const struct value_type & D.110664;
  struct _Select1st D.108142;

  D.110664 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_value (__x);
  try
    {
      D.110663 = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >::operator() (&D.108142, D.110664);
      return D.110663;
    }
  finally
    {
      D.108142 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, Glib::VariantBase>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (const struct _Rb_tree_node * __x)
{
  const struct value_type & D.110668;

  D.110668 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >::_M_valptr (__x);
  return D.110668;
}


const _Val* std::_Rb_tree_node<_Val>::_M_valptr() const [with _Val = std::pair<const Glib::ustring, Glib::VariantBase>] (const struct _Rb_tree_node * const this)
{
  const struct pair * D.110671;
  const struct pair * D.110672;

  D.110672 = &this->_M_value_field;
  D.110671 = std::__addressof<const std::pair<const Glib::ustring, Glib::VariantBase> > (D.110672);
  return D.110671;
}


_Tp* std::__addressof(_Tp&) [with _Tp = const std::pair<const Glib::ustring, Glib::VariantBase>] (const struct pair & __r)
{
  const struct pair * D.110674;

  D.110674 = __r;
  return D.110674;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_left(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.110676;

  D.110676 = __x->_M_left;
  return D.110676;
}


static std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_right(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree_node_base * __x)
{
  struct _Rb_tree_node * D.110678;

  D.110678 = __x->_M_right;
  return D.110678;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::begin() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree * const this)
{
  struct iterator D.110680;
  struct iterator D.108145;
  struct _Rb_tree_node_base * D.110681;

  D.110681 = this->_M_impl._M_header._M_left;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_iterator (&D.108145, D.110681);
  try
    {
      D.110680 = D.108145;
      return D.110680;
    }
  finally
    {
      D.108145 = {CLOBBER};
    }
}


bool std::_Rb_tree_iterator<_Tp>::operator==(const _Self&) const [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct _Rb_tree_iterator * const this, const struct _Self & __x)
{
  bool D.110684;
  struct _Rb_tree_node_base * D.110685;
  struct _Rb_tree_node_base * D.110686;

  D.110685 = this->_M_node;
  D.110686 = __x->_M_node;
  D.110684 = D.110685 == D.110686;
  return D.110684;
}


std::_Rb_tree_iterator<_Tp>::_Self& std::_Rb_tree_iterator<_Tp>::operator--() [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_iterator<_Tp>::_Self = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree_iterator * const this)
{
  struct _Rb_tree_node_base * D.110688;
  struct _Rb_tree_node_base * D.110689;
  struct _Self & D.110690;

  D.110688 = this->_M_node;
  D.110689 = std::_Rb_tree_decrement (D.110688);
  this->_M_node = D.110689;
  D.110690 = this;
  return D.110690;
}


static const _Key& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_key(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct ustring & D.110692;
  const struct value_type & D.110693;
  struct _Select1st D.108152;

  D.110693 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_value (__x);
  try
    {
      D.110692 = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >::operator() (&D.108152, D.110693);
      return D.110692;
    }
  finally
    {
      D.108152 = {CLOBBER};
    }
}


static const value_type& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_S_value(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_reference = const std::pair<const Glib::ustring, Glib::VariantBase>&; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Const_Base_ptr = const std::_Rb_tree_node_base*] (const struct _Rb_tree_node_base * __x)
{
  const struct value_type & D.110697;

  D.110697 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >::_M_valptr (__x);
  return D.110697;
}


bool std::less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = Glib::ustring] (const struct less * const this, const struct ustring & __x, const struct ustring & __y)
{
  bool D.110700;

  D.110700 = Glib::operator< (__x, __y);
  return D.110700;
}


bool Glib::operator<(const Glib::ustring&, const Glib::ustring&) (const struct ustring & lhs, const struct ustring & rhs)
{
  bool D.110703;
  int D.110704;

  D.110704 = Glib::ustring::compare (lhs, rhs);
  D.110703 = D.110704 < 0;
  return D.110703;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = std::_Rb_tree_node_base*; _T2 = std::_Rb_tree_node_base*] (struct pair * const this, struct _Rb_tree_node_base * const & __a, struct _Rb_tree_node_base * const & __b)
{
  struct _Rb_tree_node_base * D.110707;
  struct _Rb_tree_node_base * D.110708;

  D.110707 = *__a;
  this->first = D.110707;
  D.110708 = *__b;
  this->second = D.110708;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr, const _Val&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr = std::_Rb_tree_node_base*] (struct _Rb_tree * const this, struct _Rb_tree_node_base * __x, struct _Rb_tree_node_base * __p, const struct pair & __v)
{
  bool iftmp.301;
  struct _Rb_tree_node * D.110714;
  const struct ustring & D.110716;
  struct _Select1st D.107941;
  bool cleanup.302;
  const struct first_type & D.110720;
  struct less * D.110721;
  bool D.110722;
  struct _Rb_tree_node_base * D.110723;
  int D.110724;
  long unsigned int D.110725;
  long unsigned int D.110726;
  struct iterator D.110727;
  struct iterator D.107943;
  bool __insert_left;
  struct _Rb_tree_node * __z;

  cleanup.302 = 0;
  try
    {
      if (__x != 0B) goto <D.110710>; else goto <D.110713>;
      <D.110713>:
      D.110714 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_end (this);
      if (D.110714 == __p) goto <D.110710>; else goto <D.110715>;
      <D.110715>:
      D.110716 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_key (__p);
      cleanup.302 = 1;
      D.110720 = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >::operator() (&D.107941, __v);
      D.110721 = &this->_M_impl._M_key_compare;
      D.110722 = std::less<Glib::ustring>::operator() (D.110721, D.110720, D.110716);
      if (D.110722 != 0) goto <D.110710>; else goto <D.110711>;
      <D.110710>:
      iftmp.301 = 1;
      goto <D.110712>;
      <D.110711>:
      iftmp.301 = 0;
      <D.110712>:
      __insert_left = iftmp.301;
    }
  finally
    {
      if (cleanup.302 != 0) goto <D.110718>; else goto <D.110719>;
      <D.110718>:
      D.107941 = {CLOBBER};
      <D.110719>:
    }
  __z = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_create_node (this, __v);
  D.110723 = &this->_M_impl._M_header;
  D.110724 = (int) __insert_left;
  std::_Rb_tree_insert_and_rebalance (D.110724, __z, __p, D.110723);
  D.110725 = this->_M_impl._M_node_count;
  D.110726 = D.110725 + 1;
  this->_M_impl._M_node_count = D.110726;
  std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_iterator (&D.107943, __z);
  try
    {
      D.110727 = D.107943;
      return D.110727;
    }
  finally
    {
      D.107943 = {CLOBBER};
    }
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_create_node(const value_type&) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::value_type = std::pair<const Glib::ustring, Glib::VariantBase>] (struct _Rb_tree * const this, const struct value_type & __x)
{
  struct pair * D.110736;
  struct allocator_type D.108155;
  void * D.110737;
  struct _Rb_tree_node * D.110738;
  struct _Rb_tree_node * __tmp;

  __tmp = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_get_node (this);
  try
    {
      D.110736 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >::_M_valptr (__tmp);
      D.108155 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::get_allocator (this); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::construct (&D.108155, D.110736, __x);
        }
      finally
        {
          std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::~allocator (&D.108155);
          D.108155 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.110737 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.110737);
              std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_put_node (this, __tmp);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.110738 = __tmp;
  return D.110738;
}


std::_Rb_tree_node<_Val>* std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_node() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.110746;
  struct _Node_allocator & D.110747;

  D.110747 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_get_Node_allocator (this);
  D.110746 = __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > > >::allocate (D.110747, 1);
  return D.110746;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >] (struct _Rb_tree * const this)
{
  struct _Node_allocator & D.110750;

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


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

  D.110752 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::allocate (__a, __n, 0B);
  return D.110752;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >; __gnu_cxx::new_allocator<_Tp>::pointer = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.102952)
{
  bool retval.303;
  long unsigned int D.110756;
  struct _Rb_tree_node * D.110759;
  long unsigned int D.110760;

  D.110756 = __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::max_size (this);
  retval.303 = D.110756 < __n;
  if (retval.303 != 0) goto <D.110757>; else goto <D.110758>;
  <D.110757>:
  std::__throw_bad_alloc ();
  <D.110758>:
  D.110760 = __n * 48;
  D.110759 = operator new (D.110760);
  return D.110759;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.110763;
  void * D.110764;

  try
    {
      D.110763 = 384307168202282325;
      return D.110763;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.110764 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.110764);
          
        }
    }
}


_Val* std::_Rb_tree_node<_Val>::_M_valptr() [with _Val = std::pair<const Glib::ustring, Glib::VariantBase>] (struct _Rb_tree_node * const this)
{
  struct pair * D.110766;
  struct pair * D.110767;

  D.110767 = &this->_M_value_field;
  D.110766 = std::__addressof<std::pair<const Glib::ustring, Glib::VariantBase> > (D.110767);
  return D.110766;
}


_Tp* std::__addressof(_Tp&) [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>] (struct pair & __r)
{
  struct pair * D.110769;

  D.110769 = __r;
  return D.110769;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::get_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.110772;

  D.110772 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_get_Node_allocator (this);
  std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > > (<retval>, D.110772);
  return <retval>;
}


const _Node_allocator& std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_Node_allocator() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Node_allocator = std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >] (const struct _Rb_tree * const this)
{
  const struct _Node_allocator & D.110774;

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


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator<_Tp1>&) [with _Tp1 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >; _Tp = std::pair<const Glib::ustring, Glib::VariantBase>] (struct allocator * const this, const struct allocator & D.107978)
{
  void * D.110776;

  try
    {
      {
        __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.110776 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.110776);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>] (struct new_allocator * const this)
{
  void * D.110777;

  try
    {
      {

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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; __gnu_cxx::new_allocator<_Tp>::pointer = std::pair<const Glib::ustring, Glib::VariantBase>*] (struct new_allocator * const this, struct pair * __p, const struct pair & __val)
{
  void * D.108273;
  void * D.108274;
  struct pair * iftmp.304;

  D.108273 = __p;
  D.108274 = operator new (16, D.108273);
  if (D.108274 != 0B) goto <D.110779>; else goto <D.110780>;
  <D.110779>:
  try
    {
      std::pair<const Glib::ustring, Glib::VariantBase>::pair (D.108274, __val);
    }
  catch
    {
      operator delete (D.108274, D.108273);
    }
  iftmp.304 = D.108274;
  goto <D.110781>;
  <D.110780>:
  iftmp.304 = D.108274;
  <D.110781>:
}


std::pair<const Glib::ustring, Glib::VariantBase>::pair(const std::pair<const Glib::ustring, Glib::VariantBase>&) (struct pair * const this, const struct pair & D.106270)
{
  const struct ustring * D.110783;
  const struct ustring * D.110784;
  const struct VariantBase * D.110785;
  struct VariantBase * D.110786;

  D.110783 = &D.106270->first;
  D.110784 = &this->first;
  Glib::ustring::ustring (D.110784, D.110783);
  try
    {
      D.110785 = &D.106270->second;
      D.110786 = &this->second;
      Glib::VariantBase::VariantBase (D.110786, D.110785);
      try
        {

        }
      catch
        {
          D.110786 = &this->second;
          Glib::VariantBase::~VariantBase (D.110786);
        }
    }
  catch
    {
      D.110784 = &this->first;
      Glib::ustring::~ustring (D.110784);
    }
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.107993>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.110788 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.110788);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_put_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct _Node_allocator & D.110790;

  D.110790 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_get_Node_allocator (this);
  __gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > > >::deallocate (D.110790, __p, 1);
}


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


std::_Rb_tree_iterator<_Tp>::_Rb_tree_iterator(std::_Rb_tree_iterator<_Tp>::_Link_type) [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_iterator<_Tp>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree_iterator * const this, struct _Rb_tree_node * __x)
{
  this->_M_node = __x;
}


std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = std::_Rb_tree_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >; _T2 = bool] (struct pair * const this, const struct _Rb_tree_iterator & __a, const bool & __b)
{
  bool D.110791;

  this->first = *__a;
  D.110791 = *__b;
  this->second = D.110791;
}


std::pair<const Glib::ustring, Glib::VariantBase>::~pair() (struct pair * const this)
{
  struct VariantBase * D.110792;
  const struct ustring * D.110793;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.110792 = &this->second;
                Glib::VariantBase::~VariantBase (D.110792);
              }
          }
        finally
          {
            D.110793 = &this->first;
            Glib::ustring::~ustring (D.110793);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106294>:
}


std::pair<Glib::ustring, Glib::VariantBase>::~pair() (struct pair * const this)
{
  struct VariantBase * D.110796;
  struct ustring * D.110797;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.110796 = &this->second;
                Glib::VariantBase::~VariantBase (D.110796);
              }
          }
        finally
          {
            D.110797 = &this->first;
            Glib::ustring::~ustring (D.110797);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106206>:
}


Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::~Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.110800;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110800 = &this->D.106112;
            Glib::VariantContainerBase::~VariantContainerBase (D.110800);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106136>:
}


std::map<Glib::ustring, Glib::VariantBase>::~map() (struct map * const this)
{
  struct _Rep_type * D.110802;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110802 = &this->_M_t;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::~_Rb_tree (D.110802);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.103640>:
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::~_Rb_tree() [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree * const this)
{
  struct _Rb_tree_node * D.110804;
  struct _Rb_tree_impl * D.110805;

  {
    try
      {
        try
          {
            D.110804 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_begin (this);
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_erase (this, D.110804);
          }
        finally
          {
            D.110805 = &this->_M_impl;
            std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl (D.110805);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106439>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __x)
{
  struct _Rb_tree_node * D.110808;

  goto <D.107184>;
  <D.107185>:
  {
    struct _Rb_tree_node * __y;

    D.110808 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_right (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_erase (this, D.110808);
    __y = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_S_left (__x);
    std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_destroy_node (this, __x);
    __x = __y;
  }
  <D.107184>:
  if (__x != 0B) goto <D.107185>; else goto <D.107183>;
  <D.107183>:
}


void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_destroy_node(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type) [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Link_type = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree * const this, struct _Rb_tree_node * __p)
{
  struct pair * D.110809;
  struct allocator_type D.107706;

  D.110809 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >::_M_valptr (__p);
  D.107706 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::get_allocator (this); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::destroy (&D.107706, D.110809);
    }
  finally
    {
      std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >::~allocator (&D.107706);
      D.107706 = {CLOBBER};
    }
  std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_M_put_node (this, __p);
}


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


std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::_Rb_tree_impl<std::less<Glib::ustring>, false>::~_Rb_tree_impl() (struct _Rb_tree_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106434>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> > >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.107168>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.110812 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.110812);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct new_allocator * const this)
{
  void * D.110813;

  try
    {
      {
        try
          {

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


Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::~Variant() (struct Variant * const this)
{
  struct VariantContainerBase * D.110814;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.110814 = &this->D.102593;
            Glib::VariantContainerBase::~VariantContainerBase (D.110814);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.102618>:
}


std::vector<_Tp, _Alloc>::~vector() [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>] (struct vector * const this)
{
  struct _Vector_base * D.110816;
  struct _Tp_alloc_type & D.110817;
  struct ustring * D.110818;
  struct ustring * D.110819;

  {
    try
      {
        try
          {
            D.110816 = &this->D.104404;
            D.110817 = std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::_M_get_Tp_allocator (D.110816);
            D.110818 = this->D.104404._M_impl._M_finish;
            D.110819 = this->D.104404._M_impl._M_start;
            std::_Destroy<Glib::ustring*, Glib::ustring> (D.110819, D.110818, D.110817);
          }
        finally
          {
            D.110816 = &this->D.104404;
            std::_Vector_base<Glib::ustring, std::allocator<Glib::ustring> >::~_Vector_base (D.110816);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106458>:
}


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


static void Gio::DBus::Proxy_Class::g_signal_callback(GDBusProxy*, const gchar*, const gchar*, GVariant*) (struct GDBusProxy * self, const gchar * p0, const gchar * p1, struct GVariant * p2)
{
  bool retval.305;
  bool iftmp.306;
  bool D.110827;
  struct CppObjectType * const iftmp.307;
  int (*__vtbl_ptr_type) () * D.110837;
  int (*__vtbl_ptr_type) () * D.110838;
  int (*__vtbl_ptr_type) () D.110839;
  struct VariantContainerBase D.104567;
  struct ustring D.104566;
  struct ustring D.104565;
  void * D.110840;
  struct GTypeClass * D.110843;
  void (*<T1023b>) (struct GDBusProxy *, const gchar *, const gchar *, struct GVariant *) D.110846;
  struct ObjectBase * const obj_base;
  struct BaseClassType * const base;

  obj_base = Glib::ObjectBase::_get_current_wrapper (self);
  {
    if (obj_base != 0B) goto <D.110826>; else goto <D.110824>;
    <D.110826>:
    D.110827 = Glib::ObjectBase::is_derived_ (obj_base);
    if (D.110827 != 0) goto <D.110828>; else goto <D.110824>;
    <D.110828>:
    iftmp.306 = 1;
    goto <D.110825>;
    <D.110824>:
    iftmp.306 = 0;
    <D.110825>:
    retval.305 = iftmp.306;
    if (retval.305 != 0) goto <D.110829>; else goto <D.110830>;
    <D.110829>:
    {
      struct CppObjectType * const obj;

      if (obj_base == 0B) goto <D.110832>; else goto <D.110833>;
      <D.110832>:
      iftmp.307 = 0B;
      goto <D.110834>;
      <D.110833>:
      iftmp.307 = __dynamic_cast (obj_base, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus5ProxyE, -1);
      <D.110834>:
      obj = iftmp.307;
      if (obj != 0B) goto <D.110835>; else goto <D.110836>;
      <D.110835>:
      try
        {
          D.110837 = obj->D.101147._vptr.Object;
          D.110838 = D.110837 + 24;
          D.110839 = *D.110838;
          Glib::VariantContainerBase::VariantContainerBase (&D.104567, p2, 1);
          try
            {
              D.104566 = Glib::convert_const_gchar_ptr_to_ustring (p1); [return slot optimization]
              try
                {
                  D.104565 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
                  try
                    {
                      OBJ_TYPE_REF(D.110839;(struct Proxy)obj->3) (obj, &D.104565, &D.104566, &D.104567);
                    }
                  finally
                    {
                      Glib::ustring::~ustring (&D.104565);
                      D.104565 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::ustring::~ustring (&D.104566);
                  D.104566 = {CLOBBER};
                }
            }
          finally
            {
              Glib::VariantContainerBase::~VariantContainerBase (&D.104567);
              D.104567 = {CLOBBER};
            }
          return;
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.110840 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.110840);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      goto <D.110841>;
      <D.110836>:
      <D.110841>:
    }
    goto <D.110842>;
    <D.110830>:
    <D.110842>:
  }
  D.110843 = MEM[(struct GTypeInstance *)self].g_class;
  base = g_type_class_peek_parent (D.110843);
  if (base != 0B) goto <D.110844>; else goto <D.110845>;
  <D.110844>:
  D.110846 = base->g_signal;
  if (D.110846 != 0B) goto <D.110847>; else goto <D.110848>;
  <D.110847>:
  D.110846 = base->g_signal;
  D.110846 (self, p0, p1, p2);
  goto <D.110849>;
  <D.110848>:
  <D.110849>:
  <D.110845>:
}


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

  if (str != 0B) goto <D.110861>; else goto <D.110862>;
  <D.110861>:
  D.110863 = <retval>;
  Glib::ustring::ustring (D.110863, str);
  goto <D.110864>;
  <D.110862>:
  D.110863 = <retval>;
  Glib::ustring::ustring (D.110863);
  <D.110864>:
  return <retval>;
}


static Glib::ObjectBase* Gio::DBus::Proxy_Class::wrap_new(GObject*) (struct GObject * object)
{
  struct ObjectBase * D.110866;
  struct ObjectBase * iftmp.308;
  void * D.104573;
  void * D.110868;
  int (*__vtbl_ptr_type) () * D.110871;
  int (*__vtbl_ptr_type) () * D.110872;
  long int D.110873;
  sizetype D.110874;

  D.104573 = operator new (64);
  try
    {
      Gio::DBus::Proxy::Proxy (D.104573, object);
    }
  catch
    {
      operator delete (D.104573);
    }
  D.110868 = D.104573;
  if (D.110868 != 0B) goto <D.110869>; else goto <D.110870>;
  <D.110869>:
  D.110871 = MEM[(struct Proxy *)D.110868].D.101147._vptr.Object;
  D.110872 = D.110871 + 18446744073709551592;
  D.110873 = MEM[(long int *)D.110872];
  D.110874 = (sizetype) D.110873;
  iftmp.308 = D.110868 + D.110874;
  goto <D.110875>;
  <D.110870>:
  iftmp.308 = 0B;
  <D.110875>:
  D.110866 = iftmp.308;
  return D.110866;
}


GDBusProxy* Gio::DBus::Proxy::gobj_copy() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.110879;
  int (*__vtbl_ptr_type) () * D.110880;
  long int D.110881;
  sizetype D.110882;
  struct ObjectBase * D.110883;
  int (*__vtbl_ptr_type) () * D.110884;
  int (*__vtbl_ptr_type) () * D.110885;
  int (*__vtbl_ptr_type) () D.110886;
  struct GDBusProxy * D.110887;

  D.110879 = this->D.101147._vptr.Object;
  D.110880 = D.110879 + 18446744073709551592;
  D.110881 = MEM[(long int *)D.110880];
  D.110882 = (sizetype) D.110881;
  D.110883 = this + D.110882;
  D.110879 = this->D.101147._vptr.Object;
  D.110880 = D.110879 + 18446744073709551592;
  D.110881 = MEM[(long int *)D.110880];
  D.110882 = (sizetype) D.110881;
  D.110883 = this + D.110882;
  D.110884 = D.110883->_vptr.ObjectBase;
  D.110885 = D.110884 + 16;
  D.110886 = *D.110885;
  D.110879 = this->D.101147._vptr.Object;
  D.110880 = D.110879 + 18446744073709551592;
  D.110881 = MEM[(long int *)D.110880];
  D.110882 = (sizetype) D.110881;
  D.110883 = this + D.110882;
  OBJ_TYPE_REF(D.110886;(const struct ObjectBase)D.110883->2) (D.110883);
  D.110887 = Gio::DBus::Proxy::gobj (this);
  return D.110887;
}


Gio::DBus::Proxy::Proxy(const Glib::ConstructParams&) (struct Proxy * const this, const void * * __vtt_parm, const struct ConstructParams & construct_params)
{
  struct trackable * D.110891;
  const void * * iftmp.309;
  struct ObjectBase * D.110899;
  const void * * iftmp.310;
  struct Object * D.110905;
  const void * * iftmp.311;
  struct Initable * D.110910;
  const void * * iftmp.312;
  struct AsyncInitable * D.110915;
  int (*__vtbl_ptr_type) () * iftmp.313;
  sizetype iftmp.314;
  int (*__vtbl_ptr_type) () * D.110923;
  int (*__vtbl_ptr_type) () * D.110924;
  long int D.110925;
  struct ObjectBase * D.110927;
  int (*__vtbl_ptr_type) () * iftmp.315;
  int (*__vtbl_ptr_type) () * iftmp.316;
  int (*__vtbl_ptr_type) () * iftmp.317;
  const void * * iftmp.318;
  const void * * iftmp.319;
  const void * * iftmp.320;
  const void * * iftmp.321;

  if (0 != 0) goto <D.110889>; else goto <D.110890>;
  <D.110889>:
  D.110891 = &this->D.101154;
  sigc::trackable::trackable (D.110891);
  goto <D.110892>;
  <D.110890>:
  <D.110892>:
  try
    {
      if (0 != 0) goto <D.110893>; else goto <D.110894>;
      <D.110893>:
      if (0 == 0) goto <D.110896>; else goto <D.110897>;
      <D.110896>:
      iftmp.309 = __vtt_parm + 112;
      goto <D.110898>;
      <D.110897>:
      iftmp.309 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.110898>:
      D.110899 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.110899, iftmp.309);
      goto <D.110900>;
      <D.110894>:
      <D.110900>:
      try
        {
          if (0 == 0) goto <D.110902>; else goto <D.110903>;
          <D.110902>:
          iftmp.310 = __vtt_parm + 8;
          goto <D.110904>;
          <D.110903>:
          iftmp.310 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
          <D.110904>:
          D.110905 = &this->D.101147;
          Glib::Object::Object (D.110905, iftmp.310, construct_params);
          try
            {
              if (0 == 0) goto <D.110907>; else goto <D.110908>;
              <D.110907>:
              iftmp.311 = __vtt_parm + 24;
              goto <D.110909>;
              <D.110908>:
              iftmp.311 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.110909>:
              D.110910 = &this->D.101148;
              Gio::Initable::Initable (D.110910, iftmp.311);
              try
                {
                  if (0 == 0) goto <D.110912>; else goto <D.110913>;
                  <D.110912>:
                  iftmp.312 = __vtt_parm + 56;
                  goto <D.110914>;
                  <D.110913>:
                  iftmp.312 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.110914>:
                  D.110915 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.110915, iftmp.312);
                  try
                    {
                      if (0 == 0) goto <D.110917>; else goto <D.110918>;
                      <D.110917>:
                      iftmp.313 = *__vtt_parm;
                      goto <D.110919>;
                      <D.110918>:
                      iftmp.313 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.110919>:
                      this->D.101147._vptr.Object = iftmp.313;
                      if (0 == 0) goto <D.110921>; else goto <D.110922>;
                      <D.110921>:
                      D.110923 = this->D.101147._vptr.Object;
                      D.110924 = D.110923 + 18446744073709551592;
                      D.110925 = MEM[(long int *)D.110924];
                      iftmp.314 = (sizetype) D.110925;
                      goto <D.110926>;
                      <D.110922>:
                      iftmp.314 = 24;
                      <D.110926>:
                      D.110927 = this + iftmp.314;
                      if (0 == 0) goto <D.110929>; else goto <D.110930>;
                      <D.110929>:
                      iftmp.315 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.110931>;
                      <D.110930>:
                      iftmp.315 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.110931>:
                      D.110927->_vptr.ObjectBase = iftmp.315;
                      if (0 == 0) goto <D.110933>; else goto <D.110934>;
                      <D.110933>:
                      iftmp.316 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.110935>;
                      <D.110934>:
                      iftmp.316 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.110935>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.316;
                      if (0 == 0) goto <D.110937>; else goto <D.110938>;
                      <D.110937>:
                      iftmp.317 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.110939>;
                      <D.110938>:
                      iftmp.317 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.110939>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.317;
                    }
                  catch
                    {
                      if (0 == 0) goto <D.110941>; else goto <D.110942>;
                      <D.110941>:
                      iftmp.318 = __vtt_parm + 56;
                      goto <D.110943>;
                      <D.110942>:
                      iftmp.318 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.110943>:
                      D.110915 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.110915, iftmp.318);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.110945>; else goto <D.110946>;
                  <D.110945>:
                  iftmp.319 = __vtt_parm + 24;
                  goto <D.110947>;
                  <D.110946>:
                  iftmp.319 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.110947>:
                  D.110910 = &this->D.101148;
                  Gio::Initable::~Initable (D.110910, iftmp.319);
                }
            }
          catch
            {
              if (0 == 0) goto <D.110949>; else goto <D.110950>;
              <D.110949>:
              iftmp.320 = __vtt_parm + 8;
              goto <D.110951>;
              <D.110950>:
              iftmp.320 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.110951>:
              D.110905 = &this->D.101147;
              Glib::Object::~Object (D.110905, iftmp.320);
            }
        }
      catch
        {
          if (0 != 0) goto <D.110952>; else goto <D.110953>;
          <D.110952>:
          if (0 == 0) goto <D.110955>; else goto <D.110956>;
          <D.110955>:
          iftmp.321 = __vtt_parm + 112;
          goto <D.110957>;
          <D.110956>:
          iftmp.321 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.110957>:
          D.110899 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.110899, iftmp.321);
          goto <D.110958>;
          <D.110953>:
          <D.110958>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.110959>; else goto <D.110960>;
      <D.110959>:
      D.110891 = &this->D.101154;
      sigc::trackable::~trackable (D.110891);
      goto <D.110961>;
      <D.110960>:
      <D.110961>:
    }
}


Gio::DBus::Proxy::Proxy(const Glib::ConstructParams&) (struct Proxy * const this, const struct ConstructParams & construct_params)
{
  struct trackable * D.110968;
  const void * * iftmp.322;
  struct ObjectBase * D.110976;
  const void * * iftmp.323;
  struct Object * D.110982;
  const void * * iftmp.324;
  struct Initable * D.110987;
  const void * * iftmp.325;
  struct AsyncInitable * D.110992;
  int (*__vtbl_ptr_type) () * iftmp.326;
  const void * * D.110996;
  sizetype iftmp.327;
  int (*__vtbl_ptr_type) () * D.111001;
  int (*__vtbl_ptr_type) () * D.111002;
  long int D.111003;
  struct ObjectBase * D.111005;
  int (*__vtbl_ptr_type) () * iftmp.328;
  int (*__vtbl_ptr_type) () * iftmp.329;
  int (*__vtbl_ptr_type) () * iftmp.330;
  const void * * iftmp.331;
  const void * * iftmp.332;
  const void * * iftmp.333;
  const void * * iftmp.334;

  if (1 != 0) goto <D.110966>; else goto <D.110967>;
  <D.110966>:
  D.110968 = &this->D.101154;
  sigc::trackable::trackable (D.110968);
  goto <D.110969>;
  <D.110967>:
  <D.110969>:
  try
    {
      if (1 != 0) goto <D.110970>; else goto <D.110971>;
      <D.110970>:
      if (1 == 0) goto <D.110973>; else goto <D.110974>;
      <D.110973>:
      iftmp.322 = 112B;
      goto <D.110975>;
      <D.110974>:
      iftmp.322 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.110975>:
      D.110976 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.110976, iftmp.322);
      goto <D.110977>;
      <D.110971>:
      <D.110977>:
      try
        {
          if (1 == 0) goto <D.110979>; else goto <D.110980>;
          <D.110979>:
          iftmp.323 = 8B;
          goto <D.110981>;
          <D.110980>:
          iftmp.323 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
          <D.110981>:
          D.110982 = &this->D.101147;
          Glib::Object::Object (D.110982, iftmp.323, construct_params);
          try
            {
              if (1 == 0) goto <D.110984>; else goto <D.110985>;
              <D.110984>:
              iftmp.324 = 24B;
              goto <D.110986>;
              <D.110985>:
              iftmp.324 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.110986>:
              D.110987 = &this->D.101148;
              Gio::Initable::Initable (D.110987, iftmp.324);
              try
                {
                  if (1 == 0) goto <D.110989>; else goto <D.110990>;
                  <D.110989>:
                  iftmp.325 = 56B;
                  goto <D.110991>;
                  <D.110990>:
                  iftmp.325 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.110991>:
                  D.110992 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.110992, iftmp.325);
                  try
                    {
                      if (1 == 0) goto <D.110994>; else goto <D.110995>;
                      <D.110994>:
                      D.110996 = 0B;
                      iftmp.326 = *D.110996;
                      goto <D.110997>;
                      <D.110995>:
                      iftmp.326 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.110997>:
                      this->D.101147._vptr.Object = iftmp.326;
                      if (1 == 0) goto <D.110999>; else goto <D.111000>;
                      <D.110999>:
                      D.111001 = this->D.101147._vptr.Object;
                      D.111002 = D.111001 + 18446744073709551592;
                      D.111003 = MEM[(long int *)D.111002];
                      iftmp.327 = (sizetype) D.111003;
                      goto <D.111004>;
                      <D.111000>:
                      iftmp.327 = 24;
                      <D.111004>:
                      D.111005 = this + iftmp.327;
                      if (1 == 0) goto <D.111007>; else goto <D.111008>;
                      <D.111007>:
                      iftmp.328 = MEM[(const void * *)0B + 88B];
                      goto <D.111009>;
                      <D.111008>:
                      iftmp.328 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.111009>:
                      D.111005->_vptr.ObjectBase = iftmp.328;
                      if (1 == 0) goto <D.111011>; else goto <D.111012>;
                      <D.111011>:
                      iftmp.329 = MEM[(const void * *)0B + 96B];
                      goto <D.111013>;
                      <D.111012>:
                      iftmp.329 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.111013>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.329;
                      if (1 == 0) goto <D.111015>; else goto <D.111016>;
                      <D.111015>:
                      iftmp.330 = MEM[(const void * *)0B + 104B];
                      goto <D.111017>;
                      <D.111016>:
                      iftmp.330 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.111017>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.330;
                    }
                  catch
                    {
                      if (1 == 0) goto <D.111019>; else goto <D.111020>;
                      <D.111019>:
                      iftmp.331 = 56B;
                      goto <D.111021>;
                      <D.111020>:
                      iftmp.331 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.111021>:
                      D.110992 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.110992, iftmp.331);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.111023>; else goto <D.111024>;
                  <D.111023>:
                  iftmp.332 = 24B;
                  goto <D.111025>;
                  <D.111024>:
                  iftmp.332 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.111025>:
                  D.110987 = &this->D.101148;
                  Gio::Initable::~Initable (D.110987, iftmp.332);
                }
            }
          catch
            {
              if (1 == 0) goto <D.111027>; else goto <D.111028>;
              <D.111027>:
              iftmp.333 = 8B;
              goto <D.111029>;
              <D.111028>:
              iftmp.333 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.111029>:
              D.110982 = &this->D.101147;
              Glib::Object::~Object (D.110982, iftmp.333);
            }
        }
      catch
        {
          if (1 != 0) goto <D.111030>; else goto <D.111031>;
          <D.111030>:
          if (1 == 0) goto <D.111033>; else goto <D.111034>;
          <D.111033>:
          iftmp.334 = 112B;
          goto <D.111035>;
          <D.111034>:
          iftmp.334 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.111035>:
          D.110976 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.110976, iftmp.334);
          goto <D.111036>;
          <D.111031>:
          <D.111036>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.111037>; else goto <D.111038>;
      <D.111037>:
      D.110968 = &this->D.101154;
      sigc::trackable::~trackable (D.110968);
      goto <D.111039>;
      <D.111038>:
      <D.111039>:
    }
}


Gio::DBus::Proxy::Proxy(GDBusProxy*) (struct Proxy * const this, const void * * __vtt_parm, struct GDBusProxy * castitem)
{
  struct trackable * D.111046;
  const void * * iftmp.335;
  struct ObjectBase * D.111054;
  const void * * iftmp.336;
  struct Object * D.111060;
  const void * * iftmp.337;
  struct Initable * D.111065;
  const void * * iftmp.338;
  struct AsyncInitable * D.111070;
  int (*__vtbl_ptr_type) () * iftmp.339;
  sizetype iftmp.340;
  int (*__vtbl_ptr_type) () * D.111078;
  int (*__vtbl_ptr_type) () * D.111079;
  long int D.111080;
  struct ObjectBase * D.111082;
  int (*__vtbl_ptr_type) () * iftmp.341;
  int (*__vtbl_ptr_type) () * iftmp.342;
  int (*__vtbl_ptr_type) () * iftmp.343;
  const void * * iftmp.344;
  const void * * iftmp.345;
  const void * * iftmp.346;
  const void * * iftmp.347;

  if (0 != 0) goto <D.111044>; else goto <D.111045>;
  <D.111044>:
  D.111046 = &this->D.101154;
  sigc::trackable::trackable (D.111046);
  goto <D.111047>;
  <D.111045>:
  <D.111047>:
  try
    {
      if (0 != 0) goto <D.111048>; else goto <D.111049>;
      <D.111048>:
      if (0 == 0) goto <D.111051>; else goto <D.111052>;
      <D.111051>:
      iftmp.335 = __vtt_parm + 112;
      goto <D.111053>;
      <D.111052>:
      iftmp.335 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.111053>:
      D.111054 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.111054, iftmp.335);
      goto <D.111055>;
      <D.111049>:
      <D.111055>:
      try
        {
          if (0 == 0) goto <D.111057>; else goto <D.111058>;
          <D.111057>:
          iftmp.336 = __vtt_parm + 8;
          goto <D.111059>;
          <D.111058>:
          iftmp.336 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
          <D.111059>:
          D.111060 = &this->D.101147;
          Glib::Object::Object (D.111060, iftmp.336, castitem);
          try
            {
              if (0 == 0) goto <D.111062>; else goto <D.111063>;
              <D.111062>:
              iftmp.337 = __vtt_parm + 24;
              goto <D.111064>;
              <D.111063>:
              iftmp.337 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.111064>:
              D.111065 = &this->D.101148;
              Gio::Initable::Initable (D.111065, iftmp.337);
              try
                {
                  if (0 == 0) goto <D.111067>; else goto <D.111068>;
                  <D.111067>:
                  iftmp.338 = __vtt_parm + 56;
                  goto <D.111069>;
                  <D.111068>:
                  iftmp.338 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.111069>:
                  D.111070 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.111070, iftmp.338);
                  try
                    {
                      if (0 == 0) goto <D.111072>; else goto <D.111073>;
                      <D.111072>:
                      iftmp.339 = *__vtt_parm;
                      goto <D.111074>;
                      <D.111073>:
                      iftmp.339 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.111074>:
                      this->D.101147._vptr.Object = iftmp.339;
                      if (0 == 0) goto <D.111076>; else goto <D.111077>;
                      <D.111076>:
                      D.111078 = this->D.101147._vptr.Object;
                      D.111079 = D.111078 + 18446744073709551592;
                      D.111080 = MEM[(long int *)D.111079];
                      iftmp.340 = (sizetype) D.111080;
                      goto <D.111081>;
                      <D.111077>:
                      iftmp.340 = 24;
                      <D.111081>:
                      D.111082 = this + iftmp.340;
                      if (0 == 0) goto <D.111084>; else goto <D.111085>;
                      <D.111084>:
                      iftmp.341 = MEM[(const void * *)__vtt_parm + 88B];
                      goto <D.111086>;
                      <D.111085>:
                      iftmp.341 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.111086>:
                      D.111082->_vptr.ObjectBase = iftmp.341;
                      if (0 == 0) goto <D.111088>; else goto <D.111089>;
                      <D.111088>:
                      iftmp.342 = MEM[(const void * *)__vtt_parm + 96B];
                      goto <D.111090>;
                      <D.111089>:
                      iftmp.342 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.111090>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.342;
                      if (0 == 0) goto <D.111092>; else goto <D.111093>;
                      <D.111092>:
                      iftmp.343 = MEM[(const void * *)__vtt_parm + 104B];
                      goto <D.111094>;
                      <D.111093>:
                      iftmp.343 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.111094>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.343;
                    }
                  catch
                    {
                      if (0 == 0) goto <D.111096>; else goto <D.111097>;
                      <D.111096>:
                      iftmp.344 = __vtt_parm + 56;
                      goto <D.111098>;
                      <D.111097>:
                      iftmp.344 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.111098>:
                      D.111070 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.111070, iftmp.344);
                    }
                }
              catch
                {
                  if (0 == 0) goto <D.111100>; else goto <D.111101>;
                  <D.111100>:
                  iftmp.345 = __vtt_parm + 24;
                  goto <D.111102>;
                  <D.111101>:
                  iftmp.345 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.111102>:
                  D.111065 = &this->D.101148;
                  Gio::Initable::~Initable (D.111065, iftmp.345);
                }
            }
          catch
            {
              if (0 == 0) goto <D.111104>; else goto <D.111105>;
              <D.111104>:
              iftmp.346 = __vtt_parm + 8;
              goto <D.111106>;
              <D.111105>:
              iftmp.346 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.111106>:
              D.111060 = &this->D.101147;
              Glib::Object::~Object (D.111060, iftmp.346);
            }
        }
      catch
        {
          if (0 != 0) goto <D.111107>; else goto <D.111108>;
          <D.111107>:
          if (0 == 0) goto <D.111110>; else goto <D.111111>;
          <D.111110>:
          iftmp.347 = __vtt_parm + 112;
          goto <D.111112>;
          <D.111111>:
          iftmp.347 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.111112>:
          D.111054 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.111054, iftmp.347);
          goto <D.111113>;
          <D.111108>:
          <D.111113>:
        }
    }
  catch
    {
      if (0 != 0) goto <D.111114>; else goto <D.111115>;
      <D.111114>:
      D.111046 = &this->D.101154;
      sigc::trackable::~trackable (D.111046);
      goto <D.111116>;
      <D.111115>:
      <D.111116>:
    }
}


Gio::DBus::Proxy::Proxy(GDBusProxy*) (struct Proxy * const this, struct GDBusProxy * castitem)
{
  struct trackable * D.111123;
  const void * * iftmp.348;
  struct ObjectBase * D.111131;
  const void * * iftmp.349;
  struct Object * D.111137;
  const void * * iftmp.350;
  struct Initable * D.111142;
  const void * * iftmp.351;
  struct AsyncInitable * D.111147;
  int (*__vtbl_ptr_type) () * iftmp.352;
  const void * * D.111151;
  sizetype iftmp.353;
  int (*__vtbl_ptr_type) () * D.111156;
  int (*__vtbl_ptr_type) () * D.111157;
  long int D.111158;
  struct ObjectBase * D.111160;
  int (*__vtbl_ptr_type) () * iftmp.354;
  int (*__vtbl_ptr_type) () * iftmp.355;
  int (*__vtbl_ptr_type) () * iftmp.356;
  const void * * iftmp.357;
  const void * * iftmp.358;
  const void * * iftmp.359;
  const void * * iftmp.360;

  if (1 != 0) goto <D.111121>; else goto <D.111122>;
  <D.111121>:
  D.111123 = &this->D.101154;
  sigc::trackable::trackable (D.111123);
  goto <D.111124>;
  <D.111122>:
  <D.111124>:
  try
    {
      if (1 != 0) goto <D.111125>; else goto <D.111126>;
      <D.111125>:
      if (1 == 0) goto <D.111128>; else goto <D.111129>;
      <D.111128>:
      iftmp.348 = 112B;
      goto <D.111130>;
      <D.111129>:
      iftmp.348 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
      <D.111130>:
      D.111131 = &this->D.101153;
      Glib::ObjectBase::ObjectBase (D.111131, iftmp.348);
      goto <D.111132>;
      <D.111126>:
      <D.111132>:
      try
        {
          if (1 == 0) goto <D.111134>; else goto <D.111135>;
          <D.111134>:
          iftmp.349 = 8B;
          goto <D.111136>;
          <D.111135>:
          iftmp.349 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
          <D.111136>:
          D.111137 = &this->D.101147;
          Glib::Object::Object (D.111137, iftmp.349, castitem);
          try
            {
              if (1 == 0) goto <D.111139>; else goto <D.111140>;
              <D.111139>:
              iftmp.350 = 24B;
              goto <D.111141>;
              <D.111140>:
              iftmp.350 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
              <D.111141>:
              D.111142 = &this->D.101148;
              Gio::Initable::Initable (D.111142, iftmp.350);
              try
                {
                  if (1 == 0) goto <D.111144>; else goto <D.111145>;
                  <D.111144>:
                  iftmp.351 = 56B;
                  goto <D.111146>;
                  <D.111145>:
                  iftmp.351 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                  <D.111146>:
                  D.111147 = &this->D.101149;
                  Gio::AsyncInitable::AsyncInitable (D.111147, iftmp.351);
                  try
                    {
                      if (1 == 0) goto <D.111149>; else goto <D.111150>;
                      <D.111149>:
                      D.111151 = 0B;
                      iftmp.352 = *D.111151;
                      goto <D.111152>;
                      <D.111150>:
                      iftmp.352 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
                      <D.111152>:
                      this->D.101147._vptr.Object = iftmp.352;
                      if (1 == 0) goto <D.111154>; else goto <D.111155>;
                      <D.111154>:
                      D.111156 = this->D.101147._vptr.Object;
                      D.111157 = D.111156 + 18446744073709551592;
                      D.111158 = MEM[(long int *)D.111157];
                      iftmp.353 = (sizetype) D.111158;
                      goto <D.111159>;
                      <D.111155>:
                      iftmp.353 = 24;
                      <D.111159>:
                      D.111160 = this + iftmp.353;
                      if (1 == 0) goto <D.111162>; else goto <D.111163>;
                      <D.111162>:
                      iftmp.354 = MEM[(const void * *)0B + 88B];
                      goto <D.111164>;
                      <D.111163>:
                      iftmp.354 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
                      <D.111164>:
                      D.111160->_vptr.ObjectBase = iftmp.354;
                      if (1 == 0) goto <D.111166>; else goto <D.111167>;
                      <D.111166>:
                      iftmp.355 = MEM[(const void * *)0B + 96B];
                      goto <D.111168>;
                      <D.111167>:
                      iftmp.355 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
                      <D.111168>:
                      this->D.101148.D.97070._vptr.Interface = iftmp.355;
                      if (1 == 0) goto <D.111170>; else goto <D.111171>;
                      <D.111170>:
                      iftmp.356 = MEM[(const void * *)0B + 104B];
                      goto <D.111172>;
                      <D.111171>:
                      iftmp.356 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
                      <D.111172>:
                      this->D.101149.D.97206._vptr.Interface = iftmp.356;
                    }
                  catch
                    {
                      if (1 == 0) goto <D.111174>; else goto <D.111175>;
                      <D.111174>:
                      iftmp.357 = 56B;
                      goto <D.111176>;
                      <D.111175>:
                      iftmp.357 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                      <D.111176>:
                      D.111147 = &this->D.101149;
                      Gio::AsyncInitable::~AsyncInitable (D.111147, iftmp.357);
                    }
                }
              catch
                {
                  if (1 == 0) goto <D.111178>; else goto <D.111179>;
                  <D.111178>:
                  iftmp.358 = 24B;
                  goto <D.111180>;
                  <D.111179>:
                  iftmp.358 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                  <D.111180>:
                  D.111142 = &this->D.101148;
                  Gio::Initable::~Initable (D.111142, iftmp.358);
                }
            }
          catch
            {
              if (1 == 0) goto <D.111182>; else goto <D.111183>;
              <D.111182>:
              iftmp.359 = 8B;
              goto <D.111184>;
              <D.111183>:
              iftmp.359 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
              <D.111184>:
              D.111137 = &this->D.101147;
              Glib::Object::~Object (D.111137, iftmp.359);
            }
        }
      catch
        {
          if (1 != 0) goto <D.111185>; else goto <D.111186>;
          <D.111185>:
          if (1 == 0) goto <D.111188>; else goto <D.111189>;
          <D.111188>:
          iftmp.360 = 112B;
          goto <D.111190>;
          <D.111189>:
          iftmp.360 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
          <D.111190>:
          D.111131 = &this->D.101153;
          Glib::ObjectBase::~ObjectBase (D.111131, iftmp.360);
          goto <D.111191>;
          <D.111186>:
          <D.111191>:
        }
    }
  catch
    {
      if (1 != 0) goto <D.111192>; else goto <D.111193>;
      <D.111192>:
      D.111123 = &this->D.101154;
      sigc::trackable::~trackable (D.111123);
      goto <D.111194>;
      <D.111193>:
      <D.111194>:
    }
}


Gio::DBus::Proxy::~Proxy() (struct Proxy * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.361;
  sizetype iftmp.362;
  int (*__vtbl_ptr_type) () * D.111206;
  int (*__vtbl_ptr_type) () * D.111207;
  long int D.111208;
  struct ObjectBase * D.111210;
  int (*__vtbl_ptr_type) () * iftmp.363;
  int (*__vtbl_ptr_type) () * iftmp.364;
  int (*__vtbl_ptr_type) () * iftmp.365;
  const void * * iftmp.366;
  struct AsyncInitable * D.111227;
  const void * * iftmp.367;
  struct Initable * D.111232;
  const void * * iftmp.368;
  struct Object * D.111237;
  int D.111238;
  const void * * iftmp.369;
  struct ObjectBase * D.111245;
  struct trackable * D.111249;
  int D.111251;

  {
    if (0 == 0) goto <D.111200>; else goto <D.111201>;
    <D.111200>:
    iftmp.361 = *__vtt_parm;
    goto <D.111202>;
    <D.111201>:
    iftmp.361 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
    <D.111202>:
    this->D.101147._vptr.Object = iftmp.361;
    if (0 == 0) goto <D.111204>; else goto <D.111205>;
    <D.111204>:
    D.111206 = this->D.101147._vptr.Object;
    D.111207 = D.111206 + 18446744073709551592;
    D.111208 = MEM[(long int *)D.111207];
    iftmp.362 = (sizetype) D.111208;
    goto <D.111209>;
    <D.111205>:
    iftmp.362 = 24;
    <D.111209>:
    D.111210 = this + iftmp.362;
    if (0 == 0) goto <D.111212>; else goto <D.111213>;
    <D.111212>:
    iftmp.363 = MEM[(const void * *)__vtt_parm + 88B];
    goto <D.111214>;
    <D.111213>:
    iftmp.363 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
    <D.111214>:
    D.111210->_vptr.ObjectBase = iftmp.363;
    if (0 == 0) goto <D.111216>; else goto <D.111217>;
    <D.111216>:
    iftmp.364 = MEM[(const void * *)__vtt_parm + 96B];
    goto <D.111218>;
    <D.111217>:
    iftmp.364 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
    <D.111218>:
    this->D.101148.D.97070._vptr.Interface = iftmp.364;
    if (0 == 0) goto <D.111220>; else goto <D.111221>;
    <D.111220>:
    iftmp.365 = MEM[(const void * *)__vtt_parm + 104B];
    goto <D.111222>;
    <D.111221>:
    iftmp.365 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
    <D.111222>:
    this->D.101149.D.97206._vptr.Interface = iftmp.365;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {
                        try
                          {

                          }
                        finally
                          {
                            if (0 == 0) goto <D.111224>; else goto <D.111225>;
                            <D.111224>:
                            iftmp.366 = __vtt_parm + 56;
                            goto <D.111226>;
                            <D.111225>:
                            iftmp.366 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                            <D.111226>:
                            D.111227 = &this->D.101149;
                            Gio::AsyncInitable::~AsyncInitable (D.111227, iftmp.366);
                          }
                      }
                    finally
                      {
                        if (0 == 0) goto <D.111229>; else goto <D.111230>;
                        <D.111229>:
                        iftmp.367 = __vtt_parm + 24;
                        goto <D.111231>;
                        <D.111230>:
                        iftmp.367 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                        <D.111231>:
                        D.111232 = &this->D.101148;
                        Gio::Initable::~Initable (D.111232, iftmp.367);
                      }
                  }
                finally
                  {
                    if (0 == 0) goto <D.111234>; else goto <D.111235>;
                    <D.111234>:
                    iftmp.368 = __vtt_parm + 8;
                    goto <D.111236>;
                    <D.111235>:
                    iftmp.368 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
                    <D.111236>:
                    D.111237 = &this->D.101147;
                    Glib::Object::~Object (D.111237, iftmp.368);
                  }
              }
            finally
              {
                D.111238 = 0;
                if (D.111238 != 0) goto <D.111239>; else goto <D.111240>;
                <D.111239>:
                if (0 == 0) goto <D.111242>; else goto <D.111243>;
                <D.111242>:
                iftmp.369 = __vtt_parm + 112;
                goto <D.111244>;
                <D.111243>:
                iftmp.369 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
                <D.111244>:
                D.111245 = &this->D.101153;
                Glib::ObjectBase::~ObjectBase (D.111245, iftmp.369);
                goto <D.111246>;
                <D.111240>:
                <D.111246>:
              }
          }
        finally
          {
            D.111238 = 0;
            if (D.111238 != 0) goto <D.111247>; else goto <D.111248>;
            <D.111247>:
            D.111249 = &this->D.101154;
            sigc::trackable::~trackable (D.111249);
            goto <D.111250>;
            <D.111248>:
            <D.111250>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104601>:
  D.111251 = 0;
  if (D.111251 != 0) goto <D.111252>; else goto <D.111253>;
  <D.111252>:
  operator delete (this);
  goto <D.111254>;
  <D.111253>:
  <D.111254>:
}


virtual Gio::DBus::Proxy::~Proxy() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.370;
  const void * * D.111278;
  sizetype iftmp.371;
  int (*__vtbl_ptr_type) () * D.111283;
  int (*__vtbl_ptr_type) () * D.111284;
  long int D.111285;
  struct ObjectBase * D.111287;
  int (*__vtbl_ptr_type) () * iftmp.372;
  int (*__vtbl_ptr_type) () * iftmp.373;
  int (*__vtbl_ptr_type) () * iftmp.374;
  const void * * iftmp.375;
  struct AsyncInitable * D.111304;
  const void * * iftmp.376;
  struct Initable * D.111309;
  const void * * iftmp.377;
  struct Object * D.111314;
  int D.111315;
  const void * * iftmp.378;
  struct ObjectBase * D.111322;
  struct trackable * D.111326;
  int D.111328;

  {
    if (2 == 0) goto <D.111276>; else goto <D.111277>;
    <D.111276>:
    D.111278 = 0B;
    iftmp.370 = *D.111278;
    goto <D.111279>;
    <D.111277>:
    iftmp.370 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 32B];
    <D.111279>:
    this->D.101147._vptr.Object = iftmp.370;
    if (2 == 0) goto <D.111281>; else goto <D.111282>;
    <D.111281>:
    D.111283 = this->D.101147._vptr.Object;
    D.111284 = D.111283 + 18446744073709551592;
    D.111285 = MEM[(long int *)D.111284];
    iftmp.371 = (sizetype) D.111285;
    goto <D.111286>;
    <D.111282>:
    iftmp.371 = 24;
    <D.111286>:
    D.111287 = this + iftmp.371;
    if (2 == 0) goto <D.111289>; else goto <D.111290>;
    <D.111289>:
    iftmp.372 = MEM[(const void * *)0B + 88B];
    goto <D.111291>;
    <D.111290>:
    iftmp.372 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 248B];
    <D.111291>:
    D.111287->_vptr.ObjectBase = iftmp.372;
    if (2 == 0) goto <D.111293>; else goto <D.111294>;
    <D.111293>:
    iftmp.373 = MEM[(const void * *)0B + 96B];
    goto <D.111295>;
    <D.111294>:
    iftmp.373 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 96B];
    <D.111295>:
    this->D.101148.D.97070._vptr.Interface = iftmp.373;
    if (2 == 0) goto <D.111297>; else goto <D.111298>;
    <D.111297>:
    iftmp.374 = MEM[(const void * *)0B + 104B];
    goto <D.111299>;
    <D.111298>:
    iftmp.374 = &MEM[(void *)&_ZTVN3Gio4DBus5ProxyE + 152B];
    <D.111299>:
    this->D.101149.D.97206._vptr.Interface = iftmp.374;
    try
      {
        try
          {
            try
              {
                try
                  {
                    try
                      {
                        try
                          {

                          }
                        finally
                          {
                            if (2 == 0) goto <D.111301>; else goto <D.111302>;
                            <D.111301>:
                            iftmp.375 = 56B;
                            goto <D.111303>;
                            <D.111302>:
                            iftmp.375 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 56B];
                            <D.111303>:
                            D.111304 = &this->D.101149;
                            Gio::AsyncInitable::~AsyncInitable (D.111304, iftmp.375);
                          }
                      }
                    finally
                      {
                        if (2 == 0) goto <D.111306>; else goto <D.111307>;
                        <D.111306>:
                        iftmp.376 = 24B;
                        goto <D.111308>;
                        <D.111307>:
                        iftmp.376 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 24B];
                        <D.111308>:
                        D.111309 = &this->D.101148;
                        Gio::Initable::~Initable (D.111309, iftmp.376);
                      }
                  }
                finally
                  {
                    if (2 == 0) goto <D.111311>; else goto <D.111312>;
                    <D.111311>:
                    iftmp.377 = 8B;
                    goto <D.111313>;
                    <D.111312>:
                    iftmp.377 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 8B];
                    <D.111313>:
                    D.111314 = &this->D.101147;
                    Glib::Object::~Object (D.111314, iftmp.377);
                  }
              }
            finally
              {
                D.111315 = 2;
                if (D.111315 != 0) goto <D.111316>; else goto <D.111317>;
                <D.111316>:
                if (2 == 0) goto <D.111319>; else goto <D.111320>;
                <D.111319>:
                iftmp.378 = 112B;
                goto <D.111321>;
                <D.111320>:
                iftmp.378 = &MEM[(void *)&_ZTTN3Gio4DBus5ProxyE + 112B];
                <D.111321>:
                D.111322 = &this->D.101153;
                Glib::ObjectBase::~ObjectBase (D.111322, iftmp.378);
                goto <D.111323>;
                <D.111317>:
                <D.111323>:
              }
          }
        finally
          {
            D.111315 = 2;
            if (D.111315 != 0) goto <D.111324>; else goto <D.111325>;
            <D.111324>:
            D.111326 = &this->D.101154;
            sigc::trackable::~trackable (D.111326);
            goto <D.111327>;
            <D.111325>:
            <D.111327>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.104604>:
  D.111328 = 0;
  if (D.111328 != 0) goto <D.111329>; else goto <D.111330>;
  <D.111329>:
  operator delete (this);
  goto <D.111331>;
  <D.111330>:
  <D.111331>:
}


virtual Gio::DBus::Proxy::~Proxy() (struct Proxy * const this)
{
  Gio::DBus::Proxy::~Proxy (this);
  <D.104615>:
  operator delete (this);
}


static GType Gio::DBus::Proxy::get_type() ()
{
  GType D.111352;
  const struct Class & D.111353;

  D.111353 = Gio::DBus::Proxy_Class::init (&proxy_class_);
  D.111352 = Glib::Class::get_type (D.111353);
  return D.111352;
}


static GType Gio::DBus::Proxy::get_base_type() ()
{
  GType D.111356;

  D.111356 = g_dbus_proxy_get_type ();
  return D.111356;
}


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_finish(const Glib::RefPtr<Gio::AsyncResult>&) (const struct RefPtr & res)
{
  struct BaseObjectType * D.111360;
  struct GDBusProxy * D.111361;
  struct GError * gerror.379;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.111360 = Glib::unwrap<Gio::AsyncResult> (res);
      D.111361 = g_dbus_proxy_new_finish (D.111360, &gerror);
      *<retval> = Glib::wrap (D.111361, 0); [return slot optimization]
      try
        {
          gerror.379 = gerror;
          if (gerror.379 != 0B) goto <D.111363>; else goto <D.111364>;
          <D.111363>:
          gerror.379 = gerror;
          Glib::Error::throw_exception (gerror.379);
          <D.111364>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::DBus::Proxy>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


typename T::BaseObjectType* Glib::unwrap(const Glib::RefPtr<T_CppObject>&) [with T = Gio::AsyncResult; typename T::BaseObjectType = _GAsyncResult] (const struct RefPtr & ptr)
{
  struct BaseObjectType * D.111371;
  struct BaseObjectType * iftmp.380;
  bool D.111373;
  struct AsyncResult * D.111376;

  D.111373 = Glib::RefPtr<Gio::AsyncResult>::operator bool (ptr);
  if (D.111373 != 0) goto <D.111374>; else goto <D.111375>;
  <D.111374>:
  D.111376 = Glib::RefPtr<Gio::AsyncResult>::operator-> (ptr);
  iftmp.380 = Gio::AsyncResult::gobj (D.111376);
  goto <D.111377>;
  <D.111375>:
  iftmp.380 = 0B;
  <D.111377>:
  D.111371 = iftmp.380;
  return D.111371;
}


Glib::RefPtr<T_CppObject>::operator bool() const [with T_CppObject = Gio::AsyncResult] (const struct RefPtr * const this)
{
  bool D.111379;
  struct AsyncResult * D.111380;

  D.111380 = this->pCppObject_;
  D.111379 = D.111380 != 0B;
  return D.111379;
}


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

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


GAsyncResult* Gio::AsyncResult::gobj() (struct AsyncResult * const this)
{
  struct GAsyncResult * D.111384;
  int (*__vtbl_ptr_type) () * D.111385;
  int (*__vtbl_ptr_type) () * D.111386;
  long int D.111387;
  sizetype D.111388;
  struct ObjectBase * D.111389;

  D.111385 = this->D.86030._vptr.Interface;
  D.111386 = D.111385 + 18446744073709551592;
  D.111387 = MEM[(long int *)D.111386];
  D.111388 = (sizetype) D.111387;
  D.111389 = this + D.111388;
  D.111384 = D.111389->gobject_;
  return D.111384;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::DBus::Proxy] (struct RefPtr * const this)
{
  struct Proxy * D.111391;
  int (*__vtbl_ptr_type) () * D.111394;
  int (*__vtbl_ptr_type) () * D.111395;
  long int D.111396;
  sizetype D.111397;
  struct ObjectBase * D.111398;
  int (*__vtbl_ptr_type) () * D.111399;
  int (*__vtbl_ptr_type) () * D.111400;
  int (*__vtbl_ptr_type) () D.111401;

  {
    try
      {
        D.111391 = this->pCppObject_;
        if (D.111391 != 0B) goto <D.111392>; else goto <D.111393>;
        <D.111392>:
        D.111391 = this->pCppObject_;
        D.111391 = this->pCppObject_;
        D.111394 = D.111391->D.101147._vptr.Object;
        D.111395 = D.111394 + 18446744073709551592;
        D.111396 = MEM[(long int *)D.111395];
        D.111397 = (sizetype) D.111396;
        D.111398 = D.111391 + D.111397;
        D.111391 = this->pCppObject_;
        D.111391 = this->pCppObject_;
        D.111394 = D.111391->D.101147._vptr.Object;
        D.111395 = D.111394 + 18446744073709551592;
        D.111396 = MEM[(long int *)D.111395];
        D.111397 = (sizetype) D.111396;
        D.111398 = D.111391 + D.111397;
        D.111399 = D.111398->_vptr.ObjectBase;
        D.111400 = D.111399 + 24;
        D.111401 = *D.111400;
        D.111391 = this->pCppObject_;
        D.111391 = this->pCppObject_;
        D.111394 = D.111391->D.101147._vptr.Object;
        D.111395 = D.111394 + 18446744073709551592;
        D.111396 = MEM[(long int *)D.111395];
        D.111397 = (sizetype) D.111396;
        D.111398 = D.111391 + D.111397;
        OBJ_TYPE_REF(D.111401;(const struct ObjectBase)D.111398->3) (D.111398);
        goto <D.111402>;
        <D.111393>:
        <D.111402>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106041>:
}


static Glib::RefPtr<Gio::DBus::Proxy> Gio::DBus::Proxy::create_for_bus_finish(const Glib::RefPtr<Gio::AsyncResult>&) (const struct RefPtr & res)
{
  struct BaseObjectType * D.111405;
  struct GDBusProxy * D.111406;
  struct GError * gerror.381;
  struct GError * gerror;
  struct RefPtr retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.111405 = Glib::unwrap<Gio::AsyncResult> (res);
      D.111406 = g_dbus_proxy_new_for_bus_finish (D.111405, &gerror);
      *<retval> = Glib::wrap (D.111406, 0); [return slot optimization]
      try
        {
          gerror.381 = gerror;
          if (gerror.381 != 0B) goto <D.111408>; else goto <D.111409>;
          <D.111408>:
          gerror.381 = gerror;
          Glib::Error::throw_exception (gerror.381);
          <D.111409>:
          return <retval>;
        }
      catch
        {
          Glib::RefPtr<Gio::DBus::Proxy>::~RefPtr (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Gio::DBus::ProxyFlags Gio::DBus::Proxy::get_flags() const (const struct Proxy * const this)
{
  ProxyFlags D.111416;
  const struct GDBusProxy * D.111417;

  D.111417 = Gio::DBus::Proxy::gobj (this);
  D.111416 = g_dbus_proxy_get_flags (D.111417);
  return D.111416;
}


Glib::RefPtr<Gio::DBus::Connection> Gio::DBus::Proxy::get_connection() (struct Proxy * const this)
{
  struct GDBusProxy * D.111421;
  struct GDBusConnection * D.111422;

  D.111421 = Gio::DBus::Proxy::gobj (this);
  D.111422 = g_dbus_proxy_get_connection (D.111421);
  *<retval> = Glib::wrap (D.111422, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::DBus::Connection> Gio::DBus::Proxy::get_connection() const (const struct Proxy * const this)
{
  struct RefPtr D.104793;
  const struct GDBusProxy * D.111426;
  struct GDBusConnection * D.111427;

  D.111426 = Gio::DBus::Proxy::gobj (this);
  D.111427 = g_dbus_proxy_get_connection (D.111426);
  D.104793 = Glib::wrap (D.111427, 0); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::Connection>::RefPtr<Gio::DBus::Connection> (<retval>, &D.104793);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::Connection>::~RefPtr (&D.104793);
      D.104793 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::DBus::Connection; T_CppObject = const Gio::DBus::Connection] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct Connection * D.111432;
  const struct Connection * D.111433;
  int (*__vtbl_ptr_type) () * D.111436;
  int (*__vtbl_ptr_type) () * D.111437;
  long int D.111438;
  sizetype D.111439;
  const struct ObjectBase * D.111440;
  int (*__vtbl_ptr_type) () * D.111441;
  int (*__vtbl_ptr_type) () * D.111442;
  int (*__vtbl_ptr_type) () D.111443;

  D.111432 = Glib::RefPtr<Gio::DBus::Connection>::operator-> (src);
  this->pCppObject_ = D.111432;
  D.111433 = this->pCppObject_;
  if (D.111433 != 0B) goto <D.111434>; else goto <D.111435>;
  <D.111434>:
  D.111433 = this->pCppObject_;
  D.111433 = this->pCppObject_;
  D.111436 = D.111433->D.100492._vptr.Object;
  D.111437 = D.111436 + 18446744073709551592;
  D.111438 = MEM[(long int *)D.111437];
  D.111439 = (sizetype) D.111438;
  D.111440 = D.111433 + D.111439;
  D.111433 = this->pCppObject_;
  D.111433 = this->pCppObject_;
  D.111436 = D.111433->D.100492._vptr.Object;
  D.111437 = D.111436 + 18446744073709551592;
  D.111438 = MEM[(long int *)D.111437];
  D.111439 = (sizetype) D.111438;
  D.111440 = D.111433 + D.111439;
  D.111441 = D.111440->_vptr.ObjectBase;
  D.111442 = D.111441 + 16;
  D.111443 = *D.111442;
  D.111433 = this->pCppObject_;
  D.111433 = this->pCppObject_;
  D.111436 = D.111433->D.100492._vptr.Object;
  D.111437 = D.111436 + 18446744073709551592;
  D.111438 = MEM[(long int *)D.111437];
  D.111439 = (sizetype) D.111438;
  D.111440 = D.111433 + D.111439;
  OBJ_TYPE_REF(D.111443;(const struct ObjectBase)D.111440->2) (D.111440);
  goto <D.111444>;
  <D.111435>:
  <D.111444>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::DBus::Connection] (struct RefPtr * const this)
{
  struct Connection * D.111445;
  int (*__vtbl_ptr_type) () * D.111448;
  int (*__vtbl_ptr_type) () * D.111449;
  long int D.111450;
  sizetype D.111451;
  struct ObjectBase * D.111452;
  int (*__vtbl_ptr_type) () * D.111453;
  int (*__vtbl_ptr_type) () * D.111454;
  int (*__vtbl_ptr_type) () D.111455;

  {
    try
      {
        D.111445 = this->pCppObject_;
        if (D.111445 != 0B) goto <D.111446>; else goto <D.111447>;
        <D.111446>:
        D.111445 = this->pCppObject_;
        D.111445 = this->pCppObject_;
        D.111448 = D.111445->D.100492._vptr.Object;
        D.111449 = D.111448 + 18446744073709551592;
        D.111450 = MEM[(long int *)D.111449];
        D.111451 = (sizetype) D.111450;
        D.111452 = D.111445 + D.111451;
        D.111445 = this->pCppObject_;
        D.111445 = this->pCppObject_;
        D.111448 = D.111445->D.100492._vptr.Object;
        D.111449 = D.111448 + 18446744073709551592;
        D.111450 = MEM[(long int *)D.111449];
        D.111451 = (sizetype) D.111450;
        D.111452 = D.111445 + D.111451;
        D.111453 = D.111452->_vptr.ObjectBase;
        D.111454 = D.111453 + 24;
        D.111455 = *D.111454;
        D.111445 = this->pCppObject_;
        D.111445 = this->pCppObject_;
        D.111448 = D.111445->D.100492._vptr.Object;
        D.111449 = D.111448 + 18446744073709551592;
        D.111450 = MEM[(long int *)D.111449];
        D.111451 = (sizetype) D.111450;
        D.111452 = D.111445 + D.111451;
        OBJ_TYPE_REF(D.111455;(const struct ObjectBase)D.111452->3) (D.111452);
        goto <D.111456>;
        <D.111447>:
        <D.111456>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106468>:
}


Glib::ustring Gio::DBus::Proxy::get_name() const (const struct Proxy * const this)
{
  const struct GDBusProxy * D.111459;
  const gchar * D.111460;

  D.111459 = Gio::DBus::Proxy::gobj (this);
  D.111460 = g_dbus_proxy_get_name (D.111459);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.111460); [return slot optimization]
  return <retval>;
}


Glib::ustring Gio::DBus::Proxy::get_name_owner() const (const struct Proxy * const this)
{
  const struct GDBusProxy * D.111464;
  gchar * D.111465;

  D.111464 = Gio::DBus::Proxy::gobj (this);
  D.111465 = g_dbus_proxy_get_name_owner (D.111464);
  *<retval> = Glib::convert_return_gchar_ptr_to_ustring (D.111465); [return slot optimization]
  return <retval>;
}


Glib::ustring Glib::convert_return_gchar_ptr_to_ustring(char*) (char * str)
{
  struct ScopedPtr D.78974;
  bool cleanup.382;
  char * D.111474;
  struct ustring * D.111475;

  cleanup.382 = 0;
  try
    {
      if (str != 0B) goto <D.111469>; else goto <D.111470>;
      <D.111469>:
      Glib::ScopedPtr<char>::ScopedPtr (&D.78974, str);
      cleanup.382 = 1;
      D.111474 = Glib::ScopedPtr<char>::get (&D.78974);
      D.111475 = <retval>;
      Glib::ustring::ustring (D.111475, D.111474);
      goto <D.111476>;
      <D.111470>:
      D.111475 = <retval>;
      Glib::ustring::ustring (D.111475);
      <D.111476>:
      return <retval>;
    }
  finally
    {
      if (cleanup.382 != 0) goto <D.111472>; else goto <D.111473>;
      <D.111472>:
      Glib::ScopedPtr<char>::~ScopedPtr (&D.78974);
      D.78974 = {CLOBBER};
      <D.111473>:
    }
}


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

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


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

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


Glib::ustring Gio::DBus::Proxy::get_object_path() const (const struct Proxy * const this)
{
  const struct GDBusProxy * D.111487;
  const gchar * D.111488;

  D.111487 = Gio::DBus::Proxy::gobj (this);
  D.111488 = g_dbus_proxy_get_object_path (D.111487);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.111488); [return slot optimization]
  return <retval>;
}


Glib::ustring Gio::DBus::Proxy::get_interface_name() const (const struct Proxy * const this)
{
  const struct GDBusProxy * D.111492;
  const gchar * D.111493;

  D.111492 = Gio::DBus::Proxy::gobj (this);
  D.111493 = g_dbus_proxy_get_interface_name (D.111492);
  *<retval> = Glib::convert_const_gchar_ptr_to_ustring (D.111493); [return slot optimization]
  return <retval>;
}


int Gio::DBus::Proxy::get_default_timeout() const (const struct Proxy * const this)
{
  int D.111496;
  const struct GDBusProxy * D.111497;

  D.111497 = Gio::DBus::Proxy::gobj (this);
  D.111496 = g_dbus_proxy_get_default_timeout (D.111497);
  return D.111496;
}


void Gio::DBus::Proxy::set_default_timeout(int) (struct Proxy * const this, int timeout_msec)
{
  struct GDBusProxy * D.111500;

  D.111500 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_set_default_timeout (D.111500, timeout_msec);
}


void Gio::DBus::Proxy::set_cached_property(const Glib::ustring&, const Glib::VariantBase&) (struct Proxy * const this, const struct ustring & property_name, const struct VariantBase & value)
{
  const struct GVariant * D.111501;
  const char * D.111502;
  struct GDBusProxy * D.111503;

  D.111501 = Glib::VariantBase::gobj (value);
  D.111502 = Glib::ustring::c_str (property_name);
  D.111503 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_set_cached_property (D.111503, D.111502, D.111501);
}


Glib::StringArrayHandle Gio::DBus::Proxy::get_cached_property_names() const (const struct Proxy * const this)
{
  char * * const D.104991;
  const struct GDBusProxy * D.111506;
  gchar * * D.111507;

  D.111506 = Gio::DBus::Proxy::gobj (this);
  D.111507 = g_dbus_proxy_get_cached_property_names (D.111506);
  D.104991 = D.111507;
  try
    {
      Glib::ArrayHandle<Glib::ustring>::ArrayHandle<char**> (<retval>, &D.104991);
      return <retval>;
    }
  finally
    {
      D.104991 = {CLOBBER};
    }
}


Glib::ArrayHandle<T, Tr>::ArrayHandle(const Cont&) [with Cont = char**; T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>] (struct ArrayHandle * const this, char * * const & container)
{
  char * * D.111512;
  long unsigned int D.111513;
  long unsigned int D.111514;
  const char * const * D.111515;

  D.111512 = *container;
  D.111513 = Glib::Container_Helpers::ArraySourceTraits<Glib::Container_Helpers::TypeTraits<Glib::ustring>, char**>::get_size (D.111512);
  this->size_ = D.111513;
  D.111514 = this->size_;
  D.111512 = *container;
  D.111515 = Glib::Container_Helpers::ArraySourceTraits<Glib::Container_Helpers::TypeTraits<Glib::ustring>, char**>::get_data (D.111512, D.111514);
  this->parray_ = D.111515;
  this->ownership_ = 0;
}


static std::size_t Glib::Container_Helpers::ArraySourceTraits<Tr, Cont*>::get_size(const CType*) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Cont = char*; std::size_t = long unsigned int; Glib::Container_Helpers::ArraySourceTraits<Tr, Cont*>::CType = const char*] (const char * const * array)
{
  size_t D.111517;
  long unsigned int iftmp.383;

  if (array != 0B) goto <D.111519>; else goto <D.111520>;
  <D.111519>:
  iftmp.383 = Glib::Container_Helpers::compute_array_size<const char*> (array);
  goto <D.111521>;
  <D.111520>:
  iftmp.383 = 0;
  <D.111521>:
  D.111517 = iftmp.383;
  return D.111517;
}


std::size_t Glib::Container_Helpers::compute_array_size(const T*) [with T = const char*; std::size_t = long unsigned int] (const char * const * array)
{
  const char * D.111523;
  size_t D.111524;
  long int pend.384;
  long int array.385;
  long int D.111527;
  long int D.111528;
  const char * const * pend;

  pend = array;
  goto <D.107831>;
  <D.107832>:
  pend = pend + 8;
  <D.107831>:
  D.111523 = *pend;
  if (D.111523 != 0B) goto <D.107832>; else goto <D.107830>;
  <D.107830>:
  pend.384 = (long int) pend;
  array.385 = (long int) array;
  D.111527 = pend.384 - array.385;
  D.111528 = D.111527 /[ex] 8;
  D.111524 = (size_t) D.111528;
  return D.111524;
}


static const CType* Glib::Container_Helpers::ArraySourceTraits<Tr, Cont*>::get_data(const CType*, std::size_t) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Cont = char*; Glib::Container_Helpers::ArraySourceTraits<Tr, Cont*>::CType = const char*; std::size_t = long unsigned int] (const char * const * array, size_t D.106502)
{
  const char * const * D.111530;

  D.111530 = array;
  return D.111530;
}


void Gio::DBus::Proxy::set_interface_info(const Glib::RefPtr<Gio::DBus::InterfaceInfo>&) (struct Proxy * const this, const struct RefPtr & info)
{
  struct BaseObjectType * D.111532;
  struct GDBusProxy * D.111533;

  D.111532 = Glib::unwrap<Gio::DBus::InterfaceInfo> (info);
  D.111533 = Gio::DBus::Proxy::gobj (this);
  g_dbus_proxy_set_interface_info (D.111533, D.111532);
}


Glib::RefPtr<Gio::DBus::InterfaceInfo> Gio::DBus::Proxy::get_interface_info() (struct Proxy * const this)
{
  struct GDBusProxy * D.111536;
  struct GDBusInterfaceInfo * D.111537;

  D.111536 = Gio::DBus::Proxy::gobj (this);
  D.111537 = g_dbus_proxy_get_interface_info (D.111536);
  *<retval> = Glib::wrap (D.111537, 0); [return slot optimization]
  return <retval>;
}


Glib::RefPtr<const Gio::DBus::InterfaceInfo> Gio::DBus::Proxy::get_interface_info() const (const struct Proxy * const this)
{
  struct RefPtr D.105146;

  D.105146 = Gio::DBus::Proxy::get_interface_info (this); [return slot optimization]
  try
    {
      Glib::RefPtr<const Gio::DBus::InterfaceInfo>::RefPtr<Gio::DBus::InterfaceInfo> (<retval>, &D.105146);
      return <retval>;
    }
  finally
    {
      Glib::RefPtr<Gio::DBus::InterfaceInfo>::~RefPtr (&D.105146);
      D.105146 = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CastFrom>&) [with T_CastFrom = Gio::DBus::InterfaceInfo; T_CppObject = const Gio::DBus::InterfaceInfo] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct InterfaceInfo * D.111544;
  const struct InterfaceInfo * D.111545;

  D.111544 = Glib::RefPtr<Gio::DBus::InterfaceInfo>::operator-> (src);
  this->pCppObject_ = D.111544;
  D.111545 = this->pCppObject_;
  if (D.111545 != 0B) goto <D.111546>; else goto <D.111547>;
  <D.111546>:
  D.111545 = this->pCppObject_;
  Gio::DBus::InterfaceInfo::reference (D.111545);
  goto <D.111548>;
  <D.111547>:
  <D.111548>:
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::DBus::InterfaceInfo] (struct RefPtr * const this)
{
  struct InterfaceInfo * D.111549;

  {
    try
      {
        D.111549 = this->pCppObject_;
        if (D.111549 != 0B) goto <D.111550>; else goto <D.111551>;
        <D.111550>:
        D.111549 = this->pCppObject_;
        Gio::DBus::InterfaceInfo::unreference (D.111549);
        goto <D.111552>;
        <D.111551>:
        <D.111552>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106029>:
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_finish(const Glib::RefPtr<Gio::AsyncResult>&) (struct Proxy * const this, const struct RefPtr & res)
{
  struct BaseObjectType * D.111555;
  struct GDBusProxy * D.111556;
  struct GVariant * D.111557;
  struct GError * gerror.386;
  struct GError * gerror;
  struct VariantContainerBase retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      D.111555 = Glib::unwrap<Gio::AsyncResult> (res);
      D.111556 = Gio::DBus::Proxy::gobj (this);
      D.111557 = g_dbus_proxy_call_finish (D.111556, D.111555, &gerror);
      Glib::VariantContainerBase::VariantContainerBase (<retval>, D.111557, 0);
      try
        {
          gerror.386 = gerror;
          if (gerror.386 != 0B) goto <D.111559>; else goto <D.111560>;
          <D.111559>:
          gerror.386 = gerror;
          Glib::Error::throw_exception (gerror.386);
          <D.111560>:
          return <retval>;
        }
      catch
        {
          Glib::VariantContainerBase::~VariantContainerBase (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
    }
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_finish(const Glib::RefPtr<Gio::AsyncResult>&, Glib::RefPtr<Gio::UnixFDList>&) (struct Proxy * const this, const struct RefPtr & res, struct RefPtr & out_fd_list)
{
  struct BaseObjectType * D.111568;
  struct GDBusProxy * D.111569;
  struct GVariant * D.111570;
  struct GError * gerror.387;
  struct RefPtr D.105183;
  struct GUnixFDList * g_out_fd_list.388;
  struct GError * gerror;
  struct GUnixFDList * g_out_fd_list;
  struct VariantContainerBase retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      g_out_fd_list = 0B;
      D.111568 = Glib::unwrap<Gio::AsyncResult> (res);
      D.111569 = Gio::DBus::Proxy::gobj (this);
      D.111570 = g_dbus_proxy_call_with_unix_fd_list_finish (D.111569, &g_out_fd_list, D.111568, &gerror);
      Glib::VariantContainerBase::VariantContainerBase (<retval>, D.111570, 0);
      try
        {
          gerror.387 = gerror;
          if (gerror.387 != 0B) goto <D.111572>; else goto <D.111573>;
          <D.111572>:
          gerror.387 = gerror;
          Glib::Error::throw_exception (gerror.387);
          <D.111573>:
          g_out_fd_list.388 = g_out_fd_list;
          D.105183 = Glib::wrap (g_out_fd_list.388, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::UnixFDList>::operator= (out_fd_list, &D.105183);
            }
          finally
            {
              Glib::RefPtr<Gio::UnixFDList>::~RefPtr (&D.105183);
              D.105183 = {CLOBBER};
            }
          return <retval>;
        }
      catch
        {
          Glib::VariantContainerBase::~VariantContainerBase (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
      g_out_fd_list = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>& Glib::RefPtr<T_CppObject>::operator=(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::UnixFDList] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct RefPtr & D.111582;
  struct RefPtr temp;

  try
    {
      Glib::RefPtr<Gio::UnixFDList>::RefPtr (&temp, src);
      try
        {
          Glib::RefPtr<Gio::UnixFDList>::swap (this, &temp);
          D.111582 = this;
          return D.111582;
        }
      finally
        {
          Glib::RefPtr<Gio::UnixFDList>::~RefPtr (&temp);
        }
    }
  finally
    {
      temp = {CLOBBER};
    }
}


Glib::RefPtr<T_CppObject>::RefPtr(const Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::UnixFDList] (struct RefPtr * const this, const struct RefPtr & src)
{
  struct UnixFDList * D.111587;
  struct UnixFDList * D.111588;
  int (*__vtbl_ptr_type) () * D.111591;
  int (*__vtbl_ptr_type) () * D.111592;
  long int D.111593;
  sizetype D.111594;
  struct ObjectBase * D.111595;
  int (*__vtbl_ptr_type) () * D.111596;
  int (*__vtbl_ptr_type) () * D.111597;
  int (*__vtbl_ptr_type) () D.111598;

  D.111587 = src->pCppObject_;
  this->pCppObject_ = D.111587;
  D.111588 = this->pCppObject_;
  if (D.111588 != 0B) goto <D.111589>; else goto <D.111590>;
  <D.111589>:
  D.111588 = this->pCppObject_;
  D.111588 = this->pCppObject_;
  D.111591 = D.111588->D.98265._vptr.Object;
  D.111592 = D.111591 + 18446744073709551592;
  D.111593 = MEM[(long int *)D.111592];
  D.111594 = (sizetype) D.111593;
  D.111595 = D.111588 + D.111594;
  D.111588 = this->pCppObject_;
  D.111588 = this->pCppObject_;
  D.111591 = D.111588->D.98265._vptr.Object;
  D.111592 = D.111591 + 18446744073709551592;
  D.111593 = MEM[(long int *)D.111592];
  D.111594 = (sizetype) D.111593;
  D.111595 = D.111588 + D.111594;
  D.111596 = D.111595->_vptr.ObjectBase;
  D.111597 = D.111596 + 16;
  D.111598 = *D.111597;
  D.111588 = this->pCppObject_;
  D.111588 = this->pCppObject_;
  D.111591 = D.111588->D.98265._vptr.Object;
  D.111592 = D.111591 + 18446744073709551592;
  D.111593 = MEM[(long int *)D.111592];
  D.111594 = (sizetype) D.111593;
  D.111595 = D.111588 + D.111594;
  OBJ_TYPE_REF(D.111598;(const struct ObjectBase)D.111595->2) (D.111595);
  goto <D.111599>;
  <D.111590>:
  <D.111599>:
}


void Glib::RefPtr<T_CppObject>::swap(Glib::RefPtr<T_CppObject>&) [with T_CppObject = Gio::UnixFDList] (struct RefPtr * const this, struct RefPtr & other)
{
  struct UnixFDList * D.111600;
  struct UnixFDList * const temp;

  temp = this->pCppObject_;
  D.111600 = other->pCppObject_;
  this->pCppObject_ = D.111600;
  other->pCppObject_ = temp;
}


Glib::RefPtr<T_CppObject>::~RefPtr() [with T_CppObject = Gio::UnixFDList] (struct RefPtr * const this)
{
  struct UnixFDList * D.111601;
  int (*__vtbl_ptr_type) () * D.111604;
  int (*__vtbl_ptr_type) () * D.111605;
  long int D.111606;
  sizetype D.111607;
  struct ObjectBase * D.111608;
  int (*__vtbl_ptr_type) () * D.111609;
  int (*__vtbl_ptr_type) () * D.111610;
  int (*__vtbl_ptr_type) () D.111611;

  {
    try
      {
        D.111601 = this->pCppObject_;
        if (D.111601 != 0B) goto <D.111602>; else goto <D.111603>;
        <D.111602>:
        D.111601 = this->pCppObject_;
        D.111601 = this->pCppObject_;
        D.111604 = D.111601->D.98265._vptr.Object;
        D.111605 = D.111604 + 18446744073709551592;
        D.111606 = MEM[(long int *)D.111605];
        D.111607 = (sizetype) D.111606;
        D.111608 = D.111601 + D.111607;
        D.111601 = this->pCppObject_;
        D.111601 = this->pCppObject_;
        D.111604 = D.111601->D.98265._vptr.Object;
        D.111605 = D.111604 + 18446744073709551592;
        D.111606 = MEM[(long int *)D.111605];
        D.111607 = (sizetype) D.111606;
        D.111608 = D.111601 + D.111607;
        D.111609 = D.111608->_vptr.ObjectBase;
        D.111610 = D.111609 + 24;
        D.111611 = *D.111610;
        D.111601 = this->pCppObject_;
        D.111601 = this->pCppObject_;
        D.111604 = D.111601->D.98265._vptr.Object;
        D.111605 = D.111604 + 18446744073709551592;
        D.111606 = MEM[(long int *)D.111605];
        D.111607 = (sizetype) D.111606;
        D.111608 = D.111601 + D.111607;
        OBJ_TYPE_REF(D.111611;(const struct ObjectBase)D.111608->3) (D.111608);
        goto <D.111612>;
        <D.111603>:
        <D.111612>:
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.106560>:
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_sync(const Glib::ustring&, const Glib::VariantContainerBase&, const Glib::RefPtr<Gio::Cancellable>&, const Glib::RefPtr<Gio::UnixFDList>&, Glib::RefPtr<Gio::UnixFDList>&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct VariantContainerBase & parameters, const struct RefPtr & cancellable, const struct RefPtr & fd_list, struct RefPtr & out_fd_list, int timeout_msec, CallFlags flags)
{
  struct BaseObjectType * D.111615;
  struct BaseObjectType * D.111616;
  const struct VariantBase * D.111617;
  const struct GVariant * D.111618;
  const char * D.111619;
  struct GDBusProxy * D.111620;
  struct GVariant * D.111621;
  struct GError * gerror.389;
  struct RefPtr D.105202;
  struct GUnixFDList * g_out_fd_list.390;
  struct GError * gerror;
  struct GUnixFDList * g_out_fd_list;
  struct VariantContainerBase retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      g_out_fd_list = 0B;
      D.111615 = Glib::unwrap<Gio::Cancellable> (cancellable);
      D.111616 = Glib::unwrap<Gio::UnixFDList> (fd_list);
      D.111617 = &parameters->D.66789;
      D.111618 = Glib::VariantBase::gobj (D.111617);
      D.111619 = Glib::ustring::c_str (method_name);
      D.111620 = Gio::DBus::Proxy::gobj (this);
      D.111621 = g_dbus_proxy_call_with_unix_fd_list_sync (D.111620, D.111619, D.111618, flags, timeout_msec, D.111616, &g_out_fd_list, D.111615, &gerror);
      Glib::VariantContainerBase::VariantContainerBase (<retval>, D.111621, 0);
      try
        {
          gerror.389 = gerror;
          if (gerror.389 != 0B) goto <D.111623>; else goto <D.111624>;
          <D.111623>:
          gerror.389 = gerror;
          Glib::Error::throw_exception (gerror.389);
          <D.111624>:
          g_out_fd_list.390 = g_out_fd_list;
          D.105202 = Glib::wrap (g_out_fd_list.390, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::UnixFDList>::operator= (out_fd_list, &D.105202);
            }
          finally
            {
              Glib::RefPtr<Gio::UnixFDList>::~RefPtr (&D.105202);
              D.105202 = {CLOBBER};
            }
          return <retval>;
        }
      catch
        {
          Glib::VariantContainerBase::~VariantContainerBase (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
      g_out_fd_list = {CLOBBER};
    }
}


Glib::VariantContainerBase Gio::DBus::Proxy::call_sync(const Glib::ustring&, const Glib::VariantContainerBase&, const Glib::RefPtr<Gio::UnixFDList>&, Glib::RefPtr<Gio::UnixFDList>&, int, Gio::DBus::CallFlags) (struct Proxy * const this, const struct ustring & method_name, const struct VariantContainerBase & parameters, const struct RefPtr & fd_list, struct RefPtr & out_fd_list, int timeout_msec, CallFlags flags)
{
  struct BaseObjectType * D.111636;
  const struct VariantBase * D.111637;
  const struct GVariant * D.111638;
  const char * D.111639;
  struct GDBusProxy * D.111640;
  struct GVariant * D.111641;
  struct GError * gerror.391;
  struct RefPtr D.105217;
  struct GUnixFDList * g_out_fd_list.392;
  struct GError * gerror;
  struct GUnixFDList * g_out_fd_list;
  struct VariantContainerBase retvalue [value-expr: *<retval>];

  try
    {
      gerror = 0B;
      g_out_fd_list = 0B;
      D.111636 = Glib::unwrap<Gio::UnixFDList> (fd_list);
      D.111637 = &parameters->D.66789;
      D.111638 = Glib::VariantBase::gobj (D.111637);
      D.111639 = Glib::ustring::c_str (method_name);
      D.111640 = Gio::DBus::Proxy::gobj (this);
      D.111641 = g_dbus_proxy_call_with_unix_fd_list_sync (D.111640, D.111639, D.111638, flags, timeout_msec, D.111636, &g_out_fd_list, 0B, &gerror);
      Glib::VariantContainerBase::VariantContainerBase (<retval>, D.111641, 0);
      try
        {
          gerror.391 = gerror;
          if (gerror.391 != 0B) goto <D.111643>; else goto <D.111644>;
          <D.111643>:
          gerror.391 = gerror;
          Glib::Error::throw_exception (gerror.391);
          <D.111644>:
          g_out_fd_list.392 = g_out_fd_list;
          D.105217 = Glib::wrap (g_out_fd_list.392, 0); [return slot optimization]
          try
            {
              Glib::RefPtr<Gio::UnixFDList>::operator= (out_fd_list, &D.105217);
            }
          finally
            {
              Glib::RefPtr<Gio::UnixFDList>::~RefPtr (&D.105217);
              D.105217 = {CLOBBER};
            }
          return <retval>;
        }
      catch
        {
          Glib::VariantContainerBase::~VariantContainerBase (<retval>);
        }
    }
  finally
    {
      gerror = {CLOBBER};
      g_out_fd_list = {CLOBBER};
    }
}


Glib::SignalProxy2<void, const std::map<Glib::ustring, Glib::VariantBase>&, const std::vector<Glib::ustring>&> Gio::DBus::Proxy::signal_properties_changed() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111655;
  int (*__vtbl_ptr_type) () * D.111656;
  long int D.111657;
  sizetype D.111658;
  struct ObjectBase * D.111659;

  D.111655 = this->D.101147._vptr.Object;
  D.111656 = D.111655 + 18446744073709551592;
  D.111657 = MEM[(long int *)D.111656];
  D.111658 = (sizetype) D.111657;
  D.111659 = this + D.111658;
  Glib::SignalProxy2<void, const std::map<Glib::ustring, Glib::VariantBase>&, const std::vector<Glib::ustring>&>::SignalProxy2 (<retval>, D.111659, &Proxy_signal_properties_changed_info);
  return <retval>;
}


void {anonymous}::Proxy_signal_properties_changed_callback(GDBusProxy*, GVariant*, const gchar* const*, void*) (struct GDBusProxy * self, struct GVariant * p0, const gchar * const * p1, void * data)
{
  struct Proxy * iftmp.393;
  struct ObjectBase * D.111662;
  struct VectorType D.104406;
  struct map D.103626;
  struct Variant D.102604;
  struct slot2 * D.111670;
  void * D.111672;
  typedef struct SlotType SlotType;
  struct Proxy * obj;

  D.111662 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.111662 == 0B) goto <D.111663>; else goto <D.111664>;
  <D.111663>:
  iftmp.393 = 0B;
  goto <D.111665>;
  <D.111664>:
  iftmp.393 = __dynamic_cast (D.111662, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus5ProxyE, -1);
  <D.111665>:
  obj = iftmp.393;
  {
    if (obj != 0B) goto <D.111666>; else goto <D.111667>;
    <D.111666>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.111668>; else goto <D.111669>;
              <D.111668>:
              D.104406 = Glib::ArrayHandler<Glib::ustring>::array_to_vector (p1, 0); [return slot optimization]
              try
                {
                  Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::Variant (&D.102604, p0, 1);
                  try
                    {
                      D.103626 = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::get (&D.102604); [return slot optimization]
                      try
                        {
                          D.111670 = &MEM[(struct SlotType *)slot].D.102554;
                          sigc::slot2<void, const std::map<Glib::ustring, Glib::VariantBase>&, const std::vector<Glib::ustring>&>::operator() (D.111670, &D.103626, &D.104406);
                        }
                      finally
                        {
                          std::map<Glib::ustring, Glib::VariantBase>::~map (&D.103626);
                          D.103626 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::~Variant (&D.102604);
                      D.102604 = {CLOBBER};
                    }
                }
              finally
                {
                  std::vector<Glib::ustring>::~vector (&D.104406);
                  D.104406 = {CLOBBER};
                }
              goto <D.111671>;
              <D.111669>:
              <D.111671>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.111672 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.111672);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.111673>;
    <D.111667>:
    <D.111673>:
  }
}


static sigc::slot_base* Glib::SignalProxyBase::data_to_slot(void*) (void * data)
{
  struct slot_base * D.111681;
  struct slot_base * iftmp.394;
  struct slot_base * D.111683;
  bool D.111684;
  bool D.111685;
  struct SignalProxyConnectionNode * const pConnectionNode;

  pConnectionNode = data;
  D.111683 = &pConnectionNode->slot_;
  D.111684 = sigc::slot_base::blocked (D.111683);
  D.111685 = ~D.111684;
  if (D.111685 != 0) goto <D.111686>; else goto <D.111687>;
  <D.111686>:
  iftmp.394 = &pConnectionNode->slot_;
  goto <D.111688>;
  <D.111687>:
  iftmp.394 = 0B;
  <D.111688>:
  D.111681 = iftmp.394;
  return D.111681;
}


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

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


T_return sigc::slot2<T_return, T_arg1, T_arg2>::operator()(sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_, sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_) const [with T_return = void; T_arg1 = const std::map<Glib::ustring, Glib::VariantBase>&; T_arg2 = const std::vector<Glib::ustring>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg1_type_ = const std::map<Glib::ustring, Glib::VariantBase>&; sigc::slot2<T_return, T_arg1, T_arg2>::arg2_type_ = const std::vector<Glib::ustring>&] (const struct slot2 * const this, const struct map & _A_a1, const struct vector & _A_a2)
{
  bool retval.395;
  bool iftmp.396;
  const struct slot_base * D.111696;
  bool D.111697;
  bool D.111698;
  bool D.111700;
  bool D.111701;
  struct rep_type * D.111705;
  void * (*<T609>) (void *) D.111706;

  D.111696 = &this->D.102512;
  D.111697 = sigc::slot_base::empty (D.111696);
  D.111698 = ~D.111697;
  if (D.111698 != 0) goto <D.111699>; else goto <D.111694>;
  <D.111699>:
  D.111696 = &this->D.102512;
  D.111700 = sigc::slot_base::blocked (D.111696);
  D.111701 = ~D.111700;
  if (D.111701 != 0) goto <D.111702>; else goto <D.111694>;
  <D.111702>:
  iftmp.396 = 1;
  goto <D.111695>;
  <D.111694>:
  iftmp.396 = 0;
  <D.111695>:
  retval.395 = iftmp.396;
  if (retval.395 != 0) goto <D.111703>; else goto <D.111704>;
  <D.111703>:
  D.111705 = this->D.102512.rep_;
  D.111706 = D.111705->call_;
  D.111705 = this->D.102512.rep_;
  D.111706 (D.111705, _A_a1, _A_a2);
  return;
  <D.111704>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.111708;
  bool iftmp.397;
  struct rep_type * D.111713;
  void * (*<T609>) (void *) D.111715;

  D.111713 = this->rep_;
  if (D.111713 == 0B) goto <D.111710>; else goto <D.111714>;
  <D.111714>:
  D.111713 = this->rep_;
  D.111715 = D.111713->call_;
  if (D.111715 == 0B) goto <D.111710>; else goto <D.111711>;
  <D.111710>:
  iftmp.397 = 1;
  goto <D.111712>;
  <D.111711>:
  iftmp.397 = 0;
  <D.111712>:
  D.111708 = iftmp.397;
  return D.111708;
}


Glib::SignalProxy2<R, P1, P2>::SignalProxy2(Glib::ObjectBase*, const Glib::SignalProxyInfo*) [with R = void; P1 = const std::map<Glib::ustring, Glib::VariantBase>&; P2 = const std::vector<Glib::ustring>&] (struct SignalProxy2 * const this, struct ObjectBase * obj, const struct SignalProxyInfo * info)
{
  struct SignalProxyNormal * D.111717;

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

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


Glib::SignalProxy3<void, const Glib::ustring&, const Glib::ustring&, const Glib::VariantContainerBase&> Gio::DBus::Proxy::signal_signal() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111719;
  int (*__vtbl_ptr_type) () * D.111720;
  long int D.111721;
  sizetype D.111722;
  struct ObjectBase * D.111723;

  D.111719 = this->D.101147._vptr.Object;
  D.111720 = D.111719 + 18446744073709551592;
  D.111721 = MEM[(long int *)D.111720];
  D.111722 = (sizetype) D.111721;
  D.111723 = this + D.111722;
  Glib::SignalProxy3<void, const Glib::ustring&, const Glib::ustring&, const Glib::VariantContainerBase&>::SignalProxy3 (<retval>, D.111723, &Proxy_signal_signal_info);
  return <retval>;
}


void {anonymous}::Proxy_signal_signal_callback(GDBusProxy*, const gchar*, const gchar*, GVariant*, void*) (struct GDBusProxy * self, const gchar * p0, const gchar * p1, struct GVariant * p2, void * data)
{
  struct Proxy * iftmp.398;
  struct ObjectBase * D.111726;
  struct VariantContainerBase D.104527;
  struct ustring D.104526;
  struct ustring D.104525;
  struct slot3 * D.111734;
  void * D.111736;
  typedef struct SlotType SlotType;
  struct Proxy * obj;

  D.111726 = Glib::ObjectBase::_get_current_wrapper (self);
  if (D.111726 == 0B) goto <D.111727>; else goto <D.111728>;
  <D.111727>:
  iftmp.398 = 0B;
  goto <D.111729>;
  <D.111728>:
  iftmp.398 = __dynamic_cast (D.111726, &_ZTIN4Glib10ObjectBaseE, &_ZTIN3Gio4DBus5ProxyE, -1);
  <D.111729>:
  obj = iftmp.398;
  {
    if (obj != 0B) goto <D.111730>; else goto <D.111731>;
    <D.111730>:
    {
      try
        {
          {
            {
              struct slot_base * const slot;

              slot = Glib::SignalProxyBase::data_to_slot (data);
              if (slot != 0B) goto <D.111732>; else goto <D.111733>;
              <D.111732>:
              Glib::VariantContainerBase::VariantContainerBase (&D.104527, p2, 1);
              try
                {
                  D.104526 = Glib::convert_const_gchar_ptr_to_ustring (p1); [return slot optimization]
                  try
                    {
                      D.104525 = Glib::convert_const_gchar_ptr_to_ustring (p0); [return slot optimization]
                      try
                        {
                          D.111734 = &MEM[(struct SlotType *)slot].D.104523;
                          sigc::slot3<void, const Glib::ustring&, const Glib::ustring&, const Glib::VariantContainerBase&>::operator() (D.111734, &D.104525, &D.104526, &D.104527);
                        }
                      finally
                        {
                          Glib::ustring::~ustring (&D.104525);
                          D.104525 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      Glib::ustring::~ustring (&D.104526);
                      D.104526 = {CLOBBER};
                    }
                }
              finally
                {
                  Glib::VariantContainerBase::~VariantContainerBase (&D.104527);
                  D.104527 = {CLOBBER};
                }
              goto <D.111735>;
              <D.111733>:
              <D.111735>:
            }
          }
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.111736 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.111736);
                  Glib::exception_handlers_invoke ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
    }
    goto <D.111737>;
    <D.111731>:
    <D.111737>:
  }
}


T_return sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::operator()(sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_, sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_) const [with T_return = void; T_arg1 = const Glib::ustring&; T_arg2 = const Glib::ustring&; T_arg3 = const Glib::VariantContainerBase&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg1_type_ = const Glib::ustring&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg2_type_ = const Glib::ustring&; sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>::arg3_type_ = const Glib::VariantContainerBase&] (const struct slot3 * const this, const struct ustring & _A_a1, const struct ustring & _A_a2, const struct VariantContainerBase & _A_a3)
{
  bool retval.399;
  bool iftmp.400;
  const struct slot_base * D.111749;
  bool D.111750;
  bool D.111751;
  bool D.111753;
  bool D.111754;
  struct rep_type * D.111758;
  void * (*<T609>) (void *) D.111759;

  D.111749 = &this->D.104481;
  D.111750 = sigc::slot_base::empty (D.111749);
  D.111751 = ~D.111750;
  if (D.111751 != 0) goto <D.111752>; else goto <D.111747>;
  <D.111752>:
  D.111749 = &this->D.104481;
  D.111753 = sigc::slot_base::blocked (D.111749);
  D.111754 = ~D.111753;
  if (D.111754 != 0) goto <D.111755>; else goto <D.111747>;
  <D.111755>:
  iftmp.400 = 1;
  goto <D.111748>;
  <D.111747>:
  iftmp.400 = 0;
  <D.111748>:
  retval.399 = iftmp.400;
  if (retval.399 != 0) goto <D.111756>; else goto <D.111757>;
  <D.111756>:
  D.111758 = this->D.104481.rep_;
  D.111759 = D.111758->call_;
  D.111758 = this->D.104481.rep_;
  D.111759 (D.111758, _A_a1, _A_a2, _A_a3);
  return;
  <D.111757>:
  return;
}


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

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

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


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::DBus::Connection> > Gio::DBus::Proxy::property_g_connection() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111763;
  int (*__vtbl_ptr_type) () * D.111764;
  long int D.111765;
  sizetype D.111766;
  const struct ObjectBase * D.111767;

  D.111763 = this->D.101147._vptr.Object;
  D.111764 = D.111763 + 18446744073709551592;
  D.111765 = MEM[(long int *)D.111764];
  D.111766 = (sizetype) D.111765;
  D.111767 = this + D.111766;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::DBus::Connection> >::PropertyProxy_ReadOnly (<retval>, D.111767, "g-connection");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::DBus::Connection>] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.111769;

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


Glib::PropertyProxy<int> Gio::DBus::Proxy::property_g_default_timeout() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111771;
  int (*__vtbl_ptr_type) () * D.111772;
  long int D.111773;
  sizetype D.111774;
  struct ObjectBase * D.111775;

  D.111771 = this->D.101147._vptr.Object;
  D.111772 = D.111771 + 18446744073709551592;
  D.111773 = MEM[(long int *)D.111772];
  D.111774 = (sizetype) D.111773;
  D.111775 = this + D.111774;
  Glib::PropertyProxy<int>::PropertyProxy (<retval>, D.111775, "g-default-timeout");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<int> Gio::DBus::Proxy::property_g_default_timeout() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111779;
  int (*__vtbl_ptr_type) () * D.111780;
  long int D.111781;
  sizetype D.111782;
  const struct ObjectBase * D.111783;

  D.111779 = this->D.101147._vptr.Object;
  D.111780 = D.111779 + 18446744073709551592;
  D.111781 = MEM[(long int *)D.111780];
  D.111782 = (sizetype) D.111781;
  D.111783 = this + D.111782;
  Glib::PropertyProxy_ReadOnly<int>::PropertyProxy_ReadOnly (<retval>, D.111783, "g-default-timeout");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Gio::DBus::ProxyFlags> Gio::DBus::Proxy::property_g_flags() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111787;
  int (*__vtbl_ptr_type) () * D.111788;
  long int D.111789;
  sizetype D.111790;
  const struct ObjectBase * D.111791;

  D.111787 = this->D.101147._vptr.Object;
  D.111788 = D.111787 + 18446744073709551592;
  D.111789 = MEM[(long int *)D.111788];
  D.111790 = (sizetype) D.111789;
  D.111791 = this + D.111790;
  Glib::PropertyProxy_ReadOnly<Gio::DBus::ProxyFlags>::PropertyProxy_ReadOnly (<retval>, D.111791, "g-flags");
  return <retval>;
}


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

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


Glib::PropertyProxy<Glib::RefPtr<Gio::DBus::InterfaceInfo> > Gio::DBus::Proxy::property_g_interface_info() (struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111795;
  int (*__vtbl_ptr_type) () * D.111796;
  long int D.111797;
  sizetype D.111798;
  struct ObjectBase * D.111799;

  D.111795 = this->D.101147._vptr.Object;
  D.111796 = D.111795 + 18446744073709551592;
  D.111797 = MEM[(long int *)D.111796];
  D.111798 = (sizetype) D.111797;
  D.111799 = this + D.111798;
  Glib::PropertyProxy<Glib::RefPtr<Gio::DBus::InterfaceInfo> >::PropertyProxy (<retval>, D.111799, "g-interface-info");
  return <retval>;
}


Glib::PropertyProxy<T>::PropertyProxy(Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::DBus::InterfaceInfo>] (struct PropertyProxy * const this, struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.111801;

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


Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::DBus::InterfaceInfo> > Gio::DBus::Proxy::property_g_interface_info() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111803;
  int (*__vtbl_ptr_type) () * D.111804;
  long int D.111805;
  sizetype D.111806;
  const struct ObjectBase * D.111807;

  D.111803 = this->D.101147._vptr.Object;
  D.111804 = D.111803 + 18446744073709551592;
  D.111805 = MEM[(long int *)D.111804];
  D.111806 = (sizetype) D.111805;
  D.111807 = this + D.111806;
  Glib::PropertyProxy_ReadOnly<Glib::RefPtr<Gio::DBus::InterfaceInfo> >::PropertyProxy_ReadOnly (<retval>, D.111807, "g-interface-info");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<T>::PropertyProxy_ReadOnly(const Glib::ObjectBase*, const char*) [with T = Glib::RefPtr<Gio::DBus::InterfaceInfo>] (struct PropertyProxy_ReadOnly * const this, const struct ObjectBase * obj, const char * name)
{
  struct PropertyProxy_Base * D.111809;

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


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::DBus::Proxy::property_g_interface_name() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111811;
  int (*__vtbl_ptr_type) () * D.111812;
  long int D.111813;
  sizetype D.111814;
  const struct ObjectBase * D.111815;

  D.111811 = this->D.101147._vptr.Object;
  D.111812 = D.111811 + 18446744073709551592;
  D.111813 = MEM[(long int *)D.111812];
  D.111814 = (sizetype) D.111813;
  D.111815 = this + D.111814;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.111815, "g-interface-name");
  return <retval>;
}


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

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


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::DBus::Proxy::property_g_name() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111819;
  int (*__vtbl_ptr_type) () * D.111820;
  long int D.111821;
  sizetype D.111822;
  const struct ObjectBase * D.111823;

  D.111819 = this->D.101147._vptr.Object;
  D.111820 = D.111819 + 18446744073709551592;
  D.111821 = MEM[(long int *)D.111820];
  D.111822 = (sizetype) D.111821;
  D.111823 = this + D.111822;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.111823, "g-name");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::DBus::Proxy::property_g_name_owner() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111826;
  int (*__vtbl_ptr_type) () * D.111827;
  long int D.111828;
  sizetype D.111829;
  const struct ObjectBase * D.111830;

  D.111826 = this->D.101147._vptr.Object;
  D.111827 = D.111826 + 18446744073709551592;
  D.111828 = MEM[(long int *)D.111827];
  D.111829 = (sizetype) D.111828;
  D.111830 = this + D.111829;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.111830, "g-name-owner");
  return <retval>;
}


Glib::PropertyProxy_ReadOnly<Glib::ustring> Gio::DBus::Proxy::property_g_object_path() const (const struct Proxy * const this)
{
  int (*__vtbl_ptr_type) () * D.111833;
  int (*__vtbl_ptr_type) () * D.111834;
  long int D.111835;
  sizetype D.111836;
  const struct ObjectBase * D.111837;

  D.111833 = this->D.101147._vptr.Object;
  D.111834 = D.111833 + 18446744073709551592;
  D.111835 = MEM[(long int *)D.111834];
  D.111836 = (sizetype) D.111835;
  D.111837 = this + D.111836;
  Glib::PropertyProxy_ReadOnly<Glib::ustring>::PropertyProxy_ReadOnly (<retval>, D.111837, "g-object-path");
  return <retval>;
}


virtual void Gio::DBus::Proxy::on_properties_changed(const MapChangedProperties&, const std::vector<Glib::ustring>&) (struct Proxy * const this, const struct MapChangedProperties & changed_properties, const struct vector & invalidated_properties)
{
  int (*__vtbl_ptr_type) () * D.111839;
  int (*__vtbl_ptr_type) () * D.111840;
  long int D.111841;
  sizetype D.111842;
  struct ObjectBase * D.111843;
  struct GObject * D.111844;
  struct GTypeClass * D.111845;
  void (*<T10237>) (struct GDBusProxy *, struct GVariant *, const gchar * const *) D.111848;
  struct ArrayKeeperType D.105667;
  const char * * D.111851;
  struct Variant D.105622;
  struct GVariant * D.111852;
  struct GDBusProxy * D.111853;
  struct BaseClassType * const base;

  D.111839 = this->D.101147._vptr.Object;
  D.111840 = D.111839 + 18446744073709551592;
  D.111841 = MEM[(long int *)D.111840];
  D.111842 = (sizetype) D.111841;
  D.111843 = this + D.111842;
  D.111844 = D.111843->gobject_;
  D.111845 = MEM[(struct GTypeInstance *)D.111844].g_class;
  base = g_type_class_peek_parent (D.111845);
  if (base != 0B) goto <D.111846>; else goto <D.111847>;
  <D.111846>:
  D.111848 = base->g_properties_changed;
  if (D.111848 != 0B) goto <D.111849>; else goto <D.111850>;
  <D.111849>:
  D.111848 = base->g_properties_changed;
  D.105667 = Glib::ArrayHandler<Glib::ustring>::vector_to_array (invalidated_properties); [return slot optimization]
  try
    {
      D.111851 = Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::data (&D.105667);
      D.105622 = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::create (changed_properties); [return slot optimization]
      try
        {
          D.111852 = Glib::VariantBase::gobj (&D.105622.D.102593.D.66789);
          D.111853 = Gio::DBus::Proxy::gobj (this);
          D.111848 (D.111853, D.111852, D.111851);
        }
      finally
        {
          Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::~Variant (&D.105622);
          D.105622 = {CLOBBER};
        }
    }
  finally
    {
      Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::~ArrayKeeper (&D.105667);
      D.105667 = {CLOBBER};
    }
  goto <D.111854>;
  <D.111850>:
  <D.111854>:
  <D.111847>:
}


static Glib::ArrayHandler<T, Tr>::ArrayKeeperType Glib::ArrayHandler<T, Tr>::vector_to_array(const VectorType&) [with T = Glib::ustring; Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; Glib::ArrayHandler<T, Tr>::ArrayKeeperType = Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >; Glib::ArrayHandler<T, Tr>::VectorType = std::vector<Glib::ustring>] (const struct VectorType & vector)
{
  long unsigned int D.111859;
  long unsigned int D.111860;
  struct __normal_iterator D.111861;
  const char * * D.111862;

  D.111859 = std::vector<Glib::ustring>::size (vector);
  D.111860 = std::vector<Glib::ustring>::size (vector);
  D.111861 = std::vector<Glib::ustring>::begin (vector);
  D.111862 = Glib::Container_Helpers::create_array<Glib::Container_Helpers::TypeTraits<Glib::ustring> > (D.111861, D.111860);
  Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<Glib::ustring> >::ArrayKeeper (<retval>, D.111862, D.111859, 1);
  return <retval>;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = Glib::ustring; _Alloc = std::allocator<Glib::ustring>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.111865;
  struct ustring * D.111866;
  long int D.111867;
  struct ustring * D.111868;
  long int D.111869;
  long int D.111870;
  long int D.111871;

  D.111866 = this->D.104404._M_impl._M_finish;
  D.111867 = (long int) D.111866;
  D.111868 = this->D.104404._M_impl._M_start;
  D.111869 = (long int) D.111868;
  D.111870 = D.111867 - D.111869;
  D.111871 = D.111870 /[ex] 8;
  D.111865 = (size_type) D.111871;
  return D.111865;
}


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.111873;
  struct const_iterator D.107427;
  const struct ustring * const D.107426;
  struct ustring * D.111874;

  D.111874 = this->D.104404._M_impl._M_start;
  D.107426 = D.111874;
  try
    {
      __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::__normal_iterator (&D.107427, &D.107426);
      try
        {
          D.111873 = D.107427;
          return D.111873;
        }
      finally
        {
          D.107427 = {CLOBBER};
        }
    }
  finally
    {
      D.107426 = {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.111878;

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


typename Tr::CType* Glib::Container_Helpers::create_array(typename std::vector<typename Tr::CppType>::const_iterator, std::size_t) [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; typename Tr::CType = const char*; typename std::vector<typename Tr::CppType>::const_iterator = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >; std::size_t = long unsigned int] (struct const_iterator pbegin, size_t size)
{
  long unsigned int D.111879;
  long unsigned int D.111880;
  long unsigned int D.111881;
  const struct ustring & D.111882;
  const char * D.111883;
  const char * * D.111884;
  typedef const char * CType;
  const char * * const array;
  const char * * const array_end;

  D.111879 = size + 1;
  D.111880 = D.111879 * 8;
  array = g_malloc (D.111880);
  D.111881 = size * 8;
  array_end = array + D.111881;
  {
    const char * * pdest;

    pdest = array;
    goto <D.107437>;
    <D.107436>:
    D.111882 = __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::operator* (&pbegin);
    D.111883 = Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_c_type (D.111882);
    *pdest = D.111883;
    __gnu_cxx::__normal_iterator<const Glib::ustring*, std::vector<Glib::ustring> >::operator++ (&pbegin);
    pdest = pdest + 8;
    <D.107437>:
    if (pdest != array_end) goto <D.107436>; else goto <D.107434>;
    <D.107434>:
  }
  *array_end = 0B;
  D.111884 = array;
  return D.111884;
}


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

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


static const char* Glib::Container_Helpers::TypeTraits<Glib::ustring>::to_c_type(const Glib::ustring&) (const struct ustring & str)
{
  const char * D.111890;

  D.111890 = Glib::ustring::c_str (str);
  return D.111890;
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++() [with _Iterator = const Glib::ustring*; _Container = std::vector<Glib::ustring>] (struct __normal_iterator * const this)
{
  const struct ustring * D.111893;
  const struct ustring * D.111894;
  struct __normal_iterator & D.111895;

  D.111893 = this->_M_current;
  D.111894 = D.111893 + 8;
  this->_M_current = D.111894;
  D.111895 = this;
  return D.111895;
}


typename Tr::CType* Glib::Container_Helpers::ArrayKeeper<Tr>::data() const [with Tr = Glib::Container_Helpers::TypeTraits<Glib::ustring>; typename Tr::CType = const char*] (const struct ArrayKeeper * const this)
{
  const char * * D.111897;

  D.111897 = this->array_;
  return D.111897;
}


static Glib::Variant<std::map<K, V> > Glib::Variant<std::map<K, V> >::create(const std::map<K, V>&) [with K = Glib::ustring; V = Glib::VariantBase] (const struct map & data)
{
  const struct VariantType & D.111900;
  const struct VariantType & D.111901;
  struct GVariantType * D.111902;
  const struct pair D.106715;
  const struct pair & D.111903;
  struct GVariant * D.111904;
  struct _Self D.106695;
  bool retval.401;
  struct const_iterator D.106694;
  struct GVariantType * D.111906;
  struct GVariant * D.111907;
  struct VariantType element_variant_type;
  struct VariantType array_variant_type;
  struct GVariantBuilder * builder;
  struct Variant result [value-expr: *<retval>];

  try
    {
      D.111900 = Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::variant_type ();
      Glib::VariantType::VariantType (&element_variant_type, D.111900);
      try
        {
          D.111901 = Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::variant_type ();
          Glib::VariantType::VariantType (&array_variant_type, D.111901);
          try
            {
              D.111902 = Glib::VariantType::gobj (&array_variant_type);
              builder = g_variant_builder_new (D.111902);
              {
                struct const_iterator iter;

                try
                  {
                    iter = std::map<Glib::ustring, Glib::VariantBase>::begin (data);
                    goto <D.106729>;
                    <D.106728>:
                    {
                      struct Variant dict_entry;

                      try
                        {
                          D.111903 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::operator* (&iter);
                          std::pair<Glib::ustring, Glib::VariantBase>::pair<const Glib::ustring, Glib::VariantBase> (&D.106715, D.111903);
                          try
                            {
                              dict_entry = Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::create (&D.106715); [return slot optimization]
                            }
                          finally
                            {
                              try
                                {
                                  std::pair<Glib::ustring, Glib::VariantBase>::~pair (&D.106715);
                                }
                              catch
                                {
                                  Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::~Variant (&dict_entry);
                                }
                              D.106715 = {CLOBBER};
                            }
                          try
                            {
                              D.111904 = Glib::VariantBase::gobj (&dict_entry.D.106112.D.66789);
                              g_variant_builder_add_value (builder, D.111904);
                            }
                          finally
                            {
                              Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::~Variant (&dict_entry);
                            }
                        }
                      finally
                        {
                          dict_entry = {CLOBBER};
                        }
                    }
                    D.106695 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::operator++ (&iter, 0);
                    <D.106729>:
                    D.106694 = std::map<Glib::ustring, Glib::VariantBase>::end (data);
                    try
                      {
                        retval.401 = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::operator!= (&iter, &D.106694);
                      }
                    finally
                      {
                        D.106694 = {CLOBBER};
                      }
                    if (retval.401 != 0) goto <D.106728>; else goto <D.106726>;
                    <D.106726>:
                  }
                finally
                  {
                    iter = {CLOBBER};
                  }
              }
              D.111906 = Glib::VariantType::gobj (&array_variant_type);
              D.111907 = g_variant_new (D.111906, builder);
              Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::Variant (<retval>, D.111907, 0);
              try
                {
                  g_variant_builder_unref (builder);
                  return <retval>;
                }
              catch
                {
                  Glib::Variant<std::map<Glib::ustring, Glib::VariantBase> >::~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};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::const_iterator std::map<_Key, _Tp, _Compare, _Alloc>::begin() const [with _Key = Glib::ustring; _Tp = Glib::VariantBase; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::map<_Key, _Tp, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct map * const this)
{
  struct const_iterator D.111926;
  const struct _Rep_type * D.111927;

  D.111927 = &this->_M_t;
  D.111926 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::begin (D.111927);
  return D.111926;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::begin() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct _Rb_tree * const this)
{
  struct const_iterator D.111929;
  struct const_iterator D.107834;
  struct _Rb_tree_node_base * D.111930;

  D.111930 = this->_M_impl._M_header._M_left;
  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_const_iterator (&D.107834, D.111930);
  try
    {
      D.111929 = D.107834;
      return D.111929;
    }
  finally
    {
      D.107834 = {CLOBBER};
    }
}


std::_Rb_tree_const_iterator<_Tp>::_Rb_tree_const_iterator(std::_Rb_tree_const_iterator<_Tp>::_Link_type) [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_const_iterator<_Tp>::_Link_type = const std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >*] (struct _Rb_tree_const_iterator * const this, const struct _Rb_tree_node * __x)
{
  this->_M_node = __x;
}


const _Tp& std::_Rb_tree_const_iterator<_Tp>::operator*() const [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_const_iterator<_Tp>::reference = const std::pair<const Glib::ustring, Glib::VariantBase>&] (const struct _Rb_tree_const_iterator * const this)
{
  const struct pair & D.111933;
  const struct _Rb_tree_node_base * D.111934;

  D.111934 = this->_M_node;
  D.111933 = std::_Rb_tree_node<std::pair<const Glib::ustring, Glib::VariantBase> >::_M_valptr (D.111934);
  return D.111933;
}


std::pair<_T1, _T2>::pair(const std::pair<_U1, _U2>&) [with _U1 = const Glib::ustring; _U2 = Glib::VariantBase; _T1 = Glib::ustring; _T2 = Glib::VariantBase] (struct pair * const this, const struct pair & __p)
{
  const struct ustring * D.111937;
  struct ustring * D.111938;
  const struct VariantBase * D.111939;
  struct VariantBase * D.111940;

  D.111937 = &__p->first;
  D.111938 = &this->first;
  Glib::ustring::ustring (D.111938, D.111937);
  try
    {
      D.111939 = &__p->second;
      D.111940 = &this->second;
      Glib::VariantBase::VariantBase (D.111940, D.111939);
      try
        {

        }
      catch
        {
          D.111940 = &this->second;
          Glib::VariantBase::~VariantBase (D.111940);
        }
    }
  catch
    {
      D.111938 = &this->first;
      Glib::ustring::~ustring (D.111938);
    }
}


static Glib::Variant<std::pair<_T1, _T2> > Glib::Variant<std::pair<_T1, _T2> >::create(const std::pair<_T1, _T2>&) [with K = Glib::ustring; V = Glib::VariantBase] (const struct pair & data)
{
  const struct ustring * D.111943;
  const struct VariantBase * D.111944;
  struct GVariant * D.111945;
  struct GVariant * D.111946;
  struct GVariant * D.111947;
  struct Variant key;
  struct Variant value;
  struct Variant result [value-expr: *<retval>];

  try
    {
      D.111943 = &data->first;
      key = Glib::Variant<Glib::ustring>::create (D.111943); [return slot optimization]
      try
        {
          D.111944 = &data->second;
          value = Glib::Variant<Glib::VariantBase>::create (D.111944); [return slot optimization]
          try
            {
              D.111945 = Glib::VariantBase::gobj (&value.D.66837.D.66789);
              D.111946 = Glib::VariantBase::gobj (&key.D.66896.D.66743);
              D.111947 = g_variant_new_dict_entry (D.111946, D.111945);
              Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::Variant (<retval>, D.111947, 0);
              try
                {
                  return <retval>;
                }
              catch
                {
                  Glib::Variant<std::pair<Glib::ustring, Glib::VariantBase> >::~Variant (<retval>);
                }
            }
          finally
            {
              Glib::Variant<Glib::VariantBase>::~Variant (&value);
            }
        }
      finally
        {
          Glib::Variant<Glib::ustring>::~Variant (&key);
        }
    }
  finally
    {
      key = {CLOBBER};
      value = {CLOBBER};
    }
}


Glib::Variant<std::pair<_T1, _T2> >::Variant(GVariant*, bool) [with K = Glib::ustring; V = Glib::VariantBase; GVariant = _GVariant] (struct Variant * const this, struct GVariant * castitem, bool take_a_reference)
{
  int D.111956;
  struct VariantContainerBase * D.111957;

  D.111956 = (int) take_a_reference;
  D.111957 = &this->D.106112;
  Glib::VariantContainerBase::VariantContainerBase (D.111957, castitem, D.111956);
  try
    {

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


std::_Rb_tree_const_iterator<_Tp>::_Self std::_Rb_tree_const_iterator<_Tp>::operator++(int) [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_const_iterator<_Tp>::_Self = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (struct _Rb_tree_const_iterator * const this, int D.106645)
{
  const struct _Rb_tree_node_base * D.111958;
  const struct _Rb_tree_node_base * D.111959;
  struct _Self D.111960;
  struct _Self __tmp;

  try
    {
      __tmp = MEM[(const struct _Rb_tree_const_iterator &)this];
      D.111958 = this->_M_node;
      D.111959 = std::_Rb_tree_increment (D.111958);
      this->_M_node = D.111959;
      D.111960 = __tmp;
      return D.111960;
    }
  finally
    {
      __tmp = {CLOBBER};
    }
}


std::map<_Key, _Tp, _Compare, _Alloc>::const_iterator std::map<_Key, _Tp, _Compare, _Alloc>::end() const [with _Key = Glib::ustring; _Tp = Glib::VariantBase; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::map<_Key, _Tp, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct map * const this)
{
  struct const_iterator D.111963;
  const struct _Rep_type * D.111964;

  D.111964 = &this->_M_t;
  D.111963 = std::_Rb_tree<Glib::ustring, std::pair<const Glib::ustring, Glib::VariantBase>, std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >, std::less<Glib::ustring>, std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> > >::end (D.111964);
  return D.111963;
}


std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::end() const [with _Key = Glib::ustring; _Val = std::pair<const Glib::ustring, Glib::VariantBase>; _KeyOfValue = std::_Select1st<std::pair<const Glib::ustring, Glib::VariantBase> >; _Compare = std::less<Glib::ustring>; _Alloc = std::allocator<std::pair<const Glib::ustring, Glib::VariantBase> >; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct _Rb_tree * const this)
{
  struct const_iterator D.111966;
  struct const_iterator D.107836;
  const struct _Rb_tree_node_base * D.111967;

  D.111967 = &this->_M_impl._M_header;
  std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >::_Rb_tree_const_iterator (&D.107836, D.111967);
  try
    {
      D.111966 = D.107836;
      return D.111966;
    }
  finally
    {
      D.107836 = {CLOBBER};
    }
}


bool std::_Rb_tree_const_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = std::pair<const Glib::ustring, Glib::VariantBase>; std::_Rb_tree_const_iterator<_Tp>::_Self = std::_Rb_tree_const_iterator<std::pair<const Glib::ustring, Glib::VariantBase> >] (const struct _Rb_tree_const_iterator * const this, const struct _Self & __x)
{
  bool D.111970;
  const struct _Rb_tree_node_base * D.111971;
  const struct _Rb_tree_node_base * D.111972;

  D.111971 = this->_M_node;
  D.111972 = __x->_M_node;
  D.111970 = D.111971 != D.111972;
  return D.111970;
}


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

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


virtual void Gio::DBus::Proxy::on_signal(const Glib::ustring&, const Glib::ustring&, const Glib::VariantContainerBase&) (struct Proxy * const this, const struct ustring & sender_name, const struct ustring & signal_name, const struct VariantContainerBase & parameters)
{
  int (*__vtbl_ptr_type) () * D.111976;
  int (*__vtbl_ptr_type) () * D.111977;
  long int D.111978;
  sizetype D.111979;
  struct ObjectBase * D.111980;
  struct GObject * D.111981;
  struct GTypeClass * D.111982;
  void (*<T1023b>) (struct GDBusProxy *, const gchar *, const gchar *, struct GVariant *) D.111985;
  const struct VariantBase * D.111988;
  const struct GVariant * D.111989;
  const char * D.111990;
  const char * D.111991;
  struct GDBusProxy * D.111992;
  struct BaseClassType * const base;

  D.111976 = this->D.101147._vptr.Object;
  D.111977 = D.111976 + 18446744073709551592;
  D.111978 = MEM[(long int *)D.111977];
  D.111979 = (sizetype) D.111978;
  D.111980 = this + D.111979;
  D.111981 = D.111980->gobject_;
  D.111982 = MEM[(struct GTypeInstance *)D.111981].g_class;
  base = g_type_class_peek_parent (D.111982);
  if (base != 0B) goto <D.111983>; else goto <D.111984>;
  <D.111983>:
  D.111985 = base->g_signal;
  if (D.111985 != 0B) goto <D.111986>; else goto <D.111987>;
  <D.111986>:
  D.111985 = base->g_signal;
  D.111988 = &parameters->D.66789;
  D.111989 = Glib::VariantBase::gobj (D.111988);
  D.111990 = Glib::ustring::c_str (signal_name);
  D.111991 = Glib::ustring::c_str (sender_name);
  D.111992 = Gio::DBus::Proxy::gobj (this);
  D.111985 (D.111992, D.111991, D.111990, D.111989);
  goto <D.111993>;
  <D.111987>:
  <D.111993>:
  <D.111984>:
}