int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.43652;
  int D.43655;
  int iftmp.1;
  bool D.43657;
  struct retype_functor D.37187;
  struct bound_mem_functor1 D.36347;
  struct 
{
  float foo::<T698f> (struct foo *, int) * __pfn;
  long int __delta;
} D.43661;
  float D.43662;
  const struct string D.37240;
  struct allocator D.37239;
  struct retype_functor D.38137;
  struct bound_mem_functor1 D.37311;
  struct 
{
  float foo::<T6993> (struct foo *, float) * __pfn;
  long int __delta;
} D.43663;
  float D.43664;
  const struct string D.38183;
  struct allocator D.38182;
  struct retype_functor D.39040;
  struct pointer_functor1 D.38217;
  const struct string D.39086;
  struct allocator D.39085;
  struct retype_functor D.39184;
  struct bound_mem_functor1 D.39183;
  struct 
{
  float foo::<T698f> (struct foo *, int) * __pfn;
  long int __delta;
} D.43665;
  struct retype_functor D.39333;
  struct bound_mem_functor1 D.39332;
  struct 
{
  float foo::<T6993> (struct foo *, float) * __pfn;
  long int __delta;
} D.43666;
  struct retype_functor D.39489;
  struct pointer_functor1 D.39488;
  const float D.39541;
  float D.43667;
  const struct string D.39544;
  struct allocator D.39543;
  const int D.39545;
  float D.43668;
  const struct string D.39548;
  struct allocator D.39547;
  const double D.39549;
  const struct string D.39552;
  struct allocator D.39551;
  const struct slot D.40445;
  struct retype_functor D.40375;
  const int D.40447;
  float D.43669;
  const struct string D.40450;
  struct allocator D.40449;
  int iftmp.2;
  bool D.43671;

  {
    struct TestUtilities * util;
    struct foo foo_;
    struct slot s1;
    struct slot s2;
    struct slot s3;

    try
      {
        util = TestUtilities::get_instance ();
        D.43652 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.43652;
        if (retval.0 != 0) goto <D.43653>; else goto <D.43654>;
        <D.43653>:
        D.43657 = TestUtilities::get_result_and_delete_instance ();
        if (D.43657 != 0) goto <D.43658>; else goto <D.43659>;
        <D.43658>:
        iftmp.1 = 0;
        goto <D.43660>;
        <D.43659>:
        iftmp.1 = 1;
        <D.43660>:
        D.43655 = iftmp.1;
        return D.43655;
        <D.43654>:
        {anonymous}::foo::foo (&foo_);
        try
          {
            D.43661.__pfn = test_int;
            D.43661.__delta = 0;
            D.36347 = sigc::mem_fun<int, float, {anonymous}::foo, {anonymous}::foo> (&foo_, D.43661); [return slot optimization]
            try
              {
                D.37187 = sigc::retype<float, {anonymous}::foo, int> (&D.36347); [return slot optimization]
                try
                  {
                    D.43662 = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<float> (&D.37187, 1.2339999675750732421875e+0);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.43662);
                  }
                finally
                  {
                    D.37187 = {CLOBBER};
                  }
              }
            finally
              {
                D.36347 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.37239);
            try
              {
                std::basic_string<char>::basic_string (&D.37240, "foo::test_int(int 1) 1.5", &D.37239);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.37240);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.37240);
                    D.37240 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.37239);
                D.37239 = {CLOBBER};
              }
            D.43663.__pfn = test_float;
            D.43663.__delta = 0;
            D.37311 = sigc::mem_fun<float, float, {anonymous}::foo, {anonymous}::foo> (&foo_, D.43663); [return slot optimization]
            try
              {
                D.38137 = sigc::retype<float, {anonymous}::foo, float> (&D.37311); [return slot optimization]
                try
                  {
                    D.43664 = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.38137, 5);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.43664);
                  }
                finally
                  {
                    D.38137 = {CLOBBER};
                  }
              }
            finally
              {
                D.37311 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.38182);
            try
              {
                std::basic_string<char>::basic_string (&D.38183, "foo::test_float(float 5) 25", &D.38182);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.38183);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.38183);
                    D.38183 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.38182);
                D.38182 = {CLOBBER};
              }
            D.38217 = sigc::ptr_fun<short int, void> (bar);
            try
              {
                D.39040 = sigc::retype<short int, void> (&D.38217); [return slot optimization]
                try
                  {
                    sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<float> (&D.39040, 6.789000034332275390625e+0);
                  }
                finally
                  {
                    D.39040 = {CLOBBER};
                  }
              }
            finally
              {
                D.38217 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.39085);
            try
              {
                std::basic_string<char>::basic_string (&D.39086, "bar(short 6)", &D.39085);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.39086);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.39086);
                    D.39086 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.39085);
                D.39085 = {CLOBBER};
              }
            D.43665.__pfn = test_int;
            D.43665.__delta = 0;
            D.39183 = sigc::mem_fun<int, float, {anonymous}::foo, {anonymous}::foo> (&foo_, D.43665); [return slot optimization]
            try
              {
                D.39184 = sigc::retype<float, {anonymous}::foo, int> (&D.39183); [return slot optimization]
                try
                  {
                    sigc::slot<float, float>::slot<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&s1, &D.39184);
                  }
                finally
                  {
                    try
                      {

                      }
                    catch
                      {
                        sigc::slot<float, float>::~slot (&s1);
                      }
                    D.39184 = {CLOBBER};
                  }
              }
            finally
              {
                try
                  {

                  }
                catch
                  {
                    sigc::slot<float, float>::~slot (&s1);
                  }
                D.39183 = {CLOBBER};
              }
            try
              {
                D.43666.__pfn = test_float;
                D.43666.__delta = 0;
                D.39332 = sigc::mem_fun<float, float, {anonymous}::foo, {anonymous}::foo> (&foo_, D.43666); [return slot optimization]
                try
                  {
                    D.39333 = sigc::retype<float, {anonymous}::foo, float> (&D.39332); [return slot optimization]
                    try
                      {
                        sigc::slot<float, int>::slot<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&s2, &D.39333);
                      }
                    finally
                      {
                        try
                          {

                          }
                        catch
                          {
                            sigc::slot<float, int>::~slot (&s2);
                          }
                        D.39333 = {CLOBBER};
                      }
                  }
                finally
                  {
                    try
                      {

                      }
                    catch
                      {
                        sigc::slot<float, int>::~slot (&s2);
                      }
                    D.39332 = {CLOBBER};
                  }
                try
                  {
                    D.39488 = sigc::ptr_fun<short int, void> (bar);
                    try
                      {
                        D.39489 = sigc::retype<short int, void> (&D.39488); [return slot optimization]
                        try
                          {
                            sigc::slot<void, double>::slot<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&s3, &D.39489);
                          }
                        finally
                          {
                            try
                              {

                              }
                            catch
                              {
                                sigc::slot<void, double>::~slot (&s3);
                              }
                            D.39489 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        try
                          {

                          }
                        catch
                          {
                            sigc::slot<void, double>::~slot (&s3);
                          }
                        D.39488 = {CLOBBER};
                      }
                    try
                      {
                        D.39541 = 1.2339999675750732421875e+0;
                        try
                          {
                            D.43667 = sigc::slot1<float, float>::operator() (&s1.D.39181, &D.39541);
                            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.43667);
                          }
                        finally
                          {
                            D.39541 = {CLOBBER};
                          }
                        std::allocator<char>::allocator (&D.39543);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.39544, "foo::test_int(int 1) 1.5", &D.39543);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.39544);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.39544);
                                D.39544 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.39543);
                            D.39543 = {CLOBBER};
                          }
                        D.39545 = 5;
                        try
                          {
                            D.43668 = sigc::slot1<float, int>::operator() (&s2.D.39330, &D.39545);
                            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.43668);
                          }
                        finally
                          {
                            D.39545 = {CLOBBER};
                          }
                        std::allocator<char>::allocator (&D.39547);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.39548, "foo::test_float(float 5) 25", &D.39547);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.39548);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.39548);
                                D.39548 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.39547);
                            D.39547 = {CLOBBER};
                          }
                        D.39549 = 6.7889999999999997015720509807579219341278076171875e+0;
                        try
                          {
                            sigc::slot1<void, double>::operator() (&s3.D.39486, &D.39549);
                          }
                        finally
                          {
                            D.39549 = {CLOBBER};
                          }
                        std::allocator<char>::allocator (&D.39551);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.39552, "bar(short 6)", &D.39551);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.39552);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.39552);
                                D.39552 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.39551);
                            D.39551 = {CLOBBER};
                          }
                        D.40375 = sigc::retype<float, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> (&s1); [return slot optimization]
                        try
                          {
                            sigc::slot<float, int>::slot<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.40445, &D.40375);
                            try
                              {
                                sigc::slot<float, int>::operator= (&s2, &D.40445);
                              }
                            finally
                              {
                                sigc::slot<float, int>::~slot (&D.40445);
                                D.40445 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~retype_functor (&D.40375);
                            D.40375 = {CLOBBER};
                          }
                        D.40447 = 5;
                        try
                          {
                            D.43669 = sigc::slot1<float, int>::operator() (&s2.D.39330, &D.40447);
                            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.43669);
                          }
                        finally
                          {
                            D.40447 = {CLOBBER};
                          }
                        std::allocator<char>::allocator (&D.40449);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.40450, "foo::test_int(int 5) 7.5", &D.40449);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.40450);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.40450);
                                D.40450 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.40449);
                            D.40449 = {CLOBBER};
                          }
                        D.43671 = TestUtilities::get_result_and_delete_instance ();
                        if (D.43671 != 0) goto <D.43672>; else goto <D.43673>;
                        <D.43672>:
                        iftmp.2 = 0;
                        goto <D.43674>;
                        <D.43673>:
                        iftmp.2 = 1;
                        <D.43674>:
                        D.43655 = iftmp.2;
                        return D.43655;
                      }
                    finally
                      {
                        sigc::slot<void, double>::~slot (&s3);
                      }
                  }
                finally
                  {
                    sigc::slot<float, int>::~slot (&s2);
                  }
              }
            finally
              {
                sigc::slot<float, float>::~slot (&s1);
              }
          }
        finally
          {
            {anonymous}::foo::~foo (&foo_);
          }
      }
    finally
      {
        foo_ = {CLOBBER};
        s1 = {CLOBBER};
        s2 = {CLOBBER};
        s3 = {CLOBBER};
      }
  }
  D.43655 = 0;
  return D.43655;
}


