int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.45719;
  int D.45722;
  int iftmp.1;
  bool D.45724;
  const int D.39667;
  const struct string D.39670;
  struct allocator D.39669;
  struct iterator D.39821;
  const struct slot_type D.39742;
  struct pointer_functor1 D.39732;
  struct iterator D.39950;
  const struct slot_type D.39949;
  struct bound_mem_functor1 D.39939;
  struct 
{
  int A::<T6fdd> (struct A *, int) * __pfn;
  long int __delta;
} D.45728;
  struct iterator D.39995;
  const struct slot_type D.39994;
  struct pointer_functor1 D.39984;
  const int D.39996;
  long unsigned int D.45729;
  const struct string D.39999;
  struct allocator D.39998;
  const int D.40000;
  long unsigned int D.45730;
  const struct string D.40003;
  struct allocator D.40002;
  struct allocator D.40007;
  struct iterator D.40470;
  const struct slot_type D.40391;
  struct bound_mem_functor1 D.40381;
  struct 
{
  void A::<T6fe2> (struct A *, struct string &) * __pfn;
  long int __delta;
} D.45731;
  const struct string D.40473;
  struct allocator D.40472;
  struct iterator D.40476;
  const struct slot_type D.40475;
  struct pointer_functor1 D.40474;
  struct iterator D.40598;
  const struct slot_type D.40597;
  struct bound_const_mem_functor1 D.40587;
  const int D.40599;
  const struct string D.40602;
  struct allocator D.40601;
  int iftmp.2;
  bool D.45733;

  {
    struct TestUtilities * util;
    struct signal sig;
    struct A a;
    struct string str;
    struct signal sigstr;
    struct signal sig2;

    try
      {
        util = TestUtilities::get_instance ();
        D.45719 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.45719;
        if (retval.0 != 0) goto <D.45720>; else goto <D.45721>;
        <D.45720>:
        D.45724 = TestUtilities::get_result_and_delete_instance ();
        if (D.45724 != 0) goto <D.45725>; else goto <D.45726>;
        <D.45725>:
        iftmp.1 = 0;
        goto <D.45727>;
        <D.45726>:
        iftmp.1 = 1;
        <D.45727>:
        D.45722 = iftmp.1;
        return D.45722;
        <D.45721>:
        sigc::signal<int, int>::signal (&sig);
        try
          {
            D.39667 = 0;
            try
              {
                sigc::signal1<int, int, sigc::nil>::operator() (&sig.D.39633, &D.39667);
              }
            finally
              {
                D.39667 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.39669);
            try
              {
                std::basic_string<char>::basic_string (&D.39670, "", &D.39669);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.39670);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.39670);
                    D.39670 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.39669);
                D.39669 = {CLOBBER};
              }
            {
              struct A a;

              try
                {
                  {anonymous}::A::A (&a);
                  try
                    {
                      D.39732 = sigc::ptr_fun1<int, int> (foo);
                      try
                        {
                          sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<int, int> > (&D.39742, &D.39732);
                          try
                            {
                              D.39821 = sigc::signal1<int, int, sigc::nil>::connect (&sig.D.39633, &D.39742);
                            }
                          finally
                            {
                              sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.39742);
                              D.39742 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39732 = {CLOBBER};
                        }
                      D.45728.__pfn = foo;
                      D.45728.__delta = 0;
                      D.39939 = sigc::mem_fun1<int, int, {anonymous}::A, {anonymous}::A> (&a, D.45728); [return slot optimization]
                      try
                        {
                          sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_mem_functor1<int, {anonymous}::A, int> > (&D.39949, &D.39939);
                          try
                            {
                              D.39950 = sigc::signal1<int, int, sigc::nil>::connect (&sig.D.39633, &D.39949);
                            }
                          finally
                            {
                              sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.39949);
                              D.39949 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39939 = {CLOBBER};
                        }
                      D.39984 = sigc::ptr_fun1<float, int> (bar);
                      try
                        {
                          sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<float, int> > (&D.39994, &D.39984);
                          try
                            {
                              D.39995 = sigc::signal1<int, int, sigc::nil>::connect (&sig.D.39633, &D.39994);
                            }
                          finally
                            {
                              sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.39994);
                              D.39994 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.39984 = {CLOBBER};
                        }
                      D.39996 = 1;
                      try
                        {
                          sigc::signal1<int, int, sigc::nil>::operator() (&sig.D.39633, &D.39996);
                        }
                      finally
                        {
                          D.39996 = {CLOBBER};
                        }
                      D.45729 = sigc::signal_base::size (&sig.D.39633.D.39608);
                      std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.45729);
                      std::allocator<char>::allocator (&D.39998);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.39999, "foo(int 1) A::foo(int 1) bar(float 1) 3", &D.39998);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.39999);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.39999);
                              D.39999 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.39998);
                          D.39998 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::A::~A (&a);
                    }
                }
              finally
                {
                  a = {CLOBBER};
                }
            }
            D.40000 = 2;
            try
              {
                sigc::signal1<int, int, sigc::nil>::operator() (&sig.D.39633, &D.40000);
              }
            finally
              {
                D.40000 = {CLOBBER};
              }
            D.45730 = sigc::signal_base::size (&sig.D.39633.D.39608);
            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.45730);
            std::allocator<char>::allocator (&D.40002);
            try
              {
                std::basic_string<char>::basic_string (&D.40003, "foo(int 2) bar(float 2) 2", &D.40002);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.40003);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.40003);
                    D.40003 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.40002);
                D.40002 = {CLOBBER};
              }
            {anonymous}::A::A (&a);
            try
              {
                std::allocator<char>::allocator (&D.40007);
                try
                  {
                    std::basic_string<char>::basic_string (&str, "guest book", &D.40007);
                  }
                finally
                  {
                    try
                      {
                        std::allocator<char>::~allocator (&D.40007);
                      }
                    catch
                      {
                        std::basic_string<char>::~basic_string (&str);
                      }
                    D.40007 = {CLOBBER};
                  }
                try
                  {
                    sigc::signal<void, std::basic_string<char>&>::signal (&sigstr);
                    try
                      {
                        D.45731.__pfn = bar;
                        D.45731.__delta = 0;
                        D.40381 = sigc::mem_fun<std::basic_string<char>&, void, {anonymous}::A, {anonymous}::A> (&a, D.45731); [return slot optimization]
                        try
                          {
                            sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > (&D.40391, &D.40381);
                            try
                              {
                                D.40470 = sigc::signal1<void, std::basic_string<char>&, sigc::nil>::connect (&sigstr.D.40270, &D.40391);
                              }
                            finally
                              {
                                sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.40391);
                                D.40391 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            D.40381 = {CLOBBER};
                          }
                        sigc::signal1<void, std::basic_string<char>&, sigc::nil>::operator() (&sigstr.D.40270, &str);
                        std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, &str);
                        std::allocator<char>::allocator (&D.40472);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.40473, "A::foo(string \'guest book\') foo was here", &D.40472);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.40473);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.40473);
                                D.40473 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.40472);
                            D.40472 = {CLOBBER};
                          }
                        D.40474 = sigc::ptr_fun1<int, int> (foo);
                        try
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<int, int> > (&D.40475, &D.40474);
                            try
                              {
                                D.40476 = sigc::signal1<int, int, sigc::nil>::connect (&sig.D.39633, &D.40475);
                              }
                            finally
                              {
                                sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.40475);
                                D.40475 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            D.40474 = {CLOBBER};
                          }
                        sigc::signal<int, int>::signal (&sig2);
                        try
                          {
                            D.40587 = sigc::signal1<int, int, sigc::nil>::make_slot (&sig.D.39633); [return slot optimization]
                            try
                              {
                                sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > (&D.40597, &D.40587);
                                try
                                  {
                                    D.40598 = sigc::signal1<int, int, sigc::nil>::connect (&sig2.D.39633, &D.40597);
                                  }
                                finally
                                  {
                                    sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.40597);
                                    D.40597 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                D.40587 = {CLOBBER};
                              }
                            D.40599 = 3;
                            try
                              {
                                sigc::signal1<int, int, sigc::nil>::operator() (&sig2.D.39633, &D.40599);
                              }
                            finally
                              {
                                D.40599 = {CLOBBER};
                              }
                            std::allocator<char>::allocator (&D.40601);
                            try
                              {
                                std::basic_string<char>::basic_string (&D.40602, "foo(int 3) bar(float 3) foo(int 3) ", &D.40601);
                                try
                                  {
                                    TestUtilities::check_result (util, &result_stream, &D.40602);
                                  }
                                finally
                                  {
                                    std::basic_string<char>::~basic_string (&D.40602);
                                    D.40602 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                std::allocator<char>::~allocator (&D.40601);
                                D.40601 = {CLOBBER};
                              }
                            D.45733 = TestUtilities::get_result_and_delete_instance ();
                            if (D.45733 != 0) goto <D.45734>; else goto <D.45735>;
                            <D.45734>:
                            iftmp.2 = 0;
                            goto <D.45736>;
                            <D.45735>:
                            iftmp.2 = 1;
                            <D.45736>:
                            D.45722 = iftmp.2;
                            return D.45722;
                          }
                        finally
                          {
                            sigc::signal<int, int>::~signal (&sig2);
                          }
                      }
                    finally
                      {
                        sigc::signal<void, std::basic_string<char>&>::~signal (&sigstr);
                      }
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&str);
                  }
              }
            finally
              {
                {anonymous}::A::~A (&a);
              }
          }
        finally
          {
            sigc::signal<int, int>::~signal (&sig);
          }
      }
    finally
      {
        sig = {CLOBBER};
        a = {CLOBBER};
        str = {CLOBBER};
        sigstr = {CLOBBER};
        sig2 = {CLOBBER};
      }
  }
  D.45722 = 0;
  return D.45722;
}


void {anonymous}::A::bar(std::string&) (struct A * const this, struct string & str)
{
  struct basic_ostream & D.45786;
  struct basic_ostream & D.45787;

  D.45786 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "A::foo(string \'");
  D.45787 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.45786, str);
  std::operator<< <std::char_traits<char> > (D.45787, "\') ");
  std::basic_string<char>::operator= (str, "foo was here");
}


std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with _Traits = std::char_traits<char>] (struct basic_ostream & __out, const char * __s)
{
  int (*__vtbl_ptr_type) () * D.45792;
  int (*__vtbl_ptr_type) () * D.45793;
  long int D.45794;
  sizetype D.45795;
  struct basic_ios * D.45796;
  long unsigned int D.45798;
  long int D.45799;
  struct basic_ostream & D.45800;

  if (__s == 0B) goto <D.45790>; else goto <D.45791>;
  <D.45790>:
  D.45792 = __out->_vptr.basic_ostream;
  D.45793 = D.45792 + 18446744073709551592;
  D.45794 = MEM[(long int *)D.45793];
  D.45795 = (sizetype) D.45794;
  D.45796 = __out + D.45795;
  std::basic_ios<char>::setstate (D.45796, 1);
  goto <D.45797>;
  <D.45791>:
  D.45798 = std::char_traits<char>::length (__s);
  D.45799 = (long int) D.45798;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.45799);
  <D.45797>:
  D.45800 = __out;
  return D.45800;
}


void std::basic_ios<_CharT, _Traits>::setstate(std::ios_base::iostate) [with _CharT = char; _Traits = std::char_traits<char>; std::ios_base::iostate = std::_Ios_Iostate] (struct basic_ios * const this, iostate __state)
{
  _Ios_Iostate D.45802;
  _Ios_Iostate D.45803;

  D.45802 = std::basic_ios<char>::rdstate (this);
  D.45803 = std::operator| (D.45802, __state);
  std::basic_ios<char>::clear (this, D.45803);
}


std::ios_base::iostate std::basic_ios<_CharT, _Traits>::rdstate() const [with _CharT = char; _Traits = std::char_traits<char>; std::ios_base::iostate = std::_Ios_Iostate] (const struct basic_ios * const this)
{
  iostate D.45805;

  D.45805 = this->D.19008._M_streambuf_state;
  return D.45805;
}


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.45807;
  int __a.3;
  int __b.4;
  int D.45810;

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.45810 = __a.3 | __b.4;
  D.45807 = (_Ios_Iostate) D.45810;
  return D.45807;
}


static std::size_t std::char_traits<char>::length(const char_type*) (const char_type * __s)
{
  size_t D.45812;

  D.45812 = __builtin_strlen (__s);
  return D.45812;
}


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

  D.45814 = std::basic_string<char>::assign (this, __s);
  return D.45814;
}


std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::assign(const _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this, const char * __s)
{
  struct basic_string & D.45817;
  long unsigned int D.45818;

  D.45818 = std::char_traits<char>::length (__s);
  D.45817 = std::basic_string<char>::assign (this, __s, D.45818);
  return D.45817;
}


int {anonymous}::bar(float) (float i)
{
  struct basic_ostream & D.45821;
  struct __ostream_type & D.45822;
  int D.45823;

  D.45821 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar(float ");
  D.45822 = std::basic_ostream<char>::operator<< (D.45821, i);
  std::operator<< <std::char_traits<char> > (D.45822, ") ");
  D.45823 = 1;
  return D.45823;
}


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, float __f)
{
  struct __ostream_type & D.45827;
  double D.45828;

  D.45828 = (double) __f;
  D.45827 = std::basic_ostream<char>::_M_insert<double> (this, D.45828);
  return D.45827;
}


int {anonymous}::A::foo(int) (struct A * const this, int i)
{
  struct basic_ostream & D.45833;
  struct basic_ostream & D.45834;
  int D.45835;

  D.45833 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "A::foo(int ");
  D.45834 = std::basic_ostream<char>::operator<< (D.45833, i);
  std::operator<< <std::char_traits<char> > (D.45834, ") ");
  D.45835 = 1;
  return D.45835;
}


int {anonymous}::foo(int) (int i)
{
  struct basic_ostream & D.45839;
  struct basic_ostream & D.45840;
  int D.45841;

  D.45839 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.45840 = std::basic_ostream<char>::operator<< (D.45839, i);
  std::operator<< <std::char_traits<char> > (D.45840, ") ");
  D.45841 = 1;
  return D.45841;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun1(T_obj*, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = int; T_return = int; T_obj = {anonymous}::A; T_obj2 = {anonymous}::A] (struct A * _A_obj, struct 
{
  int A::<T6fdd> (struct A *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<int, {anonymous}::A, int>::bound_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = int; T_obj = {anonymous}::A; T_arg1 = int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = int ({anonymous}::A::*)(int)] (struct bound_mem_functor1 * const this, struct A * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.45847;
  struct limit_reference * D.45848;

  D.45847 = &this->D.39936;
  sigc::mem_functor1<int, {anonymous}::A, int>::mem_functor1 (D.45847, _A_func);
  D.45848 = &this->obj_;
  sigc::limit_reference<{anonymous}::A, true>::limit_reference (D.45848, _A_obj);
}


sigc::mem_functor1<T_arg1, T_return, T_obj>::mem_functor1(sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type) [with T_return = int; T_obj = {anonymous}::A; T_arg1 = int; sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type = int ({anonymous}::A::*)(int)] (struct mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::functor_base::functor_base() (struct functor_base * const this)
{

}


sigc::limit_reference<T_type, true>::limit_reference(T_type&) [with T_type = {anonymous}::A] (struct limit_reference * const this, struct A & _A_target)
{
  struct trackable * D.45849;

  D.45849 = &_A_target->D.39362;
  this->visited = D.45849;
  this->invoked = _A_target;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>; T_return = int; T_arg1 = int] (struct slot * const this, const struct bound_mem_functor1 & _A_func)
{
  struct slot1 * D.45850;

  D.45850 = &this->D.39484;
  sigc::slot1<int, int>::slot1<sigc::bound_mem_functor1<int, {anonymous}::A, int> > (D.45850, _A_func);
  try
    {

    }
  catch
    {
      D.45850 = &this->D.39484;
      sigc::slot1<int, int>::~slot1 (D.45850);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct bound_mem_functor1 & _A_func)
{
  void * D.42154;
  struct slot_base * D.45851;
  struct rep_type * D.45852;
  void * (*<T1711>) (void *) D.45853;

  D.42154 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::typed_slot_rep (D.42154, _A_func);
    }
  catch
    {
      operator delete (D.42154);
    }
  D.45851 = &this->D.39442;
  sigc::slot_base::slot_base (D.45851, D.42154);
  try
    {
      D.45852 = this->D.39442.rep_;
      D.45853 = sigc::internal::slot_call1<sigc::bound_mem_functor1<int, {anonymous}::A, int>, int, int>::address ();
      D.45852->call_ = D.45853;
    }
  catch
    {
      D.45851 = &this->D.39442;
      sigc::slot_base::~slot_base (D.45851);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (struct typed_slot_rep * const this, const struct bound_mem_functor1 & functor)
{
  struct slot_rep * D.45856;
  struct adaptor_type * D.45857;
  struct slot_do_bind D.43916;

  D.45856 = &this->D.42142;
  sigc::internal::slot_rep::slot_rep (D.45856, 0B, destroy, dup);
  try
    {
      D.45857 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::adaptor_functor (D.45857, functor);
      D.45857 = &this->functor_;
      D.45856 = &this->D.42142;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43916, D.45856);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&D.43916, D.45857);
        }
      finally
        {
          D.43916 = {CLOBBER};
        }
    }
  catch
    {
      D.45856 = &this->D.42142;
      sigc::internal::slot_rep::~slot_rep (D.45856);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (void * data)
{
  void * D.45860;
  void * D.44322;
  struct slot_rep * a_rep;

  a_rep = data;
  D.44322 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::typed_slot_rep (D.44322, a_rep);
    }
  catch
    {
      operator delete (D.44322);
    }
  D.45860 = D.44322;
  return D.45860;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.45864;
  struct slot_rep * D.45865;
  struct adaptor_type * D.45866;
  struct slot_do_bind D.45034;

  D.45864 = cl->D.42142.call_;
  D.45865 = &this->D.42142;
  sigc::internal::slot_rep::slot_rep (D.45865, D.45864, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.45866 = &this->functor_;
      D.45865 = &this->D.42142;
      sigc::internal::slot_do_bind::slot_do_bind (&D.45034, D.45865);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&D.45034, D.45866);
        }
      finally
        {
          D.45034 = {CLOBBER};
        }
    }
  catch
    {
      D.45865 = &this->D.42142;
      sigc::internal::slot_rep::~slot_rep (D.45865);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (void * data)
{
  struct adaptor_type * D.45869;
  struct slot_do_unbind D.44307;
  void * D.45870;
  struct self * self_;

  self_ = data;
  self_->D.42142.call_ = 0B;
  self_->D.42142.destroy_ = 0B;
  D.45869 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.44307, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&D.44307, D.45869);
    }
  finally
    {
      D.44307 = {CLOBBER};
    }
  D.45870 = 0B;
  return D.45870;
}


sigc::internal::slot_do_unbind::slot_do_unbind(sigc::internal::slot_rep*) (struct slot_do_unbind * const this, struct slot_rep * rep)
{
  this->rep_ = rep;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


sigc::internal::limit_derived_target<T_target*, T_action>::limit_derived_target(const T_action&) [with T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (struct limit_derived_target * const this, const struct slot_do_unbind & _A_action)
{
  this->action_ = *_A_action;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.45874;

  D.45874 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor1<int, {anonymous}::A, int> > (_A_action, D.45874);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = int; T_obj = {anonymous}::A; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.45875;

  D.45875 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<{anonymous}::A, true> > (_A_action, D.45875);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::limit_reference<{anonymous}::A, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::A, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = {anonymous}::A; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.45876;

  D.45876 = sigc::limit_reference<{anonymous}::A, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::trackable> (_A_action, D.45876);
}


const sigc::trackable& sigc::limit_reference<T_type, true>::visit() const [with T_type = {anonymous}::A] (const struct limit_reference * const this)
{
  const struct trackable & D.45877;

  D.45877 = this->visited;
  return D.45877;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::visitor<sigc::trackable>::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::trackable> (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::trackable; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct trackable & _A_type)
{
  sigc::internal::with_type_pointer<true, sigc::trackable, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_unbind * D.45879;

  D.45879 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.45879, _A_type);
}


void sigc::internal::slot_do_unbind::operator()(const sigc::trackable*) const (const struct slot_do_unbind * const this, const struct trackable * t)
{
  struct slot_rep * D.45880;

  D.45880 = this->rep_;
  sigc::trackable::remove_destroy_notify_callback (t, D.45880);
}


sigc::internal::slot_rep::slot_rep(sigc::internal::hook, sigc::internal::hook, sigc::internal::hook) (struct slot_rep * const this, void * (*hook) (void *) call__, void * (*hook) (void *) destroy__, void * (*hook) (void *) dup__)
{
  struct trackable * D.45881;

  D.45881 = &this->D.33436;
  sigc::trackable::trackable (D.45881);
  try
    {
      this->call_ = call__;
      this->destroy_ = destroy__;
      this->dup_ = dup__;
      this->cleanup_ = 0B;
      this->parent_ = 0B;
    }
  catch
    {
      D.45881 = &this->D.33436;
      sigc::trackable::~trackable (D.45881);
    }
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (struct adaptor_functor * const this, const struct bound_mem_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


sigc::adaptor_base::adaptor_base() (struct adaptor_base * const this)
{
  sigc::functor_base::functor_base (this);
}


sigc::internal::slot_do_bind::slot_do_bind(sigc::internal::slot_rep*) (struct slot_do_bind * const this, struct slot_rep * rep)
{
  this->rep_ = rep;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


sigc::internal::limit_derived_target<T_target*, T_action>::limit_derived_target(const T_action&) [with T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (struct limit_derived_target * const this, const struct slot_do_bind & _A_action)
{
  this->action_ = *_A_action;
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.45883;

  D.45883 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor1<int, {anonymous}::A, int> > (_A_action, D.45883);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = int; T_obj = {anonymous}::A; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.45884;

  D.45884 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<{anonymous}::A, true> > (_A_action, D.45884);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::limit_reference<{anonymous}::A, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::A, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = {anonymous}::A; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.45885;

  D.45885 = sigc::limit_reference<{anonymous}::A, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::trackable> (_A_action, D.45885);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::visitor<sigc::trackable>::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::trackable] (const struct limit_derived_target & _A_action, const struct trackable & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::trackable> (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::trackable; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct trackable & _A_type)
{
  sigc::internal::with_type_pointer<true, sigc::trackable, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::trackable; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct trackable & _A_type, const struct limit_derived_target & _A_action)
{
  const struct slot_do_bind * D.45886;

  D.45886 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.45886, _A_type);
}


void sigc::internal::slot_do_bind::operator()(const sigc::trackable*) const (const struct slot_do_bind * const this, const struct trackable * t)
{
  struct slot_rep * D.45887;

  D.45887 = this->rep_;
  sigc::trackable::add_destroy_notify_callback (t, D.45887, notify);
}


sigc::internal::slot_rep::~slot_rep() (struct slot_rep * const this)
{
  struct trackable * D.45888;

  {
    try
      {
        try
          {
            sigc::internal::slot_rep::destroy (this);
          }
        finally
          {
            D.45888 = &this->D.33436;
            sigc::trackable::~trackable (D.45888);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.33450>:
}


void sigc::internal::slot_rep::destroy() (struct slot_rep * const this)
{
  void * (*<T1711>) (void *) D.45891;

  D.45891 = this->destroy_;
  if (D.45891 != 0B) goto <D.45892>; else goto <D.45893>;
  <D.45892>:
  D.45891 = this->destroy_;
  D.45891 (this);
  goto <D.45894>;
  <D.45893>:
  <D.45894>:
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>; T_return = int; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.45895;

  D.45895 = call_it;
  return D.45895;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>; T_return = int; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  int D.45897;
  struct adaptor_type * D.45898;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.45898 = &typed_rep->functor_;
  D.45897 = sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::operator()<const int&> (D.45898, a_1);
  return D.45897;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::bound_mem_functor1<int, {anonymous}::A, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.45901;
  struct bound_mem_functor1 * D.45902;

  D.45902 = &this->functor_;
  D.45901 = sigc::bound_mem_functor1<int, {anonymous}::A, int>::operator() (D.45902, _A_arg1);
  return D.45901;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = int; T_obj = {anonymous}::A; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  int D.45905;
  const struct limit_reference * D.45906;
  struct A & D.45907;
  int A::<T6fdd> (struct A *, int) * iftmp.5;
  int A::<T6fdd> (struct A *, int) * D.45909;
  long int D.45910;
  long int D.45911;
  long int D.45915;
  sizetype D.45916;
  struct A * D.45917;
  int (*__vtbl_ptr_type) () * D.45918;
  long int D.45919;
  sizetype D.45920;
  int (*__vtbl_ptr_type) () * D.45921;
  int D.45922;

  D.45906 = &this->obj_;
  D.45907 = sigc::limit_reference<{anonymous}::A, true>::invoke (D.45906);
  D.45909 = this->D.39936.func_ptr_.__pfn;
  D.45910 = (long int) D.45909;
  D.45911 = D.45910 & 1;
  if (D.45911 == 0) goto <D.45912>; else goto <D.45913>;
  <D.45912>:
  iftmp.5 = this->D.39936.func_ptr_.__pfn;
  goto <D.45914>;
  <D.45913>:
  D.45915 = this->D.39936.func_ptr_.__delta;
  D.45916 = (sizetype) D.45915;
  D.45917 = D.45907 + D.45916;
  D.45918 = MEM[(int (*__vtbl_ptr_type) () * *)D.45917];
  D.45909 = this->D.39936.func_ptr_.__pfn;
  D.45910 = (long int) D.45909;
  D.45919 = D.45910 + -1;
  D.45920 = (sizetype) D.45919;
  D.45921 = D.45918 + D.45920;
  iftmp.5 = *D.45921;
  <D.45914>:
  D.45922 = *_A_a1;
  D.45915 = this->D.39936.func_ptr_.__delta;
  D.45916 = (sizetype) D.45915;
  D.45917 = D.45907 + D.45916;
  D.45905 = iftmp.5 (D.45917, D.45922);
  return D.45905;
}


T_type& sigc::limit_reference<T_type, true>::invoke() const [with T_type = {anonymous}::A] (const struct limit_reference * const this)
{
  struct A & D.45925;

  D.45925 = this->invoked;
  return D.45925;
}


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = float; T_return = int] (int (*<T7175>) (float) _A_func)
{
  struct pointer_functor1 D.45927;
  struct pointer_functor1 D.40890;

  sigc::pointer_functor1<float, int>::pointer_functor1 (&D.40890, _A_func);
  try
    {
      D.45927 = D.40890;
      return D.45927;
    }
  finally
    {
      D.40890 = {CLOBBER};
    }
}


sigc::pointer_functor1<T_arg1, T_return>::pointer_functor1(sigc::pointer_functor1<T_arg1, T_return>::function_type) [with T_arg1 = float; T_return = int; sigc::pointer_functor1<T_arg1, T_return>::function_type = int (*)(float)] (struct pointer_functor1 * const this, int (*function_type) (float) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor1<float, int>; T_return = int; T_arg1 = int] (struct slot * const this, const struct pointer_functor1 & _A_func)
{
  struct slot1 * D.45930;

  D.45930 = &this->D.39484;
  sigc::slot1<int, int>::slot1<sigc::pointer_functor1<float, int> > (D.45930, _A_func);
  try
    {

    }
  catch
    {
      D.45930 = &this->D.39484;
      sigc::slot1<int, int>::~slot1 (D.45930);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<float, int>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.42651;
  struct slot_base * D.45931;
  struct rep_type * D.45932;
  void * (*<T1711>) (void *) D.45933;

  D.42651 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<float, int> >::typed_slot_rep (D.42651, _A_func);
    }
  catch
    {
      operator delete (D.42651);
    }
  D.45931 = &this->D.39442;
  sigc::slot_base::slot_base (D.45931, D.42651);
  try
    {
      D.45932 = this->D.39442.rep_;
      D.45933 = sigc::internal::slot_call1<sigc::pointer_functor1<float, int>, int, int>::address ();
      D.45932->call_ = D.45933;
    }
  catch
    {
      D.45931 = &this->D.39442;
      sigc::slot_base::~slot_base (D.45931);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::pointer_functor1<float, int>] (struct typed_slot_rep * const this, const struct pointer_functor1 & functor)
{
  struct slot_rep * D.45936;
  struct adaptor_type * D.45937;
  struct slot_do_bind D.43943;

  D.45936 = &this->D.42633;
  sigc::internal::slot_rep::slot_rep (D.45936, 0B, destroy, dup);
  try
    {
      D.45937 = &this->functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<float, int> >::adaptor_functor (D.45937, functor);
      D.45937 = &this->functor_;
      D.45936 = &this->D.42633;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43943, D.45936);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<float, int> > > (&D.43943, D.45937);
        }
      finally
        {
          D.43943 = {CLOBBER};
        }
    }
  catch
    {
      D.45936 = &this->D.42633;
      sigc::internal::slot_rep::~slot_rep (D.45936);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::pointer_functor1<float, int>] (void * data)
{
  void * D.45940;
  void * D.44473;
  struct slot_rep * a_rep;

  a_rep = data;
  D.44473 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<float, int> >::typed_slot_rep (D.44473, a_rep);
    }
  catch
    {
      operator delete (D.44473);
    }
  D.45940 = D.44473;
  return D.45940;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<float, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.45944;
  struct slot_rep * D.45945;
  struct adaptor_type * D.45946;
  struct slot_do_bind D.45071;

  D.45944 = cl->D.42633.call_;
  D.45945 = &this->D.42633;
  sigc::internal::slot_rep::slot_rep (D.45945, D.45944, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.45946 = &this->functor_;
      D.45945 = &this->D.42633;
      sigc::internal::slot_do_bind::slot_do_bind (&D.45071, D.45945);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<float, int> > > (&D.45071, D.45946);
        }
      finally
        {
          D.45071 = {CLOBBER};
        }
    }
  catch
    {
      D.45945 = &this->D.42633;
      sigc::internal::slot_rep::~slot_rep (D.45945);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::pointer_functor1<float, int>] (void * data)
{
  struct adaptor_type * D.45949;
  struct slot_do_unbind D.44458;
  void * D.45950;
  struct self * self_;

  self_ = data;
  self_->D.42633.call_ = 0B;
  self_->D.42633.destroy_ = 0B;
  D.45949 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.44458, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor1<float, int> > > (&D.44458, D.45949);
    }
  finally
    {
      D.44458 = {CLOBBER};
    }
  D.45950 = 0B;
  return D.45950;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<float, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::pointer_functor1<float, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<float, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<float, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.45954;

  D.45954 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::pointer_functor1<float, int> > (_A_action, D.45954);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<float, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::pointer_functor1<float, int> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::pointer_functor1<float, int>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct pointer_functor1 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor1<float, int>, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<float, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.45538, const struct limit_derived_target & D.45539)
{
  GIMPLE_NOP
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::pointer_functor1<float, int>] (struct adaptor_functor * const this, const struct pointer_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<float, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::pointer_functor1<float, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<float, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<float, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.45956;

  D.45956 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::pointer_functor1<float, int> > (_A_action, D.45956);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<float, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<float, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::pointer_functor1<float, int> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::pointer_functor1<float, int>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct pointer_functor1 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor1<float, int>, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<float, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.45488, const struct limit_derived_target & D.45489)
{
  GIMPLE_NOP
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<float, int>; T_return = int; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.45957;

  D.45957 = call_it;
  return D.45957;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::pointer_functor1<float, int>; T_return = int; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  int D.45959;
  struct adaptor_type * D.45960;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.45960 = &typed_rep->functor_;
  D.45959 = sigc::adaptor_functor<sigc::pointer_functor1<float, int> >::operator()<const int&> (D.45960, a_1);
  return D.45959;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::pointer_functor1<float, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.45963;
  const float D.45090;
  int D.45964;
  float D.45965;
  struct pointer_functor1 * D.45966;

  D.45964 = *_A_arg1;
  D.45965 = (float) D.45964;
  D.45090 = D.45965;
  try
    {
      D.45966 = &this->functor_;
      D.45963 = sigc::pointer_functor1<float, int>::operator() (D.45966, &D.45090);
      return D.45963;
    }
  finally
    {
      D.45090 = {CLOBBER};
    }
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = float; T_return = int; typename sigc::type_trait<T_base>::take = const float&] (const struct pointer_functor1 * const this, const float & _A_a1)
{
  int D.45971;
  int (*<T7175>) (float) D.45972;
  float D.45973;

  D.45972 = this->func_ptr_;
  D.45973 = *_A_a1;
  D.45971 = D.45972 (D.45973);
  return D.45971;
}


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, long unsigned int __n)
{
  struct __ostream_type & D.45976;

  D.45976 = std::basic_ostream<char>::_M_insert<long unsigned int> (this, __n);
  return D.45976;
}


{anonymous}::A::A() (struct A * const this)
{
  struct trackable * D.45981;

  D.45981 = &this->D.39362;
  sigc::trackable::trackable (D.45981);
  try
    {

    }
  catch
    {
      D.45981 = &this->D.39362;
      sigc::trackable::~trackable (D.45981);
    }
}


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::signal() [with T_return = void; T_arg1 = std::basic_string<char>&] (struct signal * const this)
{
  struct signal1 * D.45982;

  D.45982 = &this->D.40270;
  sigc::signal1<void, std::basic_string<char>&, sigc::nil>::signal1 (D.45982);
  try
    {

    }
  catch
    {
      D.45982 = &this->D.40270;
      sigc::signal1<void, std::basic_string<char>&, sigc::nil>::~signal1 (D.45982);
    }
}


sigc::signal1<T_return, T_arg1, T_accumulator>::signal1() [with T_return = void; T_arg1 = std::basic_string<char>&; T_accumulator = sigc::nil] (struct signal1 * const this)
{
  struct signal_base * D.45983;

  D.45983 = &this->D.40245;
  sigc::signal_base::signal_base (D.45983);
  try
    {

    }
  catch
    {
      D.45983 = &this->D.40245;
      sigc::signal_base::~signal_base (D.45983);
    }
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = std::basic_string<char>&; T_return = void; T_obj = {anonymous}::A; T_obj2 = {anonymous}::A] (struct A * _A_obj, struct 
{
  void A::<T6fe3> (struct A *, struct basic_string &) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>::bound_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::A; T_arg1 = std::basic_string<char>&; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::A::*)(std::basic_string<char>&)] (struct bound_mem_functor1 * const this, struct A * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.45986;
  struct limit_reference * D.45987;

  D.45986 = &this->D.40378;
  sigc::mem_functor1<void, {anonymous}::A, std::basic_string<char>&>::mem_functor1 (D.45986, _A_func);
  D.45987 = &this->obj_;
  sigc::limit_reference<{anonymous}::A, true>::limit_reference (D.45987, _A_obj);
}


sigc::mem_functor1<T_arg1, T_return, T_obj>::mem_functor1(sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type) [with T_return = void; T_obj = {anonymous}::A; T_arg1 = std::basic_string<char>&; sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type = void ({anonymous}::A::*)(std::basic_string<char>&)] (struct mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>; T_return = void; T_arg1 = std::basic_string<char>&] (struct slot * const this, const struct bound_mem_functor1 & _A_func)
{
  struct slot1 * D.45988;

  D.45988 = &this->D.40121;
  sigc::slot1<void, std::basic_string<char>&>::slot1<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > (D.45988, _A_func);
  try
    {

    }
  catch
    {
      D.45988 = &this->D.40121;
      sigc::slot1<void, std::basic_string<char>&>::~slot1 (D.45988);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>; T_return = void; T_arg1 = std::basic_string<char>&] (struct slot1 * const this, const struct bound_mem_functor1 & _A_func)
{
  void * D.43154;
  struct slot_base * D.45989;
  struct rep_type * D.45990;
  void * (*<T1711>) (void *) D.45991;

  D.43154 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::typed_slot_rep (D.43154, _A_func);
    }
  catch
    {
      operator delete (D.43154);
    }
  D.45989 = &this->D.40079;
  sigc::slot_base::slot_base (D.45989, D.43154);
  try
    {
      D.45990 = this->D.40079.rep_;
      D.45991 = sigc::internal::slot_call1<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>, void, std::basic_string<char>&>::address ();
      D.45990->call_ = D.45991;
    }
  catch
    {
      D.45989 = &this->D.40079;
      sigc::slot_base::~slot_base (D.45989);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (struct typed_slot_rep * const this, const struct bound_mem_functor1 & functor)
{
  struct slot_rep * D.45994;
  struct adaptor_type * D.45995;
  struct slot_do_bind D.43973;

  D.45994 = &this->D.43142;
  sigc::internal::slot_rep::slot_rep (D.45994, 0B, destroy, dup);
  try
    {
      D.45995 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::adaptor_functor (D.45995, functor);
      D.45995 = &this->functor_;
      D.45994 = &this->D.43142;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43973, D.45994);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > > (&D.43973, D.45995);
        }
      finally
        {
          D.43973 = {CLOBBER};
        }
    }
  catch
    {
      D.45994 = &this->D.43142;
      sigc::internal::slot_rep::~slot_rep (D.45994);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (void * data)
{
  void * D.45998;
  void * D.44624;
  struct slot_rep * a_rep;

  a_rep = data;
  D.44624 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::typed_slot_rep (D.44624, a_rep);
    }
  catch
    {
      operator delete (D.44624);
    }
  D.45998 = D.44624;
  return D.45998;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.46002;
  struct slot_rep * D.46003;
  struct adaptor_type * D.46004;
  struct slot_do_bind D.45128;

  D.46002 = cl->D.43142.call_;
  D.46003 = &this->D.43142;
  sigc::internal::slot_rep::slot_rep (D.46003, D.46002, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.46004 = &this->functor_;
      D.46003 = &this->D.43142;
      sigc::internal::slot_do_bind::slot_do_bind (&D.45128, D.46003);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > > (&D.45128, D.46004);
        }
      finally
        {
          D.45128 = {CLOBBER};
        }
    }
  catch
    {
      D.46003 = &this->D.43142;
      sigc::internal::slot_rep::~slot_rep (D.46003);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (void * data)
{
  struct adaptor_type * D.46007;
  struct slot_do_unbind D.44609;
  void * D.46008;
  struct self * self_;

  self_ = data;
  self_->D.43142.call_ = 0B;
  self_->D.43142.destroy_ = 0B;
  D.46007 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.44609, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > > (&D.44609, D.46007);
    }
  finally
    {
      D.44609 = {CLOBBER};
    }
  D.46008 = 0B;
  return D.46008;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.46012;

  D.46012 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > (_A_action, D.46012);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_obj = {anonymous}::A; T_arg1 = std::basic_string<char>&] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.46013;

  D.46013 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<{anonymous}::A, true> > (_A_action, D.46013);
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (struct adaptor_functor * const this, const struct bound_mem_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.46015;

  D.46015 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> > (_A_action, D.46015);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_obj = {anonymous}::A; T_arg1 = std::basic_string<char>&] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.46016;

  D.46016 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<{anonymous}::A, true> > (_A_action, D.46016);
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>; T_return = void; T_arg1 = std::basic_string<char>&; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.46017;

  D.46017 = call_it;
  return D.46017;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>; T_return = void; T_arg1 = std::basic_string<char>&; typename sigc::type_trait<T_arg3>::take = std::basic_string<char>&] (struct slot_rep * rep, struct basic_string & a_1)
{
  struct adaptor_type * D.46019;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.46019 = &typed_rep->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&> >::operator()<std::basic_string<char>&> (D.46019, a_1);
  return;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = std::basic_string<char>&; T_functor = sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, struct basic_string & _A_arg1)
{
  struct bound_mem_functor1 * D.46021;

  D.46021 = &this->functor_;
  sigc::bound_mem_functor1<void, {anonymous}::A, std::basic_string<char>&>::operator() (D.46021, _A_arg1);
  return;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::A; T_arg1 = std::basic_string<char>&; typename sigc::type_trait<T_arg3>::take = std::basic_string<char>&] (const struct bound_mem_functor1 * const this, struct basic_string & _A_a1)
{
  const struct limit_reference * D.46023;
  struct A & D.46024;
  void A::<T6fe3> (struct A *, struct basic_string &) * iftmp.6;
  void A::<T6fe3> (struct A *, struct basic_string &) * D.46026;
  long int D.46027;
  long int D.46028;
  long int D.46032;
  sizetype D.46033;
  struct A * D.46034;
  int (*__vtbl_ptr_type) () * D.46035;
  long int D.46036;
  sizetype D.46037;
  int (*__vtbl_ptr_type) () * D.46038;

  D.46023 = &this->obj_;
  D.46024 = sigc::limit_reference<{anonymous}::A, true>::invoke (D.46023);
  D.46026 = this->D.40378.func_ptr_.__pfn;
  D.46027 = (long int) D.46026;
  D.46028 = D.46027 & 1;
  if (D.46028 == 0) goto <D.46029>; else goto <D.46030>;
  <D.46029>:
  iftmp.6 = this->D.40378.func_ptr_.__pfn;
  goto <D.46031>;
  <D.46030>:
  D.46032 = this->D.40378.func_ptr_.__delta;
  D.46033 = (sizetype) D.46032;
  D.46034 = D.46024 + D.46033;
  D.46035 = MEM[(int (*__vtbl_ptr_type) () * *)D.46034];
  D.46026 = this->D.40378.func_ptr_.__pfn;
  D.46027 = (long int) D.46026;
  D.46036 = D.46027 + -1;
  D.46037 = (sizetype) D.46036;
  D.46038 = D.46035 + D.46037;
  iftmp.6 = *D.46038;
  <D.46031>:
  D.46032 = this->D.40378.func_ptr_.__delta;
  D.46033 = (sizetype) D.46032;
  D.46034 = D.46024 + D.46033;
  iftmp.6 (D.46034, _A_a1);
  return;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = void; T_arg1 = std::basic_string<char>&; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.46040;
  struct iterator D.40947;
  struct iterator_type D.40937;
  const struct slot_base * D.46041;
  struct signal_base * D.46042;

  D.46041 = &slot_->D.40121.D.40079;
  D.46042 = &this->D.40245;
  D.40937 = sigc::signal_base::connect (D.46042, D.46041);
  try
    {
      sigc::slot_iterator<sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.40947, &D.40937);
      try
        {
          D.46040 = D.40947;
          return D.46040;
        }
      finally
        {
          D.40947 = {CLOBBER};
        }
    }
  finally
    {
      D.40937 = {CLOBBER};
    }
}


sigc::slot_iterator<T_slot>::slot_iterator(const iterator_type&) [with T_slot = sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; sigc::slot_iterator<T_slot>::iterator_type = std::_List_iterator<sigc::slot_base>] (struct slot_iterator * const this, const struct iterator_type & i)
{
  this->i_ = MEM[(const struct _List_iterator &)i];
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::operator()(typename sigc::type_trait<T_derived>::take) const [with T_return = void; T_arg1 = std::basic_string<char>&; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = void; typename sigc::type_trait<T_derived>::take = std::basic_string<char>&] (const struct signal1 * const this, struct basic_string & _A_a1)
{
  sigc::signal1<void, std::basic_string<char>&, sigc::nil>::emit (this, _A_a1);
  return;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::emit(typename sigc::type_trait<T_derived>::take) const [with T_return = void; T_arg1 = std::basic_string<char>&; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = void; typename sigc::type_trait<T_derived>::take = std::basic_string<char>&] (const struct signal1 * const this, struct basic_string & _A_a1)
{
  struct signal_impl * D.46047;

  D.46047 = this->D.40245.impl_;
  sigc::internal::signal_emit1<void, std::basic_string<char>&, sigc::nil>::emit (D.46047, _A_a1);
  return;
}


static sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_base>::take) [with T_arg1 = std::basic_string<char>&; sigc::internal::signal_emit1<void, T_arg1, sigc::nil>::result_type = void; typename sigc::type_trait<T_base>::take = std::basic_string<char>&] (struct signal_impl * impl, struct basic_string & _A_a1)
{
  bool retval.7;
  bool iftmp.8;
  struct list * D.46055;
  bool D.46056;
  struct iterator D.43980;
  bool retval.9;
  bool iftmp.10;
  const struct slot_base * D.46064;
  bool D.46065;
  const struct slot_base * D.46067;
  bool D.46068;
  const struct slot_base * D.46071;
  struct rep_type * D.46072;
  void * (*<T1711>) (void *) D.46073;
  const struct slot_base * D.46074;
  struct rep_type * D.46075;
  bool retval.11;
  const struct _Self D.43983;
  struct iterator D.43982;
  struct signal_exec exec;
  struct temp_slot_list slots;

  try
    {
      if (impl == 0B) goto <D.46051>; else goto <D.46054>;
      <D.46054>:
      D.46055 = &impl->slots_;
      D.46056 = std::list<sigc::slot_base>::empty (D.46055);
      if (D.46056 != 0) goto <D.46051>; else goto <D.46052>;
      <D.46051>:
      iftmp.8 = 1;
      goto <D.46053>;
      <D.46052>:
      iftmp.8 = 0;
      <D.46053>:
      retval.7 = iftmp.8;
      if (retval.7 != 0) goto <D.46057>; else goto <D.46058>;
      <D.46057>:
      return;
      <D.46058>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.46055 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.46055);
          try
            {
              {
                struct iterator_type it;

                try
                  {
                    D.43980 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.43980);
                      }
                    finally
                      {
                        D.43980 = {CLOBBER};
                      }
                    goto <D.43987>;
                    <D.43986>:
                    D.46064 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46065 = sigc::slot_base::empty (D.46064);
                    if (D.46065 != 0) goto <D.46061>; else goto <D.46066>;
                    <D.46066>:
                    D.46067 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46068 = sigc::slot_base::blocked (D.46067);
                    if (D.46068 != 0) goto <D.46061>; else goto <D.46062>;
                    <D.46061>:
                    iftmp.10 = 1;
                    goto <D.46063>;
                    <D.46062>:
                    iftmp.10 = 0;
                    <D.46063>:
                    retval.9 = iftmp.10;
                    if (retval.9 != 0) goto <D.46069>; else goto <D.46070>;
                    <D.46069>:
                    goto <D.43985>;
                    <D.46070>:
                    D.46071 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46072 = D.46071->rep_;
                    D.46073 = D.46072->call_;
                    D.46074 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46075 = D.46074->rep_;
                    D.46073 (D.46075, _A_a1);
                    <D.43985>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.43987>:
                    D.43982 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.43983, &D.43982);
                        try
                          {
                            retval.11 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.43983);
                          }
                        finally
                          {
                            D.43983 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43982 = {CLOBBER};
                      }
                    if (retval.11 != 0) goto <D.43986>; else goto <D.43984>;
                    <D.43984>:
                  }
                finally
                  {
                    it = {CLOBBER};
                  }
              }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
      slots = {CLOBBER};
    }
}


bool std::list<_Tp, _Alloc>::empty() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (const struct list * const this)
{
  bool D.46088;
  struct _List_node_base * D.46089;
  const struct _List_node_base * D.46090;

  D.46089 = this->D.35179._M_impl._M_node._M_next;
  D.46090 = &this->D.35179._M_impl._M_node;
  D.46088 = D.46089 == D.46090;
  return D.46088;
}


sigc::internal::signal_exec::signal_exec(const sigc::internal::signal_impl*) (struct signal_exec * const this, const struct signal_impl * sig)
{
  struct signal_impl * D.46092;

  this->sig_ = sig;
  D.46092 = this->sig_;
  sigc::internal::signal_impl::reference_exec (D.46092);
}


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.46093;
  unsigned short D.46094;
  unsigned short D.46095;
  short int D.46096;
  short int D.46097;
  unsigned short D.46098;
  unsigned short D.46099;
  short int D.46100;

  D.46093 = this->ref_count_;
  D.46094 = (unsigned short) D.46093;
  D.46095 = D.46094 + 1;
  D.46096 = (short int) D.46095;
  this->ref_count_ = D.46096;
  D.46097 = this->exec_count_;
  D.46098 = (unsigned short) D.46097;
  D.46099 = D.46098 + 1;
  D.46100 = (short int) D.46099;
  this->exec_count_ = D.46100;
}


sigc::internal::temp_slot_list::temp_slot_list(sigc::internal::temp_slot_list::slot_list&) (struct temp_slot_list * const this, struct slot_list & slots)
{
  struct iterator * D.46101;
  struct slot_base D.35400;
  struct slot_list & D.46102;
  struct _List_iterator D.46103;

  this->slots_ = slots;
  D.46101 = &this->placeholder;
  std::_List_iterator<sigc::slot_base>::_List_iterator (D.46101);
  sigc::slot_base::slot_base (&D.35400);
  try
    {
      D.46102 = this->slots_;
      D.46103 = std::list<sigc::slot_base>::end (D.46102);
      D.46102 = this->slots_;
      this->placeholder = std::list<sigc::slot_base>::insert (D.46102, D.46103, &D.35400);
    }
  finally
    {
      sigc::slot_base::~slot_base (&D.35400);
      D.35400 = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_List_iterator() [with _Tp = sigc::slot_base] (struct _List_iterator * const this)
{
  this->_M_node = 0B;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::end() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this)
{
  struct iterator D.46105;
  struct iterator D.40709;
  struct _List_node_base * D.46106;

  D.46106 = &this->D.35179._M_impl._M_node;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.40709, D.46106);
  try
    {
      D.46105 = D.40709;
      return D.46105;
    }
  finally
    {
      D.40709 = {CLOBBER};
    }
}


std::_List_iterator<_Tp>::_List_iterator(std::__detail::_List_node_base*) [with _Tp = sigc::slot_base] (struct _List_iterator * const this, struct _List_node_base * __x)
{
  this->_M_node = __x;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, struct iterator __position, const struct value_type & __x)
{
  struct _Self D.40717;
  struct _List_node_base * D.46109;
  struct _List_node_base * D.46110;
  struct iterator D.46111;
  struct iterator D.40718;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.40717 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.46109 = D.40717._M_node;
  D.46110 = &__tmp->D.40714;
  std::__detail::_List_node_base::_M_hook (D.46110, D.46109);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.40718, __tmp);
  try
    {
      D.46111 = D.40718;
      return D.46111;
    }
  finally
    {
      D.40718 = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.46115;
  struct slot_base * D.46116;
  struct slot_base * D.46117;
  struct _Tp_alloc_type D.41030;
  void * D.46118;
  struct _Node * D.46119;
  struct _Node * __p;

  D.46115 = &this->D.35179;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.46115);
  try
    {
      D.46116 = &__p->_M_data;
      D.46117 = std::__addressof<sigc::slot_base> (D.46116);
      D.46115 = &this->D.35179;
      D.41030 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.46115); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.41030, D.46117, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.41030);
          D.41030 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.46118 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.46118);
              D.46115 = &this->D.35179;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.46115, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.46119 = __p;
  return D.46119;
}