void {anonymous}::bar(short int) (short int s)
{
  int D.43728;
  struct basic_ostream & D.43729;
  struct basic_ostream & D.43730;

  D.43728 = (int) s;
  D.43729 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar(short ");
  D.43730 = std::basic_ostream<char>::operator<< (D.43729, D.43728);
  std::operator<< <std::char_traits<char> > (D.43730, ")");
}


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.43735;
  int (*__vtbl_ptr_type) () * D.43736;
  long int D.43737;
  sizetype D.43738;
  struct basic_ios * D.43739;
  long unsigned int D.43741;
  long int D.43742;
  struct basic_ostream & D.43743;

  if (__s == 0B) goto <D.43733>; else goto <D.43734>;
  <D.43733>:
  D.43735 = __out->_vptr.basic_ostream;
  D.43736 = D.43735 + 18446744073709551592;
  D.43737 = MEM[(long int *)D.43736];
  D.43738 = (sizetype) D.43737;
  D.43739 = __out + D.43738;
  std::basic_ios<char>::setstate (D.43739, 1);
  goto <D.43740>;
  <D.43734>:
  D.43741 = std::char_traits<char>::length (__s);
  D.43742 = (long int) D.43741;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.43742);
  <D.43740>:
  D.43743 = __out;
  return D.43743;
}


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.43745;
  _Ios_Iostate D.43746;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.43753 = __a.3 | __b.4;
  D.43750 = (_Ios_Iostate) D.43753;
  return D.43750;
}


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

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