std::_List_node<_Tp>* std::_List_base<_Tp, _Alloc>::_M_get_node() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this)
{
  struct _List_node * D.46126;
  struct _List_impl * D.46127;

  D.46127 = &this->_M_impl;
  D.46126 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::allocate (D.46127, 1, 0B);
  return D.46126;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::pointer = std::_List_node<sigc::slot_base>*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.34672)
{
  bool retval.12;
  long unsigned int D.46131;
  struct _List_node * D.46134;
  long unsigned int D.46135;

  D.46131 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.12 = D.46131 < __n;
  if (retval.12 != 0) goto <D.46132>; else goto <D.46133>;
  <D.46132>:
  std::__throw_bad_alloc ();
  <D.46133>:
  D.46135 = __n * 32;
  D.46134 = operator new (D.46135);
  return D.46134;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = std::_List_node<sigc::slot_base>; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.46138;
  void * D.46139;

  try
    {
      D.46138 = 576460752303423487;
      return D.46138;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.46139 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.46139);
          
        }
    }
}


_Tp* std::__addressof(_Tp&) [with _Tp = sigc::slot_base] (struct slot_base & __r)
{
  struct slot_base * D.46141;

  D.46141 = __r;
  return D.46141;
}


std::_List_base<_Tp, _Alloc>::_Tp_alloc_type std::_List_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::_List_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<sigc::slot_base>] (const struct _List_base * const this)
{
  const struct _Node_alloc_type & D.46144;

  D.46144 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Node_allocator (this);
  std::allocator<sigc::slot_base>::allocator<std::_List_node<sigc::slot_base> > (<retval>, D.46144);
  return <retval>;
}