float {anonymous}::foo::test_float(float) (struct foo * const this, float f)
{
  struct basic_ostream & D.43757;
  struct __ostream_type & D.43758;
  float D.43759;

  D.43757 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo::test_float(float ");
  D.43758 = std::basic_ostream<char>::operator<< (D.43757, f);
  std::operator<< <std::char_traits<char> > (D.43758, ") ");
  D.43759 = f * 5.0e+0;
  return D.43759;
}


float {anonymous}::foo::test_int(int) (struct foo * const this, int i)
{
  struct basic_ostream & D.43763;
  struct basic_ostream & D.43764;
  float D.43765;
  float D.43766;

  D.43763 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo::test_int(int ");
  D.43764 = std::basic_ostream<char>::operator<< (D.43763, i);
  std::operator<< <std::char_traits<char> > (D.43764, ") ");
  D.43766 = (float) i;
  D.43765 = D.43766 * 1.5e+0;
  return D.43765;
}


{anonymous}::foo::foo() (struct foo * const this)
{
  struct trackable * D.43770;

  D.43770 = &this->D.36180;
  sigc::trackable::trackable (D.43770);
  try
    {

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


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = float; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>; T_type1 = int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = float] (struct retype_functor * const this, float _A_a1)
{
  type D.43771;
  const int D.40687;
  int D.43772;
  struct adaptor_type * D.43773;

  D.43772 = (int) _A_a1;
  D.40687 = D.43772;
  try
    {
      D.43773 = &this->D.37185.functor_;
      D.43771 = sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int> >::operator()<const int&> (D.43773, &D.40687);
      return D.43771;
    }
  finally
    {
      D.40687 = {CLOBBER};
    }
}


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<float, {anonymous}::foo, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = float] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.43778;
  struct bound_mem_functor1 * D.43779;

  D.43779 = &this->functor_;
  D.43778 = sigc::bound_mem_functor1<float, {anonymous}::foo, int>::operator() (D.43779, _A_arg1);
  return D.43778;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = float; T_obj = {anonymous}::foo; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  float D.43782;
  const struct limit_reference * D.43783;
  struct foo & D.43784;
  float foo::<T698f> (struct foo *, int) * iftmp.5;
  float foo::<T698f> (struct foo *, int) * D.43786;
  long int D.43787;
  long int D.43788;
  long int D.43792;
  sizetype D.43793;
  struct foo * D.43794;
  int (*__vtbl_ptr_type) () * D.43795;
  long int D.43796;
  sizetype D.43797;
  int (*__vtbl_ptr_type) () * D.43798;
  int D.43799;

  D.43783 = &this->obj_;
  D.43784 = sigc::limit_reference<{anonymous}::foo, true>::invoke (D.43783);
  D.43786 = this->D.36344.func_ptr_.__pfn;
  D.43787 = (long int) D.43786;
  D.43788 = D.43787 & 1;
  if (D.43788 == 0) goto <D.43789>; else goto <D.43790>;
  <D.43789>:
  iftmp.5 = this->D.36344.func_ptr_.__pfn;
  goto <D.43791>;
  <D.43790>:
  D.43792 = this->D.36344.func_ptr_.__delta;
  D.43793 = (sizetype) D.43792;
  D.43794 = D.43784 + D.43793;
  D.43795 = MEM[(int (*__vtbl_ptr_type) () * *)D.43794];
  D.43786 = this->D.36344.func_ptr_.__pfn;
  D.43787 = (long int) D.43786;
  D.43796 = D.43787 + -1;
  D.43797 = (sizetype) D.43796;
  D.43798 = D.43795 + D.43797;
  iftmp.5 = *D.43798;
  <D.43791>:
  D.43799 = *_A_a1;
  D.43792 = this->D.36344.func_ptr_.__delta;
  D.43793 = (sizetype) D.43792;
  D.43794 = D.43784 + D.43793;
  D.43782 = iftmp.5 (D.43794, D.43799);
  return D.43782;
}


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

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


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = int; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = float] (struct retype_functor * const this, int _A_a1)
{
  type D.43804;
  const float D.40867;
  float D.43805;
  struct adaptor_type * D.43806;

  D.43805 = (float) _A_a1;
  D.40867 = D.43805;
  try
    {
      D.43806 = &this->D.38135.functor_;
      D.43804 = sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::operator()<const float&> (D.43806, &D.40867);
      return D.43804;
    }
  finally
    {
      D.40867 = {CLOBBER};
    }
}


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 float&; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = float] (const struct adaptor_functor * const this, const float & _A_arg1)
{
  type D.43811;
  struct bound_mem_functor1 * D.43812;

  D.43812 = &this->functor_;
  D.43811 = sigc::bound_mem_functor1<float, {anonymous}::foo, float>::operator() (D.43812, _A_arg1);
  return D.43811;
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = float; T_obj = {anonymous}::foo; T_arg1 = float; typename sigc::type_trait<T_arg3>::take = const float&] (const struct bound_mem_functor1 * const this, const float & _A_a1)
{
  float D.43815;
  const struct limit_reference * D.43816;
  struct foo & D.43817;
  float foo::<T6993> (struct foo *, float) * iftmp.6;
  float foo::<T6993> (struct foo *, float) * D.43819;
  long int D.43820;
  long int D.43821;
  long int D.43825;
  sizetype D.43826;
  struct foo * D.43827;
  int (*__vtbl_ptr_type) () * D.43828;
  long int D.43829;
  sizetype D.43830;
  int (*__vtbl_ptr_type) () * D.43831;
  float D.43832;

  D.43816 = &this->obj_;
  D.43817 = sigc::limit_reference<{anonymous}::foo, true>::invoke (D.43816);
  D.43819 = this->D.37308.func_ptr_.__pfn;
  D.43820 = (long int) D.43819;
  D.43821 = D.43820 & 1;
  if (D.43821 == 0) goto <D.43822>; else goto <D.43823>;
  <D.43822>:
  iftmp.6 = this->D.37308.func_ptr_.__pfn;
  goto <D.43824>;
  <D.43823>:
  D.43825 = this->D.37308.func_ptr_.__delta;
  D.43826 = (sizetype) D.43825;
  D.43827 = D.43817 + D.43826;
  D.43828 = MEM[(int (*__vtbl_ptr_type) () * *)D.43827];
  D.43819 = this->D.37308.func_ptr_.__pfn;
  D.43820 = (long int) D.43819;
  D.43829 = D.43820 + -1;
  D.43830 = (sizetype) D.43829;
  D.43831 = D.43828 + D.43830;
  iftmp.6 = *D.43831;
  <D.43824>:
  D.43832 = *_A_a1;
  D.43825 = this->D.37308.func_ptr_.__delta;
  D.43826 = (sizetype) D.43825;
  D.43827 = D.43817 + D.43826;
  D.43815 = iftmp.6 (D.43827, D.43832);
  return D.43815;
}


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = float; T_functor = sigc::pointer_functor1<short int, void>; T_type1 = short int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = void] (struct retype_functor * const this, float _A_a1)
{
  const short int D.41012;
  short int D.43835;
  struct adaptor_type * D.43836;

  D.43835 = (short int) _A_a1;
  D.41012 = D.43835;
  try
    {
      D.43836 = &this->D.39038.functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<short int, void> >::operator()<const short int&> (D.43836, &D.41012);
    }
  finally
    {
      D.41012 = {CLOBBER};
    }
  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 = const short int&; T_functor = sigc::pointer_functor1<short int, void>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, const short int & _A_arg1)
{
  struct pointer_functor1 * D.43839;

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


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = short int; T_return = void; typename sigc::type_trait<T_base>::take = const short int&] (const struct pointer_functor1 * const this, const short int & _A_a1)
{
  void (*<T70a5>) (short int) D.43841;
  short int D.43842;
  int D.43843;

  D.43841 = this->func_ptr_;
  D.43842 = *_A_a1;
  D.43843 = (int) D.43842;
  D.43841 (D.43843);
  return;
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj&, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = int; T_return = float; T_obj = {anonymous}::foo; T_obj2 = {anonymous}::foo] (struct foo & _A_obj, struct 
{
  float foo::<T698f> (struct foo *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<float, {anonymous}::foo, 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 = float; T_obj = {anonymous}::foo; T_arg1 = int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = float ({anonymous}::foo::*)(int)] (struct bound_mem_functor1 * const this, struct foo & _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.43847;
  struct limit_reference * D.43848;

  D.43847 = &this->D.36344;
  sigc::mem_functor1<float, {anonymous}::foo, int>::mem_functor1 (D.43847, _A_func);
  D.43848 = &this->obj_;
  sigc::limit_reference<{anonymous}::foo, true>::limit_reference (D.43848, _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 = float; T_obj = {anonymous}::foo; T_arg1 = int; sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type = float ({anonymous}::foo::*)(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}::foo] (struct limit_reference * const this, struct foo & _A_target)
{
  struct trackable * D.43849;

  D.43849 = &_A_target->D.36180;
  this->visited = D.43849;
  this->invoked = _A_target;
}


sigc::retype_functor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1> sigc::retype(const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_return = float; T_obj = {anonymous}::foo; T_arg1 = int] (const struct bound_mem_functor1 & _A_functor)
{
  sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (&<retval>, _A_functor);
  return <retval>;
}


sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::retype_functor(typename sigc::type_trait<T_base>::take) [with T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>; T_type1 = int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::type_trait<T_base>::take = const sigc::bound_mem_functor1<float, {anonymous}::foo, int>&] (struct retype_functor * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adapts * D.43852;

  D.43852 = &this->D.37185;
  sigc::adapts<sigc::bound_mem_functor1<float, {anonymous}::foo, int> >::adapts (D.43852, _A_functor);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>] (struct adapts * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adaptor_type * D.43853;

  sigc::adaptor_base::adaptor_base (this);
  D.43853 = &this->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int> >::adaptor_functor (D.43853, _A_functor);
}


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


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


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = float] (struct slot * const this, const struct retype_functor & _A_func)
{
  struct slot1 * D.43854;

  D.43854 = &this->D.39181;
  sigc::slot1<float, float>::slot1<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.43854, _A_func);
  try
    {

    }
  catch
    {
      D.43854 = &this->D.39181;
      sigc::slot1<float, float>::~slot1 (D.43854);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = float] (struct slot1 * const this, const struct retype_functor & _A_func)
{
  void * D.41468;
  struct slot_base * D.43855;
  struct rep_type * D.43856;
  void * (*<T1711>) (void *) D.43857;

  D.41468 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.41468, _A_func);
    }
  catch
    {
      operator delete (D.41468);
    }
  D.43855 = &this->D.39139;
  sigc::slot_base::slot_base (D.43855, D.41468);
  try
    {
      D.43856 = this->D.39139.rep_;
      D.43857 = sigc::internal::slot_call1<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, float, float>::address ();
      D.43856->call_ = D.43857;
    }
  catch
    {
      D.43855 = &this->D.39139;
      sigc::slot_base::~slot_base (D.43855);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct retype_functor & functor)
{
  struct slot_rep * D.43860;
  struct adaptor_type * D.43861;
  struct slot_do_bind D.41909;

  D.43860 = &this->D.41456;
  sigc::internal::slot_rep::slot_rep (D.43860, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.43861 = &this->functor_;
      D.43860 = &this->D.41456;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41909, D.43860);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.41909, D.43861);
        }
      finally
        {
          D.41909 = {CLOBBER};
        }
    }
  catch
    {
      D.43860 = &this->D.41456;
      sigc::internal::slot_rep::~slot_rep (D.43860);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.43864;
  void * D.42038;
  struct slot_rep * a_rep;

  a_rep = data;
  D.42038 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.42038, a_rep);
    }
  catch
    {
      operator delete (D.42038);
    }
  D.43864 = D.42038;
  return D.43864;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.43868;
  struct slot_rep * D.43869;
  struct adaptor_type * D.43870;
  struct slot_do_bind D.42782;

  D.43868 = cl->D.41456.call_;
  D.43869 = &this->D.41456;
  sigc::internal::slot_rep::slot_rep (D.43869, D.43868, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.43870 = &this->functor_;
      D.43869 = &this->D.41456;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42782, D.43869);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42782, D.43870);
        }
      finally
        {
          D.42782 = {CLOBBER};
        }
    }
  catch
    {
      D.43869 = &this->D.41456;
      sigc::internal::slot_rep::~slot_rep (D.43869);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.43873;
  struct slot_do_unbind D.42023;
  void * D.43874;
  struct self * self_;

  self_ = data;
  self_->D.41456.call_ = 0B;
  self_->D.41456.destroy_ = 0B;
  D.43873 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42023, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42023, D.43873);
    }
  finally
    {
      D.42023 = {CLOBBER};
    }
  D.43874 = 0B;
  return D.43874;
}


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct retype_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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>; T_type1 = int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.43878;

  D.43878 = &_A_target->D.37185.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int> > > (_A_action, D.43878);
}


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<float, {anonymous}::foo, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, 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<float, {anonymous}::foo, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.43879;

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


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<float, {anonymous}::foo, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<float, {anonymous}::foo, 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 = float; T_obj = {anonymous}::foo; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.43880;

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


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}::foo, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::foo, 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}::foo; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.43881;

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


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

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


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

  D.43884 = &_A_action->action_;
  sigc::internal::slot_do_unbind::operator() (D.43884, _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.43885;

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


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

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


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct retype_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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>; T_type1 = int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.43888;

  D.43888 = &_A_target->D.37185.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int> > > (_A_action, D.43888);
}


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<float, {anonymous}::foo, int> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, 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<float, {anonymous}::foo, int>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.43889;

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


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<float, {anonymous}::foo, int>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<float, {anonymous}::foo, 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 = float; T_obj = {anonymous}::foo; T_arg1 = int] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.43890;

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


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}::foo, true>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::foo, 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}::foo; bool I_derives_trackable = true] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct trackable & D.43891;

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


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

  D.43892 = &_A_action->action_;
  sigc::internal::slot_do_bind::operator() (D.43892, _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.43893;

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


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

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


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

  D.43897 = this->destroy_;
  if (D.43897 != 0B) goto <D.43898>; else goto <D.43899>;
  <D.43898>:
  D.43897 = this->destroy_;
  D.43897 (this);
  goto <D.43900>;
  <D.43899>:
  <D.43900>:
}


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

  D.43901 = call_it;
  return D.43901;
}


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = float; typename sigc::type_trait<T_arg3>::take = const float&] (struct slot_rep * rep, const float & a_1)
{
  float D.43903;
  struct adaptor_type * D.43904;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.43904 = &typed_rep->functor_;
  D.43903 = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<const float&> (D.43904, a_1);
  return D.43903;
}


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = const float&; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, int>; T_type1 = int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = float] (struct retype_functor * const this, const float & _A_a1)
{
  type D.43907;
  const int D.42804;
  float D.43908;
  int D.43909;
  struct adaptor_type * D.43910;

  D.43908 = *_A_a1;
  D.43909 = (int) D.43908;
  D.42804 = D.43909;
  try
    {
      D.43910 = &this->D.37185.functor_;
      D.43907 = sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, int> >::operator()<const int&> (D.43910, &D.42804);
      return D.43907;
    }
  finally
    {
      D.42804 = {CLOBBER};
    }
}


sigc::bound_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj&, T_return (T_obj2::*)(T_arg1)) [with T_arg1 = float; T_return = float; T_obj = {anonymous}::foo; T_obj2 = {anonymous}::foo] (struct foo & _A_obj, struct 
{
  float foo::<T6993> (struct foo *, float) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_mem_functor1<float, {anonymous}::foo, float>::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 = float; T_obj = {anonymous}::foo; T_arg1 = float; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = float ({anonymous}::foo::*)(float)] (struct bound_mem_functor1 * const this, struct foo & _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.43917;
  struct limit_reference * D.43918;

  D.43917 = &this->D.37308;
  sigc::mem_functor1<float, {anonymous}::foo, float>::mem_functor1 (D.43917, _A_func);
  D.43918 = &this->obj_;
  sigc::limit_reference<{anonymous}::foo, true>::limit_reference (D.43918, _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 = float; T_obj = {anonymous}::foo; T_arg1 = float; sigc::mem_functor1<T_arg1, T_return, T_obj>::function_type = float ({anonymous}::foo::*)(float)] (struct mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::retype_functor<sigc::bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1> sigc::retype(const sigc::bound_mem_functor1<T_return, T_obj, T_arg1>&) [with T_return = float; T_obj = {anonymous}::foo; T_arg1 = float] (const struct bound_mem_functor1 & _A_functor)
{
  sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (&<retval>, _A_functor);
  return <retval>;
}


sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::retype_functor(typename sigc::type_trait<T_base>::take) [with T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::type_trait<T_base>::take = const sigc::bound_mem_functor1<float, {anonymous}::foo, float>&] (struct retype_functor * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adapts * D.43921;

  D.43921 = &this->D.38135;
  sigc::adapts<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::adapts (D.43921, _A_functor);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>] (struct adapts * const this, const struct bound_mem_functor1 & _A_functor)
{
  struct adaptor_type * D.43922;

  sigc::adaptor_base::adaptor_base (this);
  D.43922 = &this->functor_;
  sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::adaptor_functor (D.43922, _A_functor);
}


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


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int] (struct slot * const this, const struct retype_functor & _A_func)
{
  struct slot1 * D.43923;

  D.43923 = &this->D.39330;
  sigc::slot1<float, int>::slot1<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.43923, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int] (struct slot1 * const this, const struct retype_functor & _A_func)
{
  void * D.41545;
  struct slot_base * D.43924;
  struct rep_type * D.43925;
  void * (*<T1711>) (void *) D.43926;

  D.41545 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.41545, _A_func);
    }
  catch
    {
      operator delete (D.41545);
    }
  D.43924 = &this->D.39288;
  sigc::slot_base::slot_base (D.43924, D.41545);
  try
    {
      D.43925 = this->D.39288.rep_;
      D.43926 = sigc::internal::slot_call1<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, float, int>::address ();
      D.43925->call_ = D.43926;
    }
  catch
    {
      D.43924 = &this->D.39288;
      sigc::slot_base::~slot_base (D.43924);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct retype_functor & functor)
{
  struct slot_rep * D.43929;
  struct adaptor_type * D.43930;
  struct slot_do_bind D.41918;

  D.43929 = &this->D.41533;
  sigc::internal::slot_rep::slot_rep (D.43929, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.43930 = &this->functor_;
      D.43929 = &this->D.41533;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41918, D.43929);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.41918, D.43930);
        }
      finally
        {
          D.41918 = {CLOBBER};
        }
    }
  catch
    {
      D.43929 = &this->D.41533;
      sigc::internal::slot_rep::~slot_rep (D.43929);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.43933;
  void * D.42243;
  struct slot_rep * a_rep;

  a_rep = data;
  D.42243 = operator new (96);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.42243, a_rep);
    }
  catch
    {
      operator delete (D.42243);
    }
  D.43933 = D.42243;
  return D.43933;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.43937;
  struct slot_rep * D.43938;
  struct adaptor_type * D.43939;
  struct slot_do_bind D.42814;

  D.43937 = cl->D.41533.call_;
  D.43938 = &this->D.41533;
  sigc::internal::slot_rep::slot_rep (D.43938, D.43937, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.43939 = &this->functor_;
      D.43938 = &this->D.41533;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42814, D.43938);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42814, D.43939);
        }
      finally
        {
          D.42814 = {CLOBBER};
        }
    }
  catch
    {
      D.43938 = &this->D.41533;
      sigc::internal::slot_rep::~slot_rep (D.43938);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.43942;
  struct slot_do_unbind D.42228;
  void * D.43943;
  struct self * self_;

  self_ = data;
  self_->D.41533.call_ = 0B;
  self_->D.41533.destroy_ = 0B;
  D.43942 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42228, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42228, D.43942);
    }
  finally
    {
      D.42228 = {CLOBBER};
    }
  D.43943 = 0B;
  return D.43943;
}


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct retype_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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.43947;

  D.43947 = &_A_target->D.38135.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> > > (_A_action, D.43947);
}


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<float, {anonymous}::foo, float> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> > >::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<float, {anonymous}::foo, float>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.43948;

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


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<float, {anonymous}::foo, float>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::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 = float; T_obj = {anonymous}::foo; T_arg1 = float] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.43949;

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


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct retype_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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.43951;

  D.43951 = &_A_target->D.38135.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> > > (_A_action, D.43951);
}


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<float, {anonymous}::foo, float> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> > >::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<float, {anonymous}::foo, float>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct bound_mem_functor1 * D.43952;

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


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<float, {anonymous}::foo, float>] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_functor)
{
  sigc::visitor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::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 = float; T_obj = {anonymous}::foo; T_arg1 = float] (const struct limit_derived_target & _A_action, const struct bound_mem_functor1 & _A_target)
{
  const struct limit_reference * D.43953;

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


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

  D.43954 = call_it;
  return D.43954;
}


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::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  float D.43956;
  struct adaptor_type * D.43957;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.43957 = &typed_rep->functor_;
  D.43956 = sigc::retype_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<const int&> (D.43957, a_1);
  return D.43956;
}


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = const int&; T_functor = sigc::bound_mem_functor1<float, {anonymous}::foo, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = float] (struct retype_functor * const this, const int & _A_a1)
{
  type D.43960;
  const float D.42833;
  int D.43961;
  float D.43962;
  struct adaptor_type * D.43963;

  D.43961 = *_A_a1;
  D.43962 = (float) D.43961;
  D.42833 = D.43962;
  try
    {
      D.43963 = &this->D.38135.functor_;
      D.43960 = sigc::adaptor_functor<sigc::bound_mem_functor1<float, {anonymous}::foo, float> >::operator()<const float&> (D.43963, &D.42833);
      return D.43960;
    }
  finally
    {
      D.42833 = {CLOBBER};
    }
}


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = short int; T_return = void] (void (*<T70a5>) (short int) _A_func)
{
  struct pointer_functor1 D.43968;
  struct pointer_functor1 D.40878;

  sigc::pointer_functor1<short int, void>::pointer_functor1 (&D.40878, _A_func);
  try
    {
      D.43968 = D.40878;
      return D.43968;
    }
  finally
    {
      D.40878 = {CLOBBER};
    }
}


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


sigc::retype_functor<sigc::pointer_functor1<T_arg1, T_return>, T_arg1> sigc::retype(const sigc::pointer_functor1<T_arg1, T_return>&) [with T_arg1 = short int; T_return = void] (const struct pointer_functor1 & _A_functor)
{
  sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (&<retval>, _A_functor);
  return <retval>;
}


sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::retype_functor(typename sigc::type_trait<T_base>::take) [with T_functor = sigc::pointer_functor1<short int, void>; T_type1 = short int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor1<short int, void>&] (struct retype_functor * const this, const struct pointer_functor1 & _A_functor)
{
  struct adapts * D.43973;

  D.43973 = &this->D.39038;
  sigc::adapts<sigc::pointer_functor1<short int, void> >::adapts (D.43973, _A_functor);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::pointer_functor1<short int, void>] (struct adapts * const this, const struct pointer_functor1 & _A_functor)
{
  struct adaptor_type * D.43974;

  sigc::adaptor_base::adaptor_base (this);
  D.43974 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<short int, void> >::adaptor_functor (D.43974, _A_functor);
}


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


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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = double] (struct slot * const this, const struct retype_functor & _A_func)
{
  struct slot1 * D.43975;

  D.43975 = &this->D.39486;
  sigc::slot1<void, double>::slot1<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.43975, _A_func);
  try
    {

    }
  catch
    {
      D.43975 = &this->D.39486;
      sigc::slot1<void, double>::~slot1 (D.43975);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = double] (struct slot1 * const this, const struct retype_functor & _A_func)
{
  void * D.41628;
  struct slot_base * D.43976;
  struct rep_type * D.43977;
  void * (*<T1711>) (void *) D.43978;

  D.41628 = operator new (72);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.41628, _A_func);
    }
  catch
    {
      operator delete (D.41628);
    }
  D.43976 = &this->D.39444;
  sigc::slot_base::slot_base (D.43976, D.41628);
  try
    {
      D.43977 = this->D.39444.rep_;
      D.43978 = sigc::internal::slot_call1<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void, double>::address ();
      D.43977->call_ = D.43978;
    }
  catch
    {
      D.43976 = &this->D.39444;
      sigc::slot_base::~slot_base (D.43976);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct retype_functor & functor)
{
  struct slot_rep * D.43981;
  struct adaptor_type * D.43982;
  struct slot_do_bind D.41927;

  D.43981 = &this->D.41610;
  sigc::internal::slot_rep::slot_rep (D.43981, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.43982 = &this->functor_;
      D.43981 = &this->D.41610;
      sigc::internal::slot_do_bind::slot_do_bind (&D.41927, D.43981);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.41927, D.43982);
        }
      finally
        {
          D.41927 = {CLOBBER};
        }
    }
  catch
    {
      D.43981 = &this->D.41610;
      sigc::internal::slot_rep::~slot_rep (D.43981);
    }
}


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

  a_rep = data;
  D.42416 = operator new (72);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.42416, a_rep);
    }
  catch
    {
      operator delete (D.42416);
    }
  D.43985 = D.42416;
  return D.43985;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.43989;
  struct slot_rep * D.43990;
  struct adaptor_type * D.43991;
  struct slot_do_bind D.42843;

  D.43989 = cl->D.41610.call_;
  D.43990 = &this->D.41610;
  sigc::internal::slot_rep::slot_rep (D.43990, D.43989, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.43991 = &this->functor_;
      D.43990 = &this->D.41610;
      sigc::internal::slot_do_bind::slot_do_bind (&D.42843, D.43990);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42843, D.43991);
        }
      finally
        {
          D.42843 = {CLOBBER};
        }
    }
  catch
    {
      D.43990 = &this->D.41610;
      sigc::internal::slot_rep::~slot_rep (D.43990);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.43994;
  struct slot_do_unbind D.42401;
  void * D.43995;
  struct self * self_;

  self_ = data;
  self_->D.41610.call_ = 0B;
  self_->D.41610.destroy_ = 0B;
  D.43994 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42401, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42401, D.43994);
    }
  finally
    {
      D.42401 = {CLOBBER};
    }
  D.43995 = 0B;
  return D.43995;
}


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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct retype_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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::pointer_functor1<short int, void>; T_type1 = short int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.43999;

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


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<short int, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<short int, void> > >::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<short int, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.44000;

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


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<short int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<short int, void> >::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<short int, void>] (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<short int, void> > (_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<short int, void>; 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<short int, void>, 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<short int, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct pointer_functor1 & D.43420, const struct limit_derived_target & D.43421)
{
  GIMPLE_NOP
}


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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct retype_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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::pointer_functor1<short int, void>; T_type1 = short int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.44002;

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


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<short int, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor1<short int, void> > >::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<short int, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor1 * D.44003;

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


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<short int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<short int, void> >::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<short int, void>] (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<short int, void> > (_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<short int, void>; 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<short int, void>, 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<short int, void>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct pointer_functor1 & D.43375, const struct limit_derived_target & D.43376)
{
  GIMPLE_NOP
}


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

  D.44004 = call_it;
  return D.44004;
}


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::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; T_arg1 = double; typename sigc::type_trait<T_arg3>::take = const double&] (struct slot_rep * rep, const double & a_1)
{
  struct adaptor_type * D.44006;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.44006 = &typed_rep->functor_;
  sigc::retype_functor<sigc::pointer_functor1<short int, void>, short int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<const double&> (D.44006, a_1);
  return;
}


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = const double&; T_functor = sigc::pointer_functor1<short int, void>; T_type1 = short int; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = void] (struct retype_functor * const this, const double & _A_a1)
{
  const short int D.42862;
  double D.44008;
  short int D.44009;
  struct adaptor_type * D.44010;

  D.44008 = *_A_a1;
  D.44009 = (short int) D.44008;
  D.42862 = D.44009;
  try
    {
      D.44010 = &this->D.39038.functor_;
      sigc::adaptor_functor<sigc::pointer_functor1<short int, void> >::operator()<const short int&> (D.44010, &D.42862);
    }
  finally
    {
      D.42862 = {CLOBBER};
    }
  return;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = float; T_arg1 = float; sigc::slot1<T_return, T_arg1>::arg1_type_ = const float&] (const struct slot1 * const this, const float & _A_a1)
{
  bool retval.7;
  bool iftmp.8;
  const struct slot_base * D.44017;
  bool D.44018;
  bool D.44019;
  bool D.44021;
  bool D.44022;
  float D.44026;
  struct rep_type * D.44027;
  void * (*<T1711>) (void *) D.44028;

  D.44017 = &this->D.39139;
  D.44018 = sigc::slot_base::empty (D.44017);
  D.44019 = ~D.44018;
  if (D.44019 != 0) goto <D.44020>; else goto <D.44015>;
  <D.44020>:
  D.44017 = &this->D.39139;
  D.44021 = sigc::slot_base::blocked (D.44017);
  D.44022 = ~D.44021;
  if (D.44022 != 0) goto <D.44023>; else goto <D.44015>;
  <D.44023>:
  iftmp.8 = 1;
  goto <D.44016>;
  <D.44015>:
  iftmp.8 = 0;
  <D.44016>:
  retval.7 = iftmp.8;
  if (retval.7 != 0) goto <D.44024>; else goto <D.44025>;
  <D.44024>:
  D.44027 = this->D.39139.rep_;
  D.44028 = D.44027->call_;
  D.44027 = this->D.39139.rep_;
  D.44026 = D.44028 (D.44027, _A_a1);
  return D.44026;
  <D.44025>:
  D.44026 = 0.0;
  return D.44026;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.44031;
  bool iftmp.9;
  struct rep_type * D.44036;
  void * (*<T1711>) (void *) D.44038;

  D.44036 = this->rep_;
  if (D.44036 == 0B) goto <D.44033>; else goto <D.44037>;
  <D.44037>:
  D.44036 = this->rep_;
  D.44038 = D.44036->call_;
  if (D.44038 == 0B) goto <D.44033>; else goto <D.44034>;
  <D.44033>:
  iftmp.9 = 1;
  goto <D.44035>;
  <D.44034>:
  iftmp.9 = 0;
  <D.44035>:
  D.44031 = iftmp.9;
  return D.44031;
}


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

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


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = void; T_arg1 = double; sigc::slot1<T_return, T_arg1>::arg1_type_ = const double&] (const struct slot1 * const this, const double & _A_a1)
{
  bool retval.10;
  bool iftmp.11;
  const struct slot_base * D.44046;
  bool D.44047;
  bool D.44048;
  bool D.44050;
  bool D.44051;
  struct rep_type * D.44055;
  void * (*<T1711>) (void *) D.44056;

  D.44046 = &this->D.39444;
  D.44047 = sigc::slot_base::empty (D.44046);
  D.44048 = ~D.44047;
  if (D.44048 != 0) goto <D.44049>; else goto <D.44044>;
  <D.44049>:
  D.44046 = &this->D.39444;
  D.44050 = sigc::slot_base::blocked (D.44046);
  D.44051 = ~D.44050;
  if (D.44051 != 0) goto <D.44052>; else goto <D.44044>;
  <D.44052>:
  iftmp.11 = 1;
  goto <D.44045>;
  <D.44044>:
  iftmp.11 = 0;
  <D.44045>:
  retval.10 = iftmp.11;
  if (retval.10 != 0) goto <D.44053>; else goto <D.44054>;
  <D.44053>:
  D.44055 = this->D.39444.rep_;
  D.44056 = D.44055->call_;
  D.44055 = this->D.39444.rep_;
  D.44056 (D.44055, _A_a1);
  return;
  <D.44054>:
  return;
}


sigc::retype_functor<sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::retype(const sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&) [with T_return = float; T_arg1 = float; T_arg2 = sigc::nil; T_arg3 = sigc::nil; T_arg4 = sigc::nil; T_arg5 = sigc::nil; T_arg6 = sigc::nil; T_arg7 = sigc::nil] (const struct slot & _A_functor)
{
  sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (<retval>, _A_functor);
  return <retval>;
}


sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::retype_functor(typename sigc::type_trait<T_base>::take) [with T_functor = sigc::slot<float, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::type_trait<T_base>::take = const sigc::slot<float, float>&] (struct retype_functor * const this, const struct slot & _A_functor)
{
  struct adapts * D.44060;

  D.44060 = &this->D.40373;
  sigc::adapts<sigc::slot<float, float> >::adapts (D.44060, _A_functor);
  try
    {

    }
  catch
    {
      D.44060 = &this->D.40373;
      sigc::adapts<sigc::slot<float, float> >::~adapts (D.44060);
    }
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::slot<float, float>] (struct adapts * const this, const struct slot & _A_functor)
{
  struct adaptor_type * D.44061;

  sigc::adaptor_base::adaptor_base (this);
  D.44061 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<float, float> >::adaptor_functor (D.44061, _A_functor);
  try
    {

    }
  catch
    {
      D.44061 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<float, float> >::~adaptor_functor (D.44061);
    }
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = sigc::slot<float, float>] (struct adaptor_functor * const this, const struct slot & _A_functor)
{
  struct slot * D.44062;

  sigc::adaptor_base::adaptor_base (this);
  D.44062 = &this->functor_;
  sigc::slot<float, float>::slot (D.44062, _A_functor);
  try
    {

    }
  catch
    {
      D.44062 = &this->functor_;
      sigc::slot<float, float>::~slot (D.44062);
    }
}


sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_return = float; T_arg1 = float] (struct slot * const this, const struct slot & src)
{
  struct slot1 * D.44063;

  D.44063 = &this->D.39181;
  sigc::slot1<float, float>::slot1 (D.44063, src);
  try
    {

    }
  catch
    {
      D.44063 = &this->D.39181;
      sigc::slot1<float, float>::~slot1 (D.44063);
    }
}