const _Node_alloc_type& std::_List_base<_Tp, _Alloc>::_M_get_Node_allocator() const [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::_List_base<_Tp, _Alloc>::_Node_alloc_type = std::allocator<std::_List_node<sigc::slot_base> >] (const struct _List_base * const this)
{
  const struct _Node_alloc_type & D.46146;

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


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator<_Tp1>&) [with _Tp1 = std::_List_node<sigc::slot_base>; _Tp = sigc::slot_base] (struct allocator * const this, const struct allocator & D.43741)
{
  void * D.46148;

  try
    {
      {
        __gnu_cxx::new_allocator<sigc::slot_base>::new_allocator (this);
        try
          {

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


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

  try
    {
      {

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


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = sigc::slot_base; __gnu_cxx::new_allocator<_Tp>::pointer = sigc::slot_base*] (struct new_allocator * const this, struct slot_base * __p, const struct slot_base & __val)
{
  void * D.43779;
  void * D.43780;
  struct slot_base * iftmp.13;

  D.43779 = __p;
  D.43780 = operator new (16, D.43779);
  if (D.43780 != 0B) goto <D.46151>; else goto <D.46152>;
  <D.46151>:
  try
    {
      sigc::slot_base::slot_base (D.43780, __val);
    }
  catch
    {
      operator delete (D.43780, D.43779);
    }
  iftmp.13 = D.43780;
  goto <D.46153>;
  <D.46152>:
  iftmp.13 = D.43780;
  <D.46153>:
}


void* operator new(std::size_t, void*) (size_t D.6125, void * __p)
{
  void * D.46155;
  void * D.46156;

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


void operator delete(void*, void*) (void * D.6133, void * D.6134)
{
  void * D.46158;

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<sigc::slot_base>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.43756>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.46159 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.46159);
          
        }
    }
}


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

  try
    {
      {
        try
          {

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


void std::_List_base<_Tp, _Alloc>::_M_put_node(std::_List_node<_Tp>*) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this, struct _List_node * __p)
{
  struct _List_impl * D.46161;

  D.46161 = &this->_M_impl;
  __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::deallocate (D.46161, __p, 1);
}


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


std::_List_iterator<_Tp>::_Self std::_List_iterator<_Tp>::_M_const_cast() const [with _Tp = sigc::slot_base; std::_List_iterator<_Tp>::_Self = std::_List_iterator<sigc::slot_base>] (const struct _List_iterator * const this)
{
  struct _Self D.46162;

  D.46162 = *this;
  return D.46162;
}


sigc::internal::temp_slot_list::iterator sigc::internal::temp_slot_list::begin() (struct temp_slot_list * const this)
{
  struct iterator D.46164;
  struct slot_list & D.46165;

  D.46165 = this->slots_;
  D.46164 = std::list<sigc::slot_base>::begin (D.46165);
  return D.46164;
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::begin() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this)
{
  struct iterator D.46167;
  struct iterator D.40725;
  struct _List_node_base * D.46168;

  D.46168 = this->D.35179._M_impl._M_node._M_next;
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.40725, D.46168);
  try
    {
      D.46167 = D.40725;
      return D.46167;
    }
  finally
    {
      D.40725 = {CLOBBER};
    }
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.46171;
  bool iftmp.14;
  struct rep_type * D.46176;
  void * (*<T1711>) (void *) D.46178;

  D.46176 = this->rep_;
  if (D.46176 == 0B) goto <D.46173>; else goto <D.46177>;
  <D.46177>:
  D.46176 = this->rep_;
  D.46178 = D.46176->call_;
  if (D.46178 == 0B) goto <D.46173>; else goto <D.46174>;
  <D.46173>:
  iftmp.14 = 1;
  goto <D.46175>;
  <D.46174>:
  iftmp.14 = 0;
  <D.46175>:
  D.46171 = iftmp.14;
  return D.46171;
}


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

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


const _Tp* std::_List_const_iterator<_Tp>::operator->() const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::pointer = const sigc::slot_base*] (const struct _List_const_iterator * const this)
{
  const struct slot_base * D.46182;
  const struct _List_node_base * D.46183;
  const struct slot_base * D.46184;

  D.46183 = this->_M_node;
  D.46184 = &MEM[(const struct _Node *)D.46183]._M_data;
  D.46182 = std::__addressof<const sigc::slot_base> (D.46184);
  return D.46182;
}


_Tp* std::__addressof(_Tp&) [with _Tp = const sigc::slot_base] (const struct slot_base & __r)
{
  const struct slot_base * D.46186;

  D.46186 = __r;
  return D.46186;
}


std::_List_const_iterator<_Tp>::_Self& std::_List_const_iterator<_Tp>::operator++() [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::_Self = std::_List_const_iterator<sigc::slot_base>] (struct _List_const_iterator * const this)
{
  const struct _List_node_base * D.46188;
  struct _List_node_base * D.46189;
  struct _Self & D.46190;

  D.46188 = this->_M_node;
  D.46189 = D.46188->_M_next;
  this->_M_node = D.46189;
  D.46190 = this;
  return D.46190;
}


sigc::internal::temp_slot_list::iterator sigc::internal::temp_slot_list::end() (struct temp_slot_list * const this)
{
  struct iterator D.46192;

  D.46192 = this->placeholder;
  return D.46192;
}


std::_List_const_iterator<_Tp>::_List_const_iterator(const iterator&) [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::iterator = std::_List_iterator<sigc::slot_base>] (struct _List_const_iterator * const this, const struct iterator & __x)
{
  struct _List_node_base * D.46194;

  D.46194 = __x->_M_node;
  this->_M_node = D.46194;
}


bool std::_List_const_iterator<_Tp>::operator!=(const _Self&) const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::_Self = std::_List_const_iterator<sigc::slot_base>] (const struct _List_const_iterator * const this, const struct _Self & __x)
{
  bool D.46195;
  const struct _List_node_base * D.46196;
  const struct _List_node_base * D.46197;

  D.46196 = this->_M_node;
  D.46197 = __x->_M_node;
  D.46195 = D.46196 != D.46197;
  return D.46195;
}


sigc::internal::temp_slot_list::~temp_slot_list() (struct temp_slot_list * const this)
{
  struct iterator D.35408;
  struct slot_list & D.46199;

  {
    try
      {
        D.46199 = this->slots_;
        D.35408 = std::list<sigc::slot_base>::erase (D.46199, this->placeholder);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35410>:
}


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.46201;
  struct _List_node_base * D.46202;
  struct _List_iterator D.46203;
  struct iterator D.46204;
  struct iterator __ret;

  try
    {
      D.46201 = __position._M_node;
      D.46202 = D.46201->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.46202);
      D.46203 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.46203);
      D.46204 = __ret;
      return D.46204;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.46208;
  struct slot_base * D.46209;
  struct slot_base * D.46210;
  struct _Tp_alloc_type D.41036;
  struct _List_base * D.46211;
  struct _Node * __n;

  D.46208 = __position._M_node;
  std::__detail::_List_node_base::_M_unhook (D.46208);
  __n = __position._M_node;
  D.46209 = &__n->_M_data;
  D.46210 = std::__addressof<sigc::slot_base> (D.46209);
  D.46211 = &this->D.35179;
  D.41036 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.46211); [return slot optimization]
  try
    {
      __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.41036, D.46210);
    }
  finally
    {
      std::allocator<sigc::slot_base>::~allocator (&D.41036);
      D.41036 = {CLOBBER};
    }
  D.46211 = &this->D.35179;
  std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.46211, __n);
}


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


sigc::internal::signal_exec::~signal_exec() (struct signal_exec * const this)
{
  struct signal_impl * D.46213;

  {
    try
      {
        D.46213 = this->sig_;
        sigc::internal::signal_impl::unreference_exec (D.46213);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35296>:
}


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.15;
  short int D.46216;
  unsigned short D.46217;
  unsigned short D.46218;
  short int D.46219;
  bool retval.16;
  bool iftmp.17;
  short int D.46230;
  unsigned short D.46231;
  unsigned short D.46232;
  short int D.46233;
  bool D.46235;

  D.46216 = this->ref_count_;
  D.46217 = (unsigned short) D.46216;
  D.46218 = D.46217 + 65535;
  D.46219 = (short int) D.46218;
  this->ref_count_ = D.46219;
  D.46216 = this->ref_count_;
  retval.15 = D.46216 == 0;
  if (retval.15 != 0) goto <D.46220>; else goto <D.46221>;
  <D.46220>:
  if (this != 0B) goto <D.46222>; else goto <D.46223>;
  <D.46222>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.46224>;
  <D.46223>:
  <D.46224>:
  goto <D.46225>;
  <D.46221>:
  D.46230 = this->exec_count_;
  D.46231 = (unsigned short) D.46230;
  D.46232 = D.46231 + 65535;
  D.46233 = (short int) D.46232;
  this->exec_count_ = D.46233;
  D.46230 = this->exec_count_;
  if (D.46230 == 0) goto <D.46234>; else goto <D.46228>;
  <D.46234>:
  D.46235 = this->deferred_;
  if (D.46235 != 0) goto <D.46236>; else goto <D.46228>;
  <D.46236>:
  iftmp.17 = 1;
  goto <D.46229>;
  <D.46228>:
  iftmp.17 = 0;
  <D.46229>:
  retval.16 = iftmp.17;
  if (retval.16 != 0) goto <D.46237>; else goto <D.46238>;
  <D.46237>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.46239>;
  <D.46238>:
  <D.46239>:
  <D.46225>:
}


sigc::internal::signal_impl::~signal_impl() (struct signal_impl * const this)
{
  struct list * D.46240;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46240 = &this->slots_;
            std::list<sigc::slot_base>::~list (D.46240);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35262>:
}


std::list<sigc::slot_base>::~list() (struct list * const this)
{
  struct _List_base * D.46242;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46242 = &this->D.35179;
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::~_List_base (D.46242);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.35257>:
}


std::_List_base<_Tp, _Alloc>::~_List_base() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this)
{
  struct _List_impl * D.46244;

  {
    try
      {
        try
          {
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_clear (this);
          }
        finally
          {
            D.46244 = &this->_M_impl;
            std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_List_impl::~_List_impl (D.46244);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40701>:
}


void std::_List_base<_Tp, _Alloc>::_M_clear() [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>] (struct _List_base * const this)
{
  struct slot_base * D.46247;
  struct slot_base * D.46248;
  struct _Tp_alloc_type D.41019;
  struct _List_node_base * D.46249;
  typedef struct _Node _Node;
  struct _Node * __cur;

  __cur = this->_M_impl._M_node._M_next;
  goto <D.41023>;
  <D.41024>:
  {
    struct _Node * __tmp;

    __tmp = __cur;
    __cur = __cur->D.40714._M_next;
    D.46247 = &__tmp->_M_data;
    D.46248 = std::__addressof<sigc::slot_base> (D.46247);
    D.41019 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.41019, D.46248);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.41019);
        D.41019 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.41023>:
  D.46249 = &this->_M_impl._M_node;
  if (D.46249 != __cur) goto <D.41024>; else goto <D.41022>;
  <D.41022>:
}


std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_List_impl::~_List_impl() (struct _List_impl * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<std::_List_node<sigc::slot_base> >::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40696>:
}


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

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.41012>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.46251 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.46251);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = std::_List_node<sigc::slot_base>] (struct new_allocator * const this)
{
  void * D.46252;

  try
    {
      {
        try
          {

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


std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostream & __os, const struct basic_string & __str)
{
  struct basic_ostream & D.46253;
  long unsigned int D.46254;
  long int D.46255;
  const char * D.46256;

  D.46254 = std::basic_string<char>::size (__str);
  D.46255 = (long int) D.46254;
  D.46256 = std::basic_string<char>::data (__str);
  D.46253 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.46256, D.46255);
  return D.46253;
}


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.46261;
  struct _Rep * D.46262;

  D.46262 = std::basic_string<char>::_M_rep (this);
  D.46261 = D.46262->D.11865._M_length;
  return D.46261;
}


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

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


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

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


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

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = int] (int (*<T70d8>) (int) _A_func)
{
  struct pointer_functor1 D.46274;
  struct pointer_functor1 D.40826;

  sigc::pointer_functor1<int, int>::pointer_functor1 (&D.40826, _A_func);
  try
    {
      D.46274 = D.40826;
      return D.46274;
    }
  finally
    {
      D.40826 = {CLOBBER};
    }
}


sigc::pointer_functor1<T_arg1, T_return>::pointer_functor1(sigc::pointer_functor1<T_arg1, T_return>::function_type) [with T_arg1 = int; T_return = int; sigc::pointer_functor1<T_arg1, T_return>::function_type = int (*)(int)] (struct pointer_functor1 * const this, int (*function_type) (int) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor1<int, int>; T_return = int; T_arg1 = int] (struct slot * const this, const struct pointer_functor1 & _A_func)
{
  struct slot1 * D.46277;

  D.46277 = &this->D.39484;
  sigc::slot1<int, int>::slot1<sigc::pointer_functor1<int, int> > (D.46277, _A_func);
  try
    {

    }
  catch
    {
      D.46277 = &this->D.39484;
      sigc::slot1<int, int>::~slot1 (D.46277);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<int, int>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.41642;
  struct slot_base * D.46278;
  struct rep_type * D.46279;
  void * (*<T1711>) (void *) D.46280;

  D.41642 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<int, int> >::typed_slot_rep (D.41642, _A_func);
    }
  catch
    {
      operator delete (D.41642);
    }
  D.46278 = &this->D.39442;
  sigc::slot_base::slot_base (D.46278, D.41642);
  try
    {
      D.46279 = this->D.39442.rep_;
      D.46280 = sigc::internal::slot_call1<sigc::pointer_functor1<int, int>, int, int>::address ();
      D.46279->call_ = D.46280;
    }
  catch
    {
      D.46278 = &this->D.39442;
      sigc::slot_base::~slot_base (D.46278);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::pointer_functor1<int, int>] (struct typed_slot_rep * const this, const struct pointer_functor1 & functor)
{
  struct slot_rep * D.46283;
  struct adaptor_type * D.46284;
  struct slot_do_bind D.43883;

  D.46283 = &this->D.41624;
  sigc::internal::slot_rep::slot_rep (D.46283, 0B, destroy, dup);
  try
    {
      D.46284 = &this->functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<int, int> >::adaptor_functor (D.46284, functor);
      D.46284 = &this->functor_;
      D.46283 = &this->D.41624;
      sigc::internal::slot_do_bind::slot_do_bind (&D.43883, D.46283);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&D.43883, D.46284);
        }
      finally
        {
          D.43883 = {CLOBBER};
        }
    }
  catch
    {
      D.46283 = &this->D.41624;
      sigc::internal::slot_rep::~slot_rep (D.46283);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::pointer_functor1<int, int>] (void * data)
{
  void * D.46287;
  void * D.44121;
  struct slot_rep * a_rep;

  a_rep = data;
  D.44121 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<int, int> >::typed_slot_rep (D.44121, a_rep);
    }
  catch
    {
      operator delete (D.44121);
    }
  D.46287 = D.44121;
  return D.46287;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<int, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.46291;
  struct slot_rep * D.46292;
  struct adaptor_type * D.46293;
  struct slot_do_bind D.44975;

  D.46291 = cl->D.41624.call_;
  D.46292 = &this->D.41624;
  sigc::internal::slot_rep::slot_rep (D.46292, D.46291, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.46293 = &this->functor_;
      D.46292 = &this->D.41624;
      sigc::internal::slot_do_bind::slot_do_bind (&D.44975, D.46292);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&D.44975, D.46293);
        }
      finally
        {
          D.44975 = {CLOBBER};
        }
    }
  catch
    {
      D.46292 = &this->D.41624;
      sigc::internal::slot_rep::~slot_rep (D.46292);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::pointer_functor1<int, int>] (void * data)
{
  struct adaptor_type * D.46296;
  struct slot_do_unbind D.44106;
  void * D.46297;
  struct self * self_;

  self_ = data;
  self_->D.41624.call_ = 0B;
  self_->D.41624.destroy_ = 0B;
  D.46296 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.44106, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&D.44106, D.46296);
    }
  finally
    {
      D.44106 = {CLOBBER};
    }
  D.46297 = 0B;
  return D.46297;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<int, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.46301;

  D.46301 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::pointer_functor1<int, int> > (_A_action, D.46301);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::pointer_functor1<int, int> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::pointer_functor1<int, int>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct pointer_functor1 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor1<int, int>, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<int, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.45520, const struct limit_derived_target & D.45521)
{
  GIMPLE_NOP
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::pointer_functor1<int, int>] (struct adaptor_functor * const this, const struct pointer_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<int, int> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.46303;

  D.46303 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::pointer_functor1<int, int> > (_A_action, D.46303);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, int> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<int, int>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::pointer_functor1<int, int> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::pointer_functor1<int, int>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct pointer_functor1 & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::pointer_functor1<int, int>, sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type_pointer<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<int, int>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.45440, const struct limit_derived_target & D.45441)
{
  GIMPLE_NOP
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<int, int>; T_return = int; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.46304;

  D.46304 = call_it;
  return D.46304;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::pointer_functor1<int, int>; T_return = int; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  int D.46306;
  struct adaptor_type * D.46307;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.46307 = &typed_rep->functor_;
  D.46306 = sigc::adaptor_functor<sigc::pointer_functor1<int, int> >::operator()<const int&> (D.46307, a_1);
  return D.46306;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::pointer_functor1<int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.46310;
  struct pointer_functor1 * D.46311;

  D.46311 = &this->functor_;
  D.46310 = sigc::pointer_functor1<int, int>::operator() (D.46311, _A_arg1);
  return D.46310;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = int; T_return = int; typename sigc::type_trait<T_base>::take = const int&] (const struct pointer_functor1 * const this, const int & _A_a1)
{
  int D.46314;
  int (*<T70d8>) (int) D.46315;
  int D.46316;

  D.46315 = this->func_ptr_;
  D.46316 = *_A_a1;
  D.46314 = D.46315 (D.46316);
  return D.46314;
}


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::signal() [with T_return = int; T_arg1 = int] (struct signal * const this)
{
  struct signal1 * D.46319;

  D.46319 = &this->D.39633;
  sigc::signal1<int, int, sigc::nil>::signal1 (D.46319);
  try
    {

    }
  catch
    {
      D.46319 = &this->D.39633;
      sigc::signal1<int, int, sigc::nil>::~signal1 (D.46319);
    }
}