sigc::slot1<T_return, T_arg1>::slot1(const sigc::slot1<T_return, T_arg1>&) [with T_return = float; T_arg1 = float] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.44064;
  struct slot_base * D.44065;

  D.44064 = &src->D.39139;
  D.44065 = &this->D.39139;
  sigc::slot_base::slot_base (D.44065, D.44064);
  try
    {

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


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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int] (struct slot * const this, const struct retype_functor & _A_func)
{
  struct slot1 * D.44066;

  D.44066 = &this->D.39330;
  sigc::slot1<float, int>::slot1<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.44066, _A_func);
  try
    {

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int] (struct slot1 * const this, const struct retype_functor & _A_func)
{
  void * D.41714;
  struct slot_base * D.44067;
  struct rep_type * D.44068;
  void * (*<T1711>) (void *) D.44069;

  D.41714 = operator new (80);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.41714, _A_func);
    }
  catch
    {
      operator delete (D.41714);
    }
  D.44067 = &this->D.39288;
  sigc::slot_base::slot_base (D.44067, D.41714);
  try
    {
      D.44068 = this->D.39288.rep_;
      D.44069 = sigc::internal::slot_call1<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, float, int>::address ();
      D.44068->call_ = D.44069;
    }
  catch
    {
      D.44067 = &this->D.39288;
      sigc::slot_base::~slot_base (D.44067);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct retype_functor & functor)
{
  struct slot_rep * D.44072;
  struct adaptor_type * D.44073;
  struct slot_do_bind D.41957;

  D.44072 = &this->D.41696;
  sigc::internal::slot_rep::slot_rep (D.44072, 0B, destroy, dup);
  try
    {
      D.44073 = &this->functor_;
      sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (D.44073, functor);
      try
        {
          D.44073 = &this->functor_;
          D.44072 = &this->D.41696;
          sigc::internal::slot_do_bind::slot_do_bind (&D.41957, D.44072);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.41957, D.44073);
            }
          finally
            {
              D.41957 = {CLOBBER};
            }
        }
      catch
        {
          D.44073 = &this->functor_;
          sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~retype_functor (D.44073);
        }
    }
  catch
    {
      D.44072 = &this->D.41696;
      sigc::internal::slot_rep::~slot_rep (D.44072);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.44077;
  void * D.42583;
  struct slot_rep * a_rep;

  a_rep = data;
  D.42583 = operator new (80);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.42583, a_rep);
    }
  catch
    {
      operator delete (D.42583);
    }
  D.44077 = D.42583;
  return D.44077;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.44081;
  struct slot_rep * D.44082;
  const struct adaptor_type * D.44083;
  struct adaptor_type * D.44084;
  struct slot_do_bind D.42875;

  D.44081 = cl->D.41696.call_;
  D.44082 = &this->D.41696;
  sigc::internal::slot_rep::slot_rep (D.44082, D.44081, destroy, dup);
  try
    {
      D.44083 = &cl->functor_;
      D.44084 = &this->functor_;
      sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor (D.44084, D.44083);
      try
        {
          D.44084 = &this->functor_;
          D.44082 = &this->D.41696;
          sigc::internal::slot_do_bind::slot_do_bind (&D.42875, D.44082);
          try
            {
              sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42875, D.44084);
            }
          finally
            {
              D.42875 = {CLOBBER};
            }
        }
      catch
        {
          D.44084 = &this->functor_;
          sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~retype_functor (D.44084);
        }
    }
  catch
    {
      D.44082 = &this->D.41696;
      sigc::internal::slot_rep::~slot_rep (D.44082);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.44088;
  struct slot_do_unbind D.42577;
  void * D.44089;
  struct self * self_;

  self_ = data;
  self_->D.41696.call_ = 0B;
  self_->D.41696.destroy_ = 0B;
  D.44088 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.42577, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.42577, D.44088);
    }
  finally
    {
      D.42577 = {CLOBBER};
    }
  D.44088 = &self_->functor_;
  sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~retype_functor (D.44088);
  D.44089 = 0B;
  return D.44089;
}


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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct retype_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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::slot<float, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.44093;

  D.44093 = &_A_target->D.40373.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::slot<float, float> > > (_A_action, D.44093);
}


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::slot<float, float> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<float, float> > >::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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.44094;

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


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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct slot & _A_functor)
{
  sigc::visitor<sigc::slot<float, float> >::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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct slot & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::operator()<sigc::slot<float, float> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<float, float>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<float, float>, 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::slot<float, float>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct slot & D.43430, const struct limit_derived_target & D.43431)
{
  GIMPLE_NOP
}


sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::retype_functor(const sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) (struct retype_functor * const this, const struct retype_functor & D.41164)
{
  const struct adapts * D.44095;
  struct adapts * D.44096;

  D.44095 = &D.41164->D.40373;
  D.44096 = &this->D.40373;
  sigc::adapts<sigc::slot<float, float> >::adapts (D.44096, D.44095);
  try
    {

    }
  catch
    {
      D.44096 = &this->D.40373;
      sigc::adapts<sigc::slot<float, float> >::~adapts (D.44096);
    }
}


sigc::adapts<sigc::slot<float, float> >::adapts(const sigc::adapts<sigc::slot<float, float> >&) (struct adapts * const this, const struct adapts & D.41155)
{
  struct adaptor_type * D.44097;
  struct adaptor_type * D.44098;

  D.44097 = &D.41155->functor_;
  D.44098 = &this->functor_;
  sigc::adaptor_functor<sigc::slot<float, float> >::adaptor_functor (D.44098, D.44097);
  try
    {

    }
  catch
    {
      D.44098 = &this->functor_;
      sigc::adaptor_functor<sigc::slot<float, float> >::~adaptor_functor (D.44098);
    }
}


sigc::adaptor_functor<sigc::slot<float, float> >::adaptor_functor(const sigc::adaptor_functor<sigc::slot<float, float> >&) (struct adaptor_functor * const this, const struct adaptor_functor & D.41137)
{
  struct slot * D.44099;
  struct slot * D.44100;

  D.44099 = &D.41137->functor_;
  D.44100 = &this->functor_;
  sigc::slot<float, float>::slot (D.44100, D.44099);
  try
    {

    }
  catch
    {
      D.44100 = &this->functor_;
      sigc::slot<float, float>::~slot (D.44100);
    }
}


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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct retype_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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_functor)
{
  sigc::visitor<sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >::do_visit_each(const T_action&, const sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::slot<float, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil] (const struct limit_derived_target & _A_action, const struct retype_functor & _A_target)
{
  struct adaptor_type * D.44102;

  D.44102 = &_A_target->D.40373.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::slot<float, float> > > (_A_action, D.44102);
}


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::slot<float, float> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::slot<float, float> > >::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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct slot * D.44103;

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


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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct slot & _A_functor)
{
  sigc::visitor<sigc::slot<float, float> >::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::slot<float, float>] (const struct limit_derived_target & _A_action, const struct slot & _A_functor)
{
  sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::operator()<sigc::slot<float, float> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = sigc::slot<float, float>; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct slot & _A_type)
{
  sigc::internal::with_type_pointer<false, sigc::slot<float, float>, 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::slot<float, float>; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct slot & D.43403, const struct limit_derived_target & D.43404)
{
  GIMPLE_NOP
}


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

  D.44104 = call_it;
  return D.44104;
}


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::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = float; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (struct slot_rep * rep, const int & a_1)
{
  float D.44106;
  struct adaptor_type * D.44107;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.44107 = &typed_rep->functor_;
  D.44106 = sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<const int&> (D.44107, a_1);
  return D.44106;
}


typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()(T_arg1) [with T_arg1 = const int&; T_functor = sigc::slot<float, float>; T_type1 = float; T_type2 = sigc::nil; T_type3 = sigc::nil; T_type4 = sigc::nil; T_type5 = sigc::nil; T_type6 = sigc::nil; T_type7 = sigc::nil; typename sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1>::type = float] (struct retype_functor * const this, const int & _A_a1)
{
  type D.44110;
  const float D.43015;
  int D.44111;
  float D.44112;
  struct adaptor_type * D.44113;

  D.44111 = *_A_a1;
  D.44112 = (float) D.44111;
  D.43015 = D.44112;
  try
    {
      D.44113 = &this->D.40373.functor_;
      D.44110 = sigc::adaptor_functor<sigc::slot<float, float> >::operator()<const float&> (D.44113, &D.43015);
      return D.44110;
    }
  finally
    {
      D.43015 = {CLOBBER};
    }
}


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 float&; T_functor = sigc::slot<float, float>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = float] (const struct adaptor_functor * const this, const float & _A_arg1)
{
  type D.44118;
  struct slot1 * D.44119;

  D.44119 = &this->functor_.D.39181;
  D.44118 = sigc::slot1<float, float>::operator() (D.44119, _A_arg1);
  return D.44118;
}


sigc::slot<float, int>& sigc::slot<float, int>::operator=(const sigc::slot<float, int>&) (struct slot * const this, const struct slot & D.40434)
{
  const struct slot1 * D.44122;
  struct slot1 * D.44123;
  struct slot & D.44124;

  D.44122 = &D.40434->D.39330;
  D.44123 = &this->D.39330;
  sigc::slot1<float, int>::operator= (D.44123, D.44122);
  D.44124 = this;
  return D.44124;
}


sigc::slot1<T_return, T_arg1>& sigc::slot1<T_return, T_arg1>::operator=(const sigc::slot1<T_return, T_arg1>&) [with T_return = float; T_arg1 = int] (struct slot1 * const this, const struct slot1 & src)
{
  const struct slot_base * D.44126;
  struct slot_base * D.44127;
  struct slot1 & D.44128;

  D.44126 = &src->D.39288;
  D.44127 = &this->D.39288;
  sigc::slot_base::operator= (D.44127, D.44126);
  D.44128 = this;
  return D.44128;
}