sigc::signal1<T_return, T_arg1, T_accumulator>::signal1() [with T_return = int; T_arg1 = int; T_accumulator = sigc::nil] (struct signal1 * const this)
{
  struct signal_base * D.46320;

  D.46320 = &this->D.39608;
  sigc::signal_base::signal_base (D.46320);
  try
    {

    }
  catch
    {
      D.46320 = &this->D.39608;
      sigc::signal_base::~signal_base (D.46320);
    }
}


sigc::bound_const_mem_functor1<typename sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type, sigc::signal1<T_return, T_arg1, T_accumulator>, typename sigc::type_trait<T_derived>::take> sigc::signal1<T_return, T_arg1, T_accumulator>::make_slot() const [with T_return = int; T_arg1 = int; T_accumulator = sigc::nil; typename sigc::type_trait<T_derived>::take = const int&; typename sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type = int] (const struct signal1 * const this)
{
  struct 
{
  result_type signal1::<T7094> (const struct signal1 *, const int &) * __pfn;
  long int __delta;
} D.46322;

  D.46322.__pfn = emit;
  D.46322.__delta = 0;
  sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>::bound_const_mem_functor1 (&<retval>, this, D.46322);
  return <retval>;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::emit(typename sigc::type_trait<T_derived>::take) const [with T_return = int; T_arg1 = int; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = int; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  result_type D.46324;
  struct signal_impl * D.46325;

  D.46325 = this->D.39608.impl_;
  D.46324 = sigc::internal::signal_emit1<int, int, sigc::nil>::emit (D.46325, _A_a1);
  return D.46324;
}


static sigc::internal::signal_emit1<T_return, T_arg1, sigc::nil>::result_type sigc::internal::signal_emit1<T_return, T_arg1, sigc::nil>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_derived>::take) [with T_return = int; T_arg1 = int; sigc::internal::signal_emit1<T_return, T_arg1, sigc::nil>::result_type = int; typename sigc::type_trait<T_derived>::take = const int&] (struct signal_impl * impl, const int & _A_a1)
{
  bool retval.18;
  bool iftmp.19;
  struct list * D.46334;
  bool D.46335;
  result_type D.46338;
  struct iterator D.43811;
  bool retval.20;
  bool iftmp.21;
  const struct slot_base * D.46343;
  bool D.46344;
  bool D.46345;
  const struct slot_base * D.46347;
  bool D.46348;
  bool D.46349;
  bool retval.22;
  const struct _Self D.43814;
  struct iterator D.43813;
  bool retval.23;
  const struct _Self D.43816;
  struct iterator D.43815;
  const struct slot_base * D.46356;
  struct rep_type * D.46357;
  void * (*<T1711>) (void *) D.46358;
  const struct slot_base * D.46359;
  struct rep_type * D.46360;
  bool retval.24;
  bool iftmp.25;
  const struct slot_base * D.46366;
  bool D.46367;
  const struct slot_base * D.46369;
  bool D.46370;
  const struct slot_base * D.46373;
  struct rep_type * D.46374;
  void * (*<T1711>) (void *) D.46375;
  const struct slot_base * D.46376;
  struct rep_type * D.46377;
  bool retval.26;
  const struct _Self D.43818;
  struct iterator D.43817;
  struct signal_exec exec;
  int r_;

  try
    {
      if (impl == 0B) goto <D.46330>; else goto <D.46333>;
      <D.46333>:
      D.46334 = &impl->slots_;
      D.46335 = std::list<sigc::slot_base>::empty (D.46334);
      if (D.46335 != 0) goto <D.46330>; else goto <D.46331>;
      <D.46330>:
      iftmp.19 = 1;
      goto <D.46332>;
      <D.46331>:
      iftmp.19 = 0;
      <D.46332>:
      retval.18 = iftmp.19;
      if (retval.18 != 0) goto <D.46336>; else goto <D.46337>;
      <D.46336>:
      D.46338 = 0;
      return D.46338;
      <D.46337>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          r_ = 0;
          {
            struct temp_slot_list slots;
            struct iterator_type it;

            try
              {
                D.46334 = &impl->slots_;
                sigc::internal::temp_slot_list::temp_slot_list (&slots, D.46334);
                try
                  {
                    D.43811 = sigc::internal::temp_slot_list::begin (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&it, &D.43811);
                      }
                    finally
                      {
                        D.43811 = {CLOBBER};
                      }
                    goto <D.43822>;
                    <D.43821>:
                    D.46343 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46344 = sigc::slot_base::empty (D.46343);
                    D.46345 = ~D.46344;
                    if (D.46345 != 0) goto <D.46346>; else goto <D.46341>;
                    <D.46346>:
                    D.46347 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46348 = sigc::slot_base::blocked (D.46347);
                    D.46349 = ~D.46348;
                    if (D.46349 != 0) goto <D.46350>; else goto <D.46341>;
                    <D.46350>:
                    iftmp.21 = 1;
                    goto <D.46342>;
                    <D.46341>:
                    iftmp.21 = 0;
                    <D.46342>:
                    retval.20 = iftmp.21;
                    if (retval.20 != 0) goto <D.43819>; else goto <D.46351>;
                    <D.46351>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.43822>:
                    D.43813 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.43814, &D.43813);
                        try
                          {
                            retval.22 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.43814);
                          }
                        finally
                          {
                            D.43814 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43813 = {CLOBBER};
                      }
                    if (retval.22 != 0) goto <D.43821>; else goto <D.43819>;
                    <D.43819>:
                    D.43815 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.43816, &D.43815);
                        try
                          {
                            retval.23 = std::_List_const_iterator<sigc::slot_base>::operator== (&it, &D.43816);
                          }
                        finally
                          {
                            D.43816 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43815 = {CLOBBER};
                      }
                    if (retval.23 != 0) goto <D.46354>; else goto <D.46355>;
                    <D.46354>:
                    D.46338 = 0;
                    return D.46338;
                    <D.46355>:
                    D.46356 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46357 = D.46356->rep_;
                    D.46358 = D.46357->call_;
                    D.46359 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46360 = D.46359->rep_;
                    r_ = D.46358 (D.46360, _A_a1);
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    goto <D.43826>;
                    <D.43825>:
                    D.46366 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46367 = sigc::slot_base::empty (D.46366);
                    if (D.46367 != 0) goto <D.46363>; else goto <D.46368>;
                    <D.46368>:
                    D.46369 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46370 = sigc::slot_base::blocked (D.46369);
                    if (D.46370 != 0) goto <D.46363>; else goto <D.46364>;
                    <D.46363>:
                    iftmp.25 = 1;
                    goto <D.46365>;
                    <D.46364>:
                    iftmp.25 = 0;
                    <D.46365>:
                    retval.24 = iftmp.25;
                    if (retval.24 != 0) goto <D.46371>; else goto <D.46372>;
                    <D.46371>:
                    goto <D.43824>;
                    <D.46372>:
                    D.46373 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46374 = D.46373->rep_;
                    D.46375 = D.46374->call_;
                    D.46376 = std::_List_const_iterator<sigc::slot_base>::operator-> (&it);
                    D.46377 = D.46376->rep_;
                    r_ = D.46375 (D.46377, _A_a1);
                    <D.43824>:
                    std::_List_const_iterator<sigc::slot_base>::operator++ (&it);
                    <D.43826>:
                    D.43817 = sigc::internal::temp_slot_list::end (&slots);
                    try
                      {
                        std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.43818, &D.43817);
                        try
                          {
                            retval.26 = std::_List_const_iterator<sigc::slot_base>::operator!= (&it, &D.43818);
                          }
                        finally
                          {
                            D.43818 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43817 = {CLOBBER};
                      }
                    if (retval.26 != 0) goto <D.43825>; else goto <D.43823>;
                    <D.43823>:
                  }
                finally
                  {
                    sigc::internal::temp_slot_list::~temp_slot_list (&slots);
                  }
              }
            finally
              {
                slots = {CLOBBER};
                it = {CLOBBER};
              }
          }
          D.46338 = r_;
          return D.46338;
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      exec = {CLOBBER};
    }
}


bool std::_List_const_iterator<_Tp>::operator==(const _Self&) const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::_Self = std::_List_const_iterator<sigc::slot_base>] (const struct _List_const_iterator * const this, const struct _Self & __x)
{
  bool D.46400;
  const struct _List_node_base * D.46401;
  const struct _List_node_base * D.46402;

  D.46401 = this->_M_node;
  D.46402 = __x->_M_node;
  D.46400 = D.46401 == D.46402;
  return D.46400;
}


sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::bound_const_mem_functor1(const T_obj*, sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = int; T_obj = sigc::signal1<int, int, sigc::nil>; T_arg1 = const int&; sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type = int (sigc::signal1<int, int, sigc::nil>::*)(const int&) const] (struct bound_const_mem_functor1 * const this, const struct signal1 * _A_obj, struct function_type _A_func)
{
  struct const_mem_functor1 * D.46404;
  struct const_limit_reference * D.46405;

  D.46404 = &this->D.40584;
  sigc::const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>::const_mem_functor1 (D.46404, _A_func);
  D.46405 = &this->obj_;
  sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>::const_limit_reference (D.46405, _A_obj);
}


sigc::const_mem_functor1<T_arg1, T_return, T_obj>::const_mem_functor1(sigc::const_mem_functor1<T_arg1, T_return, T_obj>::function_type) [with T_return = int; T_obj = sigc::signal1<int, int, sigc::nil>; T_arg1 = const int&; sigc::const_mem_functor1<T_arg1, T_return, T_obj>::function_type = int (sigc::signal1<int, int, sigc::nil>::*)(const int&) const] (struct const_mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::const_limit_reference<T_type, true>::const_limit_reference(const T_type&) [with T_type = sigc::signal1<int, int, sigc::nil>] (struct const_limit_reference * const this, const struct signal1 & _A_target)
{
  const struct trackable * D.46406;

  D.46406 = &_A_target->D.39608.D.35545;
  this->visited = D.46406;
  this->invoked = _A_target;
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>; T_return = int; T_arg1 = int] (struct slot * const this, const struct bound_const_mem_functor1 & _A_func)
{
  struct slot1 * D.46407;

  D.46407 = &this->D.39484;
  sigc::slot1<int, int>::slot1<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > (D.46407, _A_func);
  try
    {

    }
  catch
    {
      D.46407 = &this->D.39484;
      sigc::slot1<int, int>::~slot1 (D.46407);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct bound_const_mem_functor1 & _A_func)
{
  void * D.43673;
  struct slot_base * D.46408;
  struct rep_type * D.46409;
  void * (*<T1711>) (void *) D.46410;

  D.43673 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::typed_slot_rep (D.43673, _A_func);
    }
  catch
    {
      operator delete (D.43673);
    }
  D.46408 = &this->D.39442;
  sigc::slot_base::slot_base (D.46408, D.43673);
  try
    {
      D.46409 = this->D.39442.rep_;
      D.46410 = sigc::internal::slot_call1<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>, int, int>::address ();
      D.46409->call_ = D.46410;
    }
  catch
    {
      D.46408 = &this->D.39442;
      sigc::slot_base::~slot_base (D.46408);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (struct typed_slot_rep * const this, const struct bound_const_mem_functor1 & functor)
{
  struct slot_rep * D.46413;
  struct adaptor_type * D.46414;
  struct slot_do_bind D.44018;

  D.46413 = &this->D.43655;
  sigc::internal::slot_rep::slot_rep (D.46413, 0B, destroy, dup);
  try
    {
      D.46414 = &this->functor_;
      sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::adaptor_functor (D.46414, functor);
      D.46414 = &this->functor_;
      D.46413 = &this->D.43655;
      sigc::internal::slot_do_bind::slot_do_bind (&D.44018, D.46413);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > > (&D.44018, D.46414);
        }
      finally
        {
          D.44018 = {CLOBBER};
        }
    }
  catch
    {
      D.46413 = &this->D.43655;
      sigc::internal::slot_rep::~slot_rep (D.46413);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (void * data)
{
  void * D.46417;
  void * D.44775;
  struct slot_rep * a_rep;

  a_rep = data;
  D.44775 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::typed_slot_rep (D.44775, a_rep);
    }
  catch
    {
      operator delete (D.44775);
    }
  D.46417 = D.44775;
  return D.46417;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.46421;
  struct slot_rep * D.46422;
  struct adaptor_type * D.46423;
  struct slot_do_bind D.45165;

  D.46421 = cl->D.43655.call_;
  D.46422 = &this->D.43655;
  sigc::internal::slot_rep::slot_rep (D.46422, D.46421, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.46423 = &this->functor_;
      D.46422 = &this->D.43655;
      sigc::internal::slot_do_bind::slot_do_bind (&D.45165, D.46422);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > > (&D.45165, D.46423);
        }
      finally
        {
          D.45165 = {CLOBBER};
        }
    }
  catch
    {
      D.46422 = &this->D.43655;
      sigc::internal::slot_rep::~slot_rep (D.46422);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (void * data)
{
  struct adaptor_type * D.46426;
  struct slot_do_unbind D.44760;
  void * D.46427;
  struct self * self_;

  self_ = data;
  self_->D.43655.call_ = 0B;
  self_->D.43655.destroy_ = 0B;
  D.46426 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.44760, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > > (&D.44760, D.46426);
    }
  finally
    {
      D.44760 = {CLOBBER};
    }
  D.46427 = 0B;
  return D.46427;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >] (const struct slot_do_unbind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_const_mem_functor1 * D.46431;

  D.46431 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > (_A_action, D.46431);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (const struct limit_derived_target & _A_action, const struct bound_const_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = int; T_obj = sigc::signal1<int, int, sigc::nil>; T_arg1 = const int&] (const struct limit_derived_target & _A_action, const struct bound_const_mem_functor1 & _A_target)
{
  const struct const_limit_reference * D.46432;

  D.46432 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true> > (_A_action, D.46432);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = sigc::signal1<int, int, sigc::nil>; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.46433;

  D.46433 = sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::trackable> (_A_action, D.46433);
}


const sigc::trackable& sigc::const_limit_reference<T_type, true>::visit() const [with T_type = sigc::signal1<int, int, sigc::nil>] (const struct const_limit_reference * const this)
{
  const struct trackable & D.46434;

  D.46434 = this->visited;
  return D.46434;
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (struct adaptor_functor * const this, const struct bound_const_mem_functor1 & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >] (const struct slot_do_bind & _A_action, const struct adaptor_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::adaptor_functor<T_functor> >::do_visit_each(const T_action&, const sigc::adaptor_functor<T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_const_mem_functor1 * D.46437;

  D.46437 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> > (_A_action, D.46437);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>] (const struct limit_derived_target & _A_action, const struct bound_const_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1> >::do_visit_each(const T_action&, const sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = int; T_obj = sigc::signal1<int, int, sigc::nil>; T_arg1 = const int&] (const struct limit_derived_target & _A_action, const struct bound_const_mem_functor1 & _A_target)
{
  const struct const_limit_reference * D.46438;

  D.46438 = &_A_target->obj_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true> > (_A_action, D.46438);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_functor)
{
  sigc::visitor<sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::const_limit_reference<T_type, I_derives_trackable> >::do_visit_each(const T_action&, const sigc::const_limit_reference<T_type, I_derives_trackable>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = sigc::signal1<int, int, sigc::nil>; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct const_limit_reference & _A_target)
{
  const struct trackable & D.46439;

  D.46439 = sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::trackable> (_A_action, D.46439);
}


static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>; T_return = int; T_arg1 = int; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.46440;

  D.46440 = call_it;
  return D.46440;
}


static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename sigc::type_trait<T_arg3>::take) [with T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>; T_return = int; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  int D.46442;
  struct adaptor_type * D.46443;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.46443 = &typed_rep->functor_;
  D.46442 = sigc::adaptor_functor<sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&> >::operator()<const int&> (D.46443, a_1);
  return D.46442;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.46446;
  struct bound_const_mem_functor1 * D.46447;

  D.46447 = &this->functor_;
  D.46446 = sigc::bound_const_mem_functor1<int, sigc::signal1<int, int, sigc::nil>, const int&>::operator() (D.46447, _A_arg1);
  return D.46446;
}


T_return sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = int; T_obj = sigc::signal1<int, int, sigc::nil>; T_arg1 = const int&; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_const_mem_functor1 * const this, const int & _A_a1)
{
  int D.46450;
  const struct const_limit_reference * D.46451;
  const struct signal1 & D.46452;
  int signal1::<T7095> (const struct signal1 *, const int &) * iftmp.27;
  int signal1::<T7095> (const struct signal1 *, const int &) * D.46454;
  long int D.46455;
  long int D.46456;
  long int D.46460;
  sizetype D.46461;
  const struct signal1 * D.46462;
  int (*__vtbl_ptr_type) () * D.46463;
  long int D.46464;
  sizetype D.46465;
  int (*__vtbl_ptr_type) () * D.46466;

  D.46451 = &this->obj_;
  D.46452 = sigc::const_limit_reference<sigc::signal1<int, int, sigc::nil>, true>::invoke (D.46451);
  D.46454 = this->D.40584.func_ptr_.__pfn;
  D.46455 = (long int) D.46454;
  D.46456 = D.46455 & 1;
  if (D.46456 == 0) goto <D.46457>; else goto <D.46458>;
  <D.46457>:
  iftmp.27 = this->D.40584.func_ptr_.__pfn;
  goto <D.46459>;
  <D.46458>:
  D.46460 = this->D.40584.func_ptr_.__delta;
  D.46461 = (sizetype) D.46460;
  D.46462 = D.46452 + D.46461;
  D.46463 = MEM[(int (*__vtbl_ptr_type) () * *)D.46462];
  D.46454 = this->D.40584.func_ptr_.__pfn;
  D.46455 = (long int) D.46454;
  D.46464 = D.46455 + -1;
  D.46465 = (sizetype) D.46464;
  D.46466 = D.46463 + D.46465;
  iftmp.27 = *D.46466;
  <D.46459>:
  D.46460 = this->D.40584.func_ptr_.__delta;
  D.46461 = (sizetype) D.46460;
  D.46462 = D.46452 + D.46461;
  D.46450 = iftmp.27 (D.46462, _A_a1);
  return D.46450;
}


const T_type& sigc::const_limit_reference<T_type, true>::invoke() const [with T_type = sigc::signal1<int, int, sigc::nil>] (const struct const_limit_reference * const this)
{
  const struct signal1 & D.46469;

  D.46469 = this->invoked;
  return D.46469;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = int; T_arg1 = int; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.46471;
  struct iterator D.40856;
  struct iterator_type D.40846;
  const struct slot_base * D.46472;
  struct signal_base * D.46473;

  D.46472 = &slot_->D.39484.D.39442;
  D.46473 = &this->D.39608;
  D.40846 = sigc::signal_base::connect (D.46473, D.46472);
  try
    {
      sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.40856, &D.40846);
      try
        {
          D.46471 = D.40856;
          return D.46471;
        }
      finally
        {
          D.40856 = {CLOBBER};
        }
    }
  finally
    {
      D.40846 = {CLOBBER};
    }
}


sigc::slot_iterator<T_slot>::slot_iterator(const iterator_type&) [with T_slot = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; sigc::slot_iterator<T_slot>::iterator_type = std::_List_iterator<sigc::slot_base>] (struct slot_iterator * const this, const struct iterator_type & i)
{
  this->i_ = MEM[(const struct _List_iterator &)i];
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::operator()(typename sigc::type_trait<T_derived>::take) const [with T_return = int; T_arg1 = int; T_accumulator = sigc::nil; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = int; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  result_type D.46477;

  D.46477 = sigc::signal1<int, int, sigc::nil>::emit (this, _A_a1);
  return D.46477;
}


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

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

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


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

  try
    {
      {

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


sigc::slot<void, std::basic_string<char>&, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot() (struct slot * const this)
{
  struct slot1 * D.46482;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46482 = &this->D.40121;
            sigc::slot1<void, std::basic_string<char>&>::~slot1 (D.46482);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40421>:
}


sigc::slot1<void, std::basic_string<char>&>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.46484;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46484 = &this->D.40079;
            sigc::slot_base::~slot_base (D.46484);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40416>:
}


sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot() (struct slot * const this)
{
  struct slot1 * D.46486;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46486 = &this->D.39484;
            sigc::slot1<int, int>::~slot1 (D.46486);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39772>:
}


sigc::slot1<int, int>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.46488;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46488 = &this->D.39442;
            sigc::slot_base::~slot_base (D.46488);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39767>:
}


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::signal<void, std::basic_string<char>&>::~signal() (struct signal * const this)
{
  struct signal1 * D.46492;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46492 = &this->D.40270;
            sigc::signal1<void, std::basic_string<char>&, sigc::nil>::~signal1 (D.46492);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40301>:
}


sigc::signal1<void, std::basic_string<char>&, sigc::nil>::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.46494;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46494 = &this->D.40245;
            sigc::signal_base::~signal_base (D.46494);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40296>:
}


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

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


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

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


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

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

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


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

  try
    {
      {

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


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.28;
  struct _Rep & D.46508;
  bool D.46509;
  long int D.46510;
  long int D.46511;
  bool retval.29;
  _Atomic_word * D.46515;
  int D.46516;

  D.46508 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.46509 = D.46508 != this;
  D.46510 = (long int) D.46509;
  D.46511 = __builtin_expect (D.46510, 0);
  retval.28 = D.46511 != 0;
  if (retval.28 != 0) goto <D.46512>; else goto <D.46513>;
  <D.46512>:
  D.46515 = &this->D.11865._M_refcount;
  D.46516 = __gnu_cxx::__exchange_and_add_dispatch (D.46515, -1);
  retval.29 = D.46516 <= 0;
  if (retval.29 != 0) goto <D.46517>; else goto <D.46518>;
  <D.46517>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.46519>;
  <D.46518>:
  <D.46519>:
  goto <D.46520>;
  <D.46513>:
  <D.46520>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.30;
  int D.46525;
  _Atomic_word D.46528;

  D.46525 = __gthread_active_p ();
  retval.30 = D.46525 != 0;
  if (retval.30 != 0) goto <D.46526>; else goto <D.46527>;
  <D.46526>:
  D.46528 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.46528;
  <D.46527>:
  D.46528 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.46528;
}


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

  D.46531 = __gthrw___pthread_key_create != 0B;
  D.46530 = (int) D.46531;
  return D.46530;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.46533;
  unsigned int __val.31;
  unsigned int D.46535;

  __val.31 = (unsigned int) __val;
  D.46535 = __atomic_fetch_add_4 (__mem, __val.31, 4);
  D.46533 = (_Atomic_word) D.46535;
  return D.46533;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.46537;
  int D.46538;
  _Atomic_word D.46539;
  _Atomic_word __result;

  __result = *__mem;
  D.46537 = *__mem;
  D.46538 = D.46537 + __val;
  *__mem = D.46538;
  D.46539 = __result;
  return D.46539;
}


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

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


{anonymous}::A::~A() (struct A * const this)
{
  struct trackable * D.46541;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46541 = &this->D.39362;
            sigc::trackable::~trackable (D.46541);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39703>:
}


sigc::signal<int, int>::~signal() (struct signal * const this)
{
  struct signal1 * D.46543;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46543 = &this->D.39633;
            sigc::signal1<int, int, sigc::nil>::~signal1 (D.46543);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39664>:
}


sigc::signal1<int, int, sigc::nil>::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.46545;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.46545 = &this->D.39608;
            sigc::signal_base::~signal_base (D.46545);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39659>:
}


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


void __static_initialization_and_destruction_0(int, int) (int __initialize_p, int __priority)
{
  if (__initialize_p == 1) goto <D.46547>; else goto <D.46548>;
  <D.46547>:
  if (__priority == 65535) goto <D.46549>; else goto <D.46550>;
  <D.46549>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.46551>;
  <D.46550>:
  <D.46551>:
  goto <D.46552>;
  <D.46548>:
  <D.46552>:
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostringstream * const this)
{
  int (*__vtbl_ptr_type) () * iftmp.32;
  const void * * D.46556;
  sizetype iftmp.33;
  int (*__vtbl_ptr_type) () * D.46561;
  int (*__vtbl_ptr_type) () * D.46562;
  long int D.46563;
  struct basic_ios * D.46565;
  int (*__vtbl_ptr_type) () * iftmp.34;
  struct __stringbuf_type * D.46570;
  const void * * iftmp.35;
  struct basic_ostream * D.46575;
  int D.46576;
  struct basic_ios * D.46579;
  int D.46581;

  {
    if (2 == 0) goto <D.46554>; else goto <D.46555>;
    <D.46554>:
    D.46556 = 0B;
    iftmp.32 = *D.46556;
    goto <D.46557>;
    <D.46555>:
    iftmp.32 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.46557>:
    this->D.22312._vptr.basic_ostream = iftmp.32;
    if (2 == 0) goto <D.46559>; else goto <D.46560>;
    <D.46559>:
    D.46561 = this->D.22312._vptr.basic_ostream;
    D.46562 = D.46561 + 18446744073709551592;
    D.46563 = MEM[(long int *)D.46562];
    iftmp.33 = (sizetype) D.46563;
    goto <D.46564>;
    <D.46560>:
    iftmp.33 = 88;
    <D.46564>:
    D.46565 = this + iftmp.33;
    if (2 == 0) goto <D.46567>; else goto <D.46568>;
    <D.46567>:
    iftmp.34 = MEM[(const void * *)0B + 24B];
    goto <D.46569>;
    <D.46568>:
    iftmp.34 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.46569>:
    D.46565->D.19008._vptr.ios_base = iftmp.34;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.46570 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.46570);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.46572>; else goto <D.46573>;
                <D.46572>:
                iftmp.35 = 8B;
                goto <D.46574>;
                <D.46573>:
                iftmp.35 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.46574>:
                D.46575 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.46575, iftmp.35);
              }
          }
        finally
          {
            D.46576 = 2;
            if (D.46576 != 0) goto <D.46577>; else goto <D.46578>;
            <D.46577>:
            D.46579 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.46579);
            goto <D.46580>;
            <D.46578>:
            <D.46580>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.45631>:
  D.46581 = 0;
  if (D.46581 != 0) goto <D.46582>; else goto <D.46583>;
  <D.46582>:
  operator delete (this);
  goto <D.46584>;
  <D.46583>:
  <D.46584>:
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_ostringstream * const this)
{
  std::basic_ostringstream<char>::~basic_ostringstream (this);
  <D.45633>:
  operator delete (this);
}


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.46594;
  struct basic_streambuf * D.46595;
  int D.46596;

  {
    this->D.22162._vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_stringbufIcSt11char_traitsIcESaIcEE + 16B];
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.46594 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.46594);
              }
          }
        finally
          {
            D.46595 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.46595);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40766>:
  D.46596 = 0;
  if (D.46596 != 0) goto <D.46597>; else goto <D.46598>;
  <D.46597>:
  operator delete (this);
  goto <D.46599>;
  <D.46598>:
  <D.46599>:
}