T_return sigc::slot1<T_return, T_arg1>::operator()(sigc::slot1<T_return, T_arg1>::arg1_type_) const [with T_return = float; T_arg1 = int; sigc::slot1<T_return, T_arg1>::arg1_type_ = const int&] (const struct slot1 * const this, const int & _A_a1)
{
  bool retval.12;
  bool iftmp.13;
  const struct slot_base * D.44134;
  bool D.44135;
  bool D.44136;
  bool D.44138;
  bool D.44139;
  float D.44143;
  struct rep_type * D.44144;
  void * (*<T1711>) (void *) D.44145;

  D.44134 = &this->D.39288;
  D.44135 = sigc::slot_base::empty (D.44134);
  D.44136 = ~D.44135;
  if (D.44136 != 0) goto <D.44137>; else goto <D.44132>;
  <D.44137>:
  D.44134 = &this->D.39288;
  D.44138 = sigc::slot_base::blocked (D.44134);
  D.44139 = ~D.44138;
  if (D.44139 != 0) goto <D.44140>; else goto <D.44132>;
  <D.44140>:
  iftmp.13 = 1;
  goto <D.44133>;
  <D.44132>:
  iftmp.13 = 0;
  <D.44133>:
  retval.12 = iftmp.13;
  if (retval.12 != 0) goto <D.44141>; else goto <D.44142>;
  <D.44141>:
  D.44144 = this->D.39288.rep_;
  D.44145 = D.44144->call_;
  D.44144 = this->D.39288.rep_;
  D.44143 = D.44145 (D.44144, _A_a1);
  return D.44143;
  <D.44142>:
  D.44143 = 0.0;
  return D.44143;
}


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.44148;
  double D.44149;

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


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

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

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


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

  try
    {
      {

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


sigc::retype_functor<sigc::slot<float, float>, float, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~retype_functor() (struct retype_functor * const this)
{
  struct adapts * D.44156;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44156 = &this->D.40373;
            sigc::adapts<sigc::slot<float, float> >::~adapts (D.44156);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40430>:
}


sigc::adapts<sigc::slot<float, float> >::~adapts() (struct adapts * const this)
{
  struct adaptor_type * D.44158;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44158 = &this->functor_;
            sigc::adaptor_functor<sigc::slot<float, float> >::~adaptor_functor (D.44158);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40425>:
}


sigc::adaptor_functor<sigc::slot<float, float> >::~adaptor_functor() (struct adaptor_functor * const this)
{
  struct slot * D.44160;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44160 = &this->functor_;
            sigc::slot<float, float>::~slot (D.44160);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40420>:
}


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.40719;
  struct _Rep * D.44162;
  struct _Alloc_hider * D.44163;

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


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

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

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


__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.44172;

  try
    {
      {

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


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.44173;
  char * D.44174;

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


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

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


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.14;
  struct _Rep & D.44180;
  bool D.44181;
  long int D.44182;
  long int D.44183;
  bool retval.15;
  _Atomic_word * D.44187;
  int D.44188;

  D.44180 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.44181 = D.44180 != this;
  D.44182 = (long int) D.44181;
  D.44183 = __builtin_expect (D.44182, 0);
  retval.14 = D.44183 != 0;
  if (retval.14 != 0) goto <D.44184>; else goto <D.44185>;
  <D.44184>:
  D.44187 = &this->D.11865._M_refcount;
  D.44188 = __gnu_cxx::__exchange_and_add_dispatch (D.44187, -1);
  retval.15 = D.44188 <= 0;
  if (retval.15 != 0) goto <D.44189>; else goto <D.44190>;
  <D.44189>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.44191>;
  <D.44190>:
  <D.44191>:
  goto <D.44192>;
  <D.44185>:
  <D.44192>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.16;
  int D.44197;
  _Atomic_word D.44200;

  D.44197 = __gthread_active_p ();
  retval.16 = D.44197 != 0;
  if (retval.16 != 0) goto <D.44198>; else goto <D.44199>;
  <D.44198>:
  D.44200 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.44200;
  <D.44199>:
  D.44200 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.44200;
}


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

  D.44203 = __gthrw___pthread_key_create != 0B;
  D.44202 = (int) D.44203;
  return D.44202;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.44205;
  unsigned int __val.17;
  unsigned int D.44207;

  __val.17 = (unsigned int) __val;
  D.44207 = __atomic_fetch_add_4 (__mem, __val.17, 4);
  D.44205 = (_Atomic_word) D.44207;
  return D.44205;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.44209;
  int D.44210;
  _Atomic_word D.44211;
  _Atomic_word __result;

  __result = *__mem;
  D.44209 = *__mem;
  D.44210 = D.44209 + __val;
  *__mem = D.44210;
  D.44211 = __result;
  return D.44211;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<void, double>::~slot() (struct slot * const this)
{
  struct slot1 * D.44215;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44215 = &this->D.39486;
            sigc::slot1<void, double>::~slot1 (D.44215);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39529>:
}


sigc::slot1<void, double>::~slot1() (struct slot1 * const this)
{
  struct slot_base * D.44217;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44217 = &this->D.39444;
            sigc::slot_base::~slot_base (D.44217);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39524>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44219 = &this->D.39330;
            sigc::slot1<float, int>::~slot1 (D.44219);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39373>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44221 = &this->D.39288;
            sigc::slot_base::~slot_base (D.44221);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39368>:
}


sigc::slot<float, float>::~slot() (struct slot * const this)
{
  struct slot1 * D.44223;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44223 = &this->D.39181;
            sigc::slot1<float, float>::~slot1 (D.44223);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39224>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44225 = &this->D.39139;
            sigc::slot_base::~slot_base (D.44225);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39219>:
}


{anonymous}::foo::~foo() (struct foo * const this)
{
  struct trackable * D.44227;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.44227 = &this->D.36180;
            sigc::trackable::~trackable (D.44227);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.36224>:
}


(static initializers for test_retype.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.44229>; else goto <D.44230>;
  <D.44229>:
  if (__priority == 65535) goto <D.44231>; else goto <D.44232>;
  <D.44231>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.44233>;
  <D.44232>:
  <D.44233>:
  goto <D.44234>;
  <D.44230>:
  <D.44234>:
}


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.18;
  const void * * D.44238;
  sizetype iftmp.19;
  int (*__vtbl_ptr_type) () * D.44243;
  int (*__vtbl_ptr_type) () * D.44244;
  long int D.44245;
  struct basic_ios * D.44247;
  int (*__vtbl_ptr_type) () * iftmp.20;
  struct __stringbuf_type * D.44252;
  const void * * iftmp.21;
  struct basic_ostream * D.44257;
  int D.44258;
  struct basic_ios * D.44261;
  int D.44263;

  {
    if (2 == 0) goto <D.44236>; else goto <D.44237>;
    <D.44236>:
    D.44238 = 0B;
    iftmp.18 = *D.44238;
    goto <D.44239>;
    <D.44237>:
    iftmp.18 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.44239>:
    this->D.22312._vptr.basic_ostream = iftmp.18;
    if (2 == 0) goto <D.44241>; else goto <D.44242>;
    <D.44241>:
    D.44243 = this->D.22312._vptr.basic_ostream;
    D.44244 = D.44243 + 18446744073709551592;
    D.44245 = MEM[(long int *)D.44244];
    iftmp.19 = (sizetype) D.44245;
    goto <D.44246>;
    <D.44242>:
    iftmp.19 = 88;
    <D.44246>:
    D.44247 = this + iftmp.19;
    if (2 == 0) goto <D.44249>; else goto <D.44250>;
    <D.44249>:
    iftmp.20 = MEM[(const void * *)0B + 24B];
    goto <D.44251>;
    <D.44250>:
    iftmp.20 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.44251>:
    D.44247->D.19008._vptr.ios_base = iftmp.20;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.44252 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.44252);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.44254>; else goto <D.44255>;
                <D.44254>:
                iftmp.21 = 8B;
                goto <D.44256>;
                <D.44255>:
                iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.44256>:
                D.44257 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.44257, iftmp.21);
              }
          }
        finally
          {
            D.44258 = 2;
            if (D.44258 != 0) goto <D.44259>; else goto <D.44260>;
            <D.44259>:
            D.44261 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.44261);
            goto <D.44262>;
            <D.44260>:
            <D.44262>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.43512>:
  D.44263 = 0;
  if (D.44263 != 0) goto <D.44264>; else goto <D.44265>;
  <D.44264>:
  operator delete (this);
  goto <D.44266>;
  <D.44265>:
  <D.44266>:
}


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.43514>:
  operator delete (this);
}


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.44276;
  struct basic_streambuf * D.44277;
  int D.44278;

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

              }
            finally
              {
                D.44276 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.44276);
              }
          }
        finally
          {
            D.44277 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.44277);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.40534>:
  D.44278 = 0;
  if (D.44278 != 0) goto <D.44279>; else goto <D.44280>;
  <D.44279>:
  operator delete (this);
  goto <D.44281>;
  <D.44280>:
  <D.44281>:
}


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

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

          }
        finally
          {
            D.44284 = &this->_M_buf_locale;
            std::locale::~locale (D.44284);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41255>:
  D.44285 = 0;
  if (D.44285 != 0) goto <D.44286>; else goto <D.44287>;
  <D.44286>:
  operator delete (this);
  goto <D.44288>;
  <D.44287>:
  <D.44288>:
}


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.41259>:
  operator delete (this);
}


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.40538>:
  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.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.44296;
  int (*__vtbl_ptr_type) () * D.44297;
  long int D.44298;
  struct basic_ios * D.44300;
  int (*__vtbl_ptr_type) () * iftmp.24;
  int D.44305;
  struct basic_ios * D.44308;
  int D.44310;

  {
    if (0 == 0) goto <D.44290>; else goto <D.44291>;
    <D.44290>:
    iftmp.22 = *__vtt_parm;
    goto <D.44292>;
    <D.44291>:
    iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
    <D.44292>:
    this->_vptr.basic_ostream = iftmp.22;
    if (0 == 0) goto <D.44294>; else goto <D.44295>;
    <D.44294>:
    D.44296 = this->_vptr.basic_ostream;
    D.44297 = D.44296 + 18446744073709551592;
    D.44298 = MEM[(long int *)D.44297];
    iftmp.23 = (sizetype) D.44298;
    goto <D.44299>;
    <D.44295>:
    iftmp.23 = 8;
    <D.44299>:
    D.44300 = this + iftmp.23;
    if (0 == 0) goto <D.44302>; else goto <D.44303>;
    <D.44302>:
    iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.44304>;
    <D.44303>:
    iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
    <D.44304>:
    D.44300->D.19008._vptr.ios_base = iftmp.24;
    try
      {
        try
          {

          }
        finally
          {
            D.44305 = 0;
            if (D.44305 != 0) goto <D.44306>; else goto <D.44307>;
            <D.44306>:
            D.44308 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.44308);
            goto <D.44309>;
            <D.44307>:
            <D.44309>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41240>:
  D.44310 = 0;
  if (D.44310 != 0) goto <D.44311>; else goto <D.44312>;
  <D.44311>:
  operator delete (this);
  goto <D.44313>;
  <D.44312>:
  <D.44313>:
}


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

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

          }
        finally
          {
            D.44315 = &this->D.19008;
            std::ios_base::~ios_base (D.44315);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41228>:
  D.44316 = 0;
  if (D.44316 != 0) goto <D.44317>; else goto <D.44318>;
  <D.44317>:
  operator delete (this);
  goto <D.44319>;
  <D.44318>:
  <D.44319>:
}


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.41232>:
  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.44323;
  const void * * iftmp.25;
  struct basic_ostream * D.44329;
  int (*__vtbl_ptr_type) () * iftmp.26;
  const void * * D.44333;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.44338;
  int (*__vtbl_ptr_type) () * D.44339;
  long int D.44340;
  struct basic_ios * D.44342;
  int (*__vtbl_ptr_type) () * iftmp.28;
  _Ios_Openmode D.44347;
  struct __stringbuf_type * D.44348;
  struct basic_streambuf * D.44349;
  sizetype iftmp.29;
  struct basic_ios * D.44354;
  const void * * iftmp.30;

  if (1 != 0) goto <D.44321>; else goto <D.44322>;
  <D.44321>:
  D.44323 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.44323);
  goto <D.44324>;
  <D.44322>:
  <D.44324>:
  try
    {
      if (1 == 0) goto <D.44326>; else goto <D.44327>;
      <D.44326>:
      iftmp.25 = 8B;
      goto <D.44328>;
      <D.44327>:
      iftmp.25 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.44328>:
      D.44329 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.44329, iftmp.25);
      try
        {
          if (1 == 0) goto <D.44331>; else goto <D.44332>;
          <D.44331>:
          D.44333 = 0B;
          iftmp.26 = *D.44333;
          goto <D.44334>;
          <D.44332>:
          iftmp.26 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.44334>:
          this->D.22312._vptr.basic_ostream = iftmp.26;
          if (1 == 0) goto <D.44336>; else goto <D.44337>;
          <D.44336>:
          D.44338 = this->D.22312._vptr.basic_ostream;
          D.44339 = D.44338 + 18446744073709551592;
          D.44340 = MEM[(long int *)D.44339];
          iftmp.27 = (sizetype) D.44340;
          goto <D.44341>;
          <D.44337>:
          iftmp.27 = 88;
          <D.44341>:
          D.44342 = this + iftmp.27;
          if (1 == 0) goto <D.44344>; else goto <D.44345>;
          <D.44344>:
          iftmp.28 = MEM[(const void * *)0B + 24B];
          goto <D.44346>;
          <D.44345>:
          iftmp.28 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.44346>:
          D.44342->D.19008._vptr.ios_base = iftmp.28;
          D.44347 = std::operator| (__mode, 16);
          D.44348 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.44348, D.44347);
          try
            {
              D.44349 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.44351>; else goto <D.44352>;
              <D.44351>:
              D.44338 = this->D.22312._vptr.basic_ostream;
              D.44339 = D.44338 + 18446744073709551592;
              D.44340 = MEM[(long int *)D.44339];
              iftmp.29 = (sizetype) D.44340;
              goto <D.44353>;
              <D.44352>:
              iftmp.29 = 88;
              <D.44353>:
              D.44354 = this + iftmp.29;
              std::basic_ios<char>::init (D.44354, D.44349);
            }
          catch
            {
              D.44348 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.44348);
            }
        }
      catch
        {
          if (1 == 0) goto <D.44356>; else goto <D.44357>;
          <D.44356>:
          iftmp.30 = 8B;
          goto <D.44358>;
          <D.44357>:
          iftmp.30 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.44358>:
          D.44329 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.44329, iftmp.30);
        }
    }
  catch
    {
      if (1 != 0) goto <D.44359>; else goto <D.44360>;
      <D.44359>:
      D.44323 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.44323);
      goto <D.44361>;
      <D.44360>:
      <D.44361>:
    }
}


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

  D.44365 = &this->D.19008;
  std::ios_base::ios_base (D.44365);
  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.44365 = &this->D.19008;
      std::ios_base::~ios_base (D.44365);
    }
}


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.44368;
  int (*__vtbl_ptr_type) () * iftmp.31;
  sizetype iftmp.32;
  int (*__vtbl_ptr_type) () * D.44377;
  int (*__vtbl_ptr_type) () * D.44378;
  long int D.44379;
  struct basic_ios * D.44381;
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  struct basic_ios * D.44390;

  if (0 != 0) goto <D.44366>; else goto <D.44367>;
  <D.44366>:
  D.44368 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.44368);
  goto <D.44369>;
  <D.44367>:
  <D.44369>:
  try
    {
      if (0 == 0) goto <D.44371>; else goto <D.44372>;
      <D.44371>:
      iftmp.31 = *__vtt_parm;
      goto <D.44373>;
      <D.44372>:
      iftmp.31 = &MEM[(void *)&_ZTVSo + 24B];
      <D.44373>:
      this->_vptr.basic_ostream = iftmp.31;
      if (0 == 0) goto <D.44375>; else goto <D.44376>;
      <D.44375>:
      D.44377 = this->_vptr.basic_ostream;
      D.44378 = D.44377 + 18446744073709551592;
      D.44379 = MEM[(long int *)D.44378];
      iftmp.32 = (sizetype) D.44379;
      goto <D.44380>;
      <D.44376>:
      iftmp.32 = 8;
      <D.44380>:
      D.44381 = this + iftmp.32;
      if (0 == 0) goto <D.44383>; else goto <D.44384>;
      <D.44383>:
      iftmp.33 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.44385>;
      <D.44384>:
      iftmp.33 = &MEM[(void *)&_ZTVSo + 64B];
      <D.44385>:
      D.44381->D.19008._vptr.ios_base = iftmp.33;
      if (0 == 0) goto <D.44387>; else goto <D.44388>;
      <D.44387>:
      D.44377 = this->_vptr.basic_ostream;
      D.44378 = D.44377 + 18446744073709551592;
      D.44379 = MEM[(long int *)D.44378];
      iftmp.34 = (sizetype) D.44379;
      goto <D.44389>;
      <D.44388>:
      iftmp.34 = 8;
      <D.44389>:
      D.44390 = this + iftmp.34;
      std::basic_ios<char>::init (D.44390, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.44391>; else goto <D.44392>;
      <D.44391>:
      D.44368 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.44368);
      goto <D.44393>;
      <D.44392>:
      <D.44393>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.44395;
  int __a.35;
  int __b.36;
  int D.44398;

  __a.35 = (int) __a;
  __b.36 = (int) __b;
  D.44398 = __a.35 | __b.36;
  D.44395 = (_Ios_Openmode) D.44398;
  return D.44395;
}


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.44400;
  struct __string_type * D.44401;

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

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


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

  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.44403 = &this->_M_buf_locale;
  std::locale::locale (D.44403);
  try
    {

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


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.41783;
  struct _Rep & D.44404;
  char * D.44405;
  struct _Alloc_hider * D.44406;

  std::allocator<char>::allocator (&D.41783);
  try
    {
      D.44404 = std::basic_string<char>::_S_empty_rep ();
      D.44405 = std::basic_string<char>::_Rep::_M_refdata (D.44404);
      D.44406 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.44406, D.44405, &D.41783);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.41783);
      D.41783 = {CLOBBER};
    }
  try
    {

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


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

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


_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.44412;
  void * D.44413;

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


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);
    }
}