std::basic_streambuf<_CharT, _Traits>::~basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  struct locale * D.46602;
  int D.46603;

  {
    this->_vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_streambufIcSt11char_traitsIcEE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.46602 = &this->_M_buf_locale;
            std::locale::~locale (D.46602);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41079>:
  D.46603 = 0;
  if (D.46603 != 0) goto <D.46604>; else goto <D.46605>;
  <D.46604>:
  operator delete (this);
  goto <D.46606>;
  <D.46605>:
  <D.46606>:
}


std::basic_streambuf<_CharT, _Traits>::~basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  std::basic_streambuf<char>::~basic_streambuf (this);
  <D.41083>:
  operator delete (this);
}


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.40770>:
  operator delete (this);
}


std::basic_ostream<_CharT, _Traits>::~basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  int (*__vtbl_ptr_type) () * iftmp.36;
  sizetype iftmp.37;
  int (*__vtbl_ptr_type) () * D.46614;
  int (*__vtbl_ptr_type) () * D.46615;
  long int D.46616;
  struct basic_ios * D.46618;
  int (*__vtbl_ptr_type) () * iftmp.38;
  int D.46623;
  struct basic_ios * D.46626;
  int D.46628;

  {
    if (0 == 0) goto <D.46608>; else goto <D.46609>;
    <D.46608>:
    iftmp.36 = *__vtt_parm;
    goto <D.46610>;
    <D.46609>:
    iftmp.36 = &MEM[(void *)&_ZTVSo + 24B];
    <D.46610>:
    this->_vptr.basic_ostream = iftmp.36;
    if (0 == 0) goto <D.46612>; else goto <D.46613>;
    <D.46612>:
    D.46614 = this->_vptr.basic_ostream;
    D.46615 = D.46614 + 18446744073709551592;
    D.46616 = MEM[(long int *)D.46615];
    iftmp.37 = (sizetype) D.46616;
    goto <D.46617>;
    <D.46613>:
    iftmp.37 = 8;
    <D.46617>:
    D.46618 = this + iftmp.37;
    if (0 == 0) goto <D.46620>; else goto <D.46621>;
    <D.46620>:
    iftmp.38 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.46622>;
    <D.46621>:
    iftmp.38 = &MEM[(void *)&_ZTVSo + 64B];
    <D.46622>:
    D.46618->D.19008._vptr.ios_base = iftmp.38;
    try
      {
        try
          {

          }
        finally
          {
            D.46623 = 0;
            if (D.46623 != 0) goto <D.46624>; else goto <D.46625>;
            <D.46624>:
            D.46626 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.46626);
            goto <D.46627>;
            <D.46625>:
            <D.46627>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41064>:
  D.46628 = 0;
  if (D.46628 != 0) goto <D.46629>; else goto <D.46630>;
  <D.46629>:
  operator delete (this);
  goto <D.46631>;
  <D.46630>:
  <D.46631>:
}


std::basic_ios<_CharT, _Traits>::~basic_ios() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ios * const this)
{
  struct ios_base * D.46633;
  int D.46634;

  {
    this->D.19008._vptr.ios_base = &MEM[(void *)&_ZTVSt9basic_iosIcSt11char_traitsIcEE + 16B];
    try
      {
        try
          {

          }
        finally
          {
            D.46633 = &this->D.19008;
            std::ios_base::~ios_base (D.46633);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41052>:
  D.46634 = 0;
  if (D.46634 != 0) goto <D.46635>; else goto <D.46636>;
  <D.46635>:
  operator delete (this);
  goto <D.46637>;
  <D.46636>:
  <D.46637>:
}


std::basic_ios<_CharT, _Traits>::~basic_ios() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ios * const this)
{
  std::basic_ios<char>::~basic_ios (this);
  <D.41056>:
  operator delete (this);
}


std::basic_ostringstream<_CharT, _Traits, _Alloc>::basic_ostringstream(std::ios_base::openmode) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::ios_base::openmode = std::_Ios_Openmode] (struct basic_ostringstream * const this, openmode __mode)
{
  struct basic_ios * D.46641;
  const void * * iftmp.39;
  struct basic_ostream * D.46647;
  int (*__vtbl_ptr_type) () * iftmp.40;
  const void * * D.46651;
  sizetype iftmp.41;
  int (*__vtbl_ptr_type) () * D.46656;
  int (*__vtbl_ptr_type) () * D.46657;
  long int D.46658;
  struct basic_ios * D.46660;
  int (*__vtbl_ptr_type) () * iftmp.42;
  _Ios_Openmode D.46665;
  struct __stringbuf_type * D.46666;
  struct basic_streambuf * D.46667;
  sizetype iftmp.43;
  struct basic_ios * D.46672;
  const void * * iftmp.44;

  if (1 != 0) goto <D.46639>; else goto <D.46640>;
  <D.46639>:
  D.46641 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.46641);
  goto <D.46642>;
  <D.46640>:
  <D.46642>:
  try
    {
      if (1 == 0) goto <D.46644>; else goto <D.46645>;
      <D.46644>:
      iftmp.39 = 8B;
      goto <D.46646>;
      <D.46645>:
      iftmp.39 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.46646>:
      D.46647 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.46647, iftmp.39);
      try
        {
          if (1 == 0) goto <D.46649>; else goto <D.46650>;
          <D.46649>:
          D.46651 = 0B;
          iftmp.40 = *D.46651;
          goto <D.46652>;
          <D.46650>:
          iftmp.40 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.46652>:
          this->D.22312._vptr.basic_ostream = iftmp.40;
          if (1 == 0) goto <D.46654>; else goto <D.46655>;
          <D.46654>:
          D.46656 = this->D.22312._vptr.basic_ostream;
          D.46657 = D.46656 + 18446744073709551592;
          D.46658 = MEM[(long int *)D.46657];
          iftmp.41 = (sizetype) D.46658;
          goto <D.46659>;
          <D.46655>:
          iftmp.41 = 88;
          <D.46659>:
          D.46660 = this + iftmp.41;
          if (1 == 0) goto <D.46662>; else goto <D.46663>;
          <D.46662>:
          iftmp.42 = MEM[(const void * *)0B + 24B];
          goto <D.46664>;
          <D.46663>:
          iftmp.42 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.46664>:
          D.46660->D.19008._vptr.ios_base = iftmp.42;
          D.46665 = std::operator| (__mode, 16);
          D.46666 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.46666, D.46665);
          try
            {
              D.46667 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.46669>; else goto <D.46670>;
              <D.46669>:
              D.46656 = this->D.22312._vptr.basic_ostream;
              D.46657 = D.46656 + 18446744073709551592;
              D.46658 = MEM[(long int *)D.46657];
              iftmp.43 = (sizetype) D.46658;
              goto <D.46671>;
              <D.46670>:
              iftmp.43 = 88;
              <D.46671>:
              D.46672 = this + iftmp.43;
              std::basic_ios<char>::init (D.46672, D.46667);
            }
          catch
            {
              D.46666 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.46666);
            }
        }
      catch
        {
          if (1 == 0) goto <D.46674>; else goto <D.46675>;
          <D.46674>:
          iftmp.44 = 8B;
          goto <D.46676>;
          <D.46675>:
          iftmp.44 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.46676>:
          D.46647 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.46647, iftmp.44);
        }
    }
  catch
    {
      if (1 != 0) goto <D.46677>; else goto <D.46678>;
      <D.46677>:
      D.46641 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.46641);
      goto <D.46679>;
      <D.46678>:
      <D.46679>:
    }
}


std::basic_ios<_CharT, _Traits>::basic_ios() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ios * const this)
{
  struct ios_base * D.46683;

  D.46683 = &this->D.19008;
  std::ios_base::ios_base (D.46683);
  try
    {
      this->D.19008._vptr.ios_base = &MEM[(void *)&_ZTVSt9basic_iosIcSt11char_traitsIcEE + 16B];
      this->_M_tie = 0B;
      this->_M_fill = 0;
      this->_M_fill_init = 0;
      this->_M_streambuf = 0B;
      this->_M_ctype = 0B;
      this->_M_num_put = 0B;
      this->_M_num_get = 0B;
    }
  catch
    {
      D.46683 = &this->D.19008;
      std::ios_base::~ios_base (D.46683);
    }
}


std::basic_ostream<_CharT, _Traits>::basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream * const this, const void * * __vtt_parm)
{
  struct basic_ios * D.46686;
  int (*__vtbl_ptr_type) () * iftmp.45;
  sizetype iftmp.46;
  int (*__vtbl_ptr_type) () * D.46695;
  int (*__vtbl_ptr_type) () * D.46696;
  long int D.46697;
  struct basic_ios * D.46699;
  int (*__vtbl_ptr_type) () * iftmp.47;
  sizetype iftmp.48;
  struct basic_ios * D.46708;

  if (0 != 0) goto <D.46684>; else goto <D.46685>;
  <D.46684>:
  D.46686 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.46686);
  goto <D.46687>;
  <D.46685>:
  <D.46687>:
  try
    {
      if (0 == 0) goto <D.46689>; else goto <D.46690>;
      <D.46689>:
      iftmp.45 = *__vtt_parm;
      goto <D.46691>;
      <D.46690>:
      iftmp.45 = &MEM[(void *)&_ZTVSo + 24B];
      <D.46691>:
      this->_vptr.basic_ostream = iftmp.45;
      if (0 == 0) goto <D.46693>; else goto <D.46694>;
      <D.46693>:
      D.46695 = this->_vptr.basic_ostream;
      D.46696 = D.46695 + 18446744073709551592;
      D.46697 = MEM[(long int *)D.46696];
      iftmp.46 = (sizetype) D.46697;
      goto <D.46698>;
      <D.46694>:
      iftmp.46 = 8;
      <D.46698>:
      D.46699 = this + iftmp.46;
      if (0 == 0) goto <D.46701>; else goto <D.46702>;
      <D.46701>:
      iftmp.47 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.46703>;
      <D.46702>:
      iftmp.47 = &MEM[(void *)&_ZTVSo + 64B];
      <D.46703>:
      D.46699->D.19008._vptr.ios_base = iftmp.47;
      if (0 == 0) goto <D.46705>; else goto <D.46706>;
      <D.46705>:
      D.46695 = this->_vptr.basic_ostream;
      D.46696 = D.46695 + 18446744073709551592;
      D.46697 = MEM[(long int *)D.46696];
      iftmp.48 = (sizetype) D.46697;
      goto <D.46707>;
      <D.46706>:
      iftmp.48 = 8;
      <D.46707>:
      D.46708 = this + iftmp.48;
      std::basic_ios<char>::init (D.46708, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.46709>; else goto <D.46710>;
      <D.46709>:
      D.46686 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.46686);
      goto <D.46711>;
      <D.46710>:
      <D.46711>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.46713;
  int __a.49;
  int __b.50;
  int D.46716;

  __a.49 = (int) __a;
  __b.50 = (int) __b;
  D.46716 = __a.49 | __b.50;
  D.46713 = (_Ios_Openmode) D.46716;
  return D.46713;
}


std::basic_stringbuf<_CharT, _Traits, _Alloc>::basic_stringbuf(std::ios_base::openmode) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::ios_base::openmode = std::_Ios_Openmode] (struct basic_stringbuf * const this, openmode __mode)
{
  struct basic_streambuf * D.46718;
  struct __string_type * D.46719;

  D.46718 = &this->D.22162;
  std::basic_streambuf<char>::basic_streambuf (D.46718);
  try
    {
      this->D.22162._vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_stringbufIcSt11char_traitsIcESaIcEE + 16B];
      this->_M_mode = __mode;
      D.46719 = &this->_M_string;
      std::basic_string<char>::basic_string (D.46719);
      try
        {

        }
      catch
        {
          D.46719 = &this->_M_string;
          std::basic_string<char>::~basic_string (D.46719);
        }
    }
  catch
    {
      D.46718 = &this->D.22162;
      std::basic_streambuf<char>::~basic_streambuf (D.46718);
    }
}


std::basic_streambuf<_CharT, _Traits>::basic_streambuf() [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_streambuf * const this)
{
  struct locale * D.46721;

  this->_vptr.basic_streambuf = &MEM[(void *)&_ZTVSt15basic_streambufIcSt11char_traitsIcEE + 16B];
  this->_M_in_beg = 0B;
  this->_M_in_cur = 0B;
  this->_M_in_end = 0B;
  this->_M_out_beg = 0B;
  this->_M_out_cur = 0B;
  this->_M_out_end = 0B;
  D.46721 = &this->_M_buf_locale;
  std::locale::locale (D.46721);
  try
    {

    }
  catch
    {
      D.46721 = &this->_M_buf_locale;
      std::locale::~locale (D.46721);
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator D.43802;
  struct _Rep & D.46722;
  char * D.46723;
  struct _Alloc_hider * D.46724;

  std::allocator<char>::allocator (&D.43802);
  try
    {
      D.46722 = std::basic_string<char>::_S_empty_rep ();
      D.46723 = std::basic_string<char>::_Rep::_M_refdata (D.46722);
      D.46724 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.46724, D.46723, &D.43802);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.43802);
      D.43802 = {CLOBBER};
    }
  try
    {

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


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

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


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

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


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


