int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.48155;
  int D.48158;
  int iftmp.1;
  bool D.48160;
  const int D.42627;
  double D.48164;
  struct basic_ostream & D.48165;
  const struct string D.42630;
  struct allocator D.42629;
  const char * iftmp.2;
  struct result_type D.43376;
  const int D.42631;
  bool D.48167;
  struct basic_ostream & D.48171;
  const struct string D.43379;
  struct allocator D.43378;
  struct iterator D.43530;
  const struct slot_type D.43451;
  struct pointer_functor1 D.43441;
  struct iterator D.43659;
  const struct slot_type D.43658;
  struct bound_mem_functor1 D.43648;
  struct 
{
  int A::<T76c5> (struct A *, int) * __pfn;
  long int __delta;
} D.48172;
  struct iterator D.43704;
  const struct slot_type D.43703;
  struct pointer_functor1 D.43693;
  struct iterator D.43707;
  const struct slot_type D.43706;
  struct pointer_functor1 D.43705;
  struct iterator D.43710;
  const struct slot_type D.43709;
  struct bound_mem_functor1 D.43708;
  struct 
{
  int A::<T76c5> (struct A *, int) * __pfn;
  long int __delta;
} D.48173;
  struct iterator D.43713;
  const struct slot_type D.43712;
  struct pointer_functor1 D.43711;
  const int D.43715;
  struct _Setprecision D.48174;
  struct basic_ostream & D.48175;
  struct __ostream_type & D.48176;
  struct basic_ostream & D.48177;
  const struct string D.43719;
  struct allocator D.43718;
  const int D.43720;
  struct _Setprecision D.48178;
  struct basic_ostream & D.48179;
  struct __ostream_type & D.48180;
  struct basic_ostream & D.48181;
  const struct string D.43724;
  struct allocator D.43723;
  const int D.43726;
  int & D.48182;
  int D.48183;
  struct basic_ostream & D.48184;
  bool retval.3;
  struct iterator D.43851;
  const struct string D.43860;
  struct allocator D.43859;
  const int D.43862;
  int & D.48186;
  int D.48187;
  struct basic_ostream & D.48188;
  bool retval.4;
  struct iterator D.43866;
  const struct string D.43869;
  struct allocator D.43868;
  int iftmp.5;
  bool D.48191;

  {
    struct TestUtilities * util;
    struct accumulated sig;
    struct accumulated sig_vec;
    struct A a;
    double dres;
    struct vector res1;
    struct vector res3;

    try
      {
        util = TestUtilities::get_instance ();
        D.48155 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.48155;
        if (retval.0 != 0) goto <D.48156>; else goto <D.48157>;
        <D.48156>:
        D.48160 = TestUtilities::get_result_and_delete_instance ();
        if (D.48160 != 0) goto <D.48161>; else goto <D.48162>;
        <D.48161>:
        iftmp.1 = 0;
        goto <D.48163>;
        <D.48162>:
        iftmp.1 = 1;
        <D.48163>:
        D.48158 = iftmp.1;
        return D.48158;
        <D.48157>:
        sigc::signal<int, int>::accumulated<{anonymous}::arithmetic_mean_accumulator>::accumulated (&sig);
        try
          {
            sigc::signal<int, int>::accumulated<{anonymous}::vector_accumulator<int> >::accumulated (&sig_vec);
            try
              {
                D.42627 = 0;
                try
                  {
                    D.48164 = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::operator() (&sig.D.42445, &D.42627);
                    D.48165 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Result (empty slot list): ");
                    std::basic_ostream<char>::operator<< (D.48165, D.48164);
                  }
                finally
                  {
                    D.42627 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.42629);
                try
                  {
                    std::basic_string<char>::basic_string (&D.42630, "Result (empty slot list): -1", &D.42629);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.42630);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.42630);
                        D.42630 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.42629);
                    D.42629 = {CLOBBER};
                  }
                D.42631 = 0;
                try
                  {
                    D.43376 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::operator() (&sig_vec.D.42593, &D.42631); [return slot optimization]
                    try
                      {
                        D.48167 = std::vector<int, std::allocator<int> >::empty (&D.43376);
                        if (D.48167 != 0) goto <D.48168>; else goto <D.48169>;
                        <D.48168>:
                        iftmp.2 = "empty";
                        goto <D.48170>;
                        <D.48169>:
                        iftmp.2 = "not empty";
                        <D.48170>:
                        D.48171 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Vector result (empty slot list): ");
                        std::operator<< <std::char_traits<char> > (D.48171, iftmp.2);
                      }
                    finally
                      {
                        std::vector<int, std::allocator<int> >::~vector (&D.43376);
                        D.43376 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.42631 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.43378);
                try
                  {
                    std::basic_string<char>::basic_string (&D.43379, "Vector result (empty slot list): empty", &D.43378);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.43379);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.43379);
                        D.43379 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.43378);
                    D.43378 = {CLOBBER};
                  }
                {anonymous}::A::A (&a);
                try
                  {
                    D.43441 = sigc::ptr_fun1<int, int> (foo);
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<int, int> > (&D.43451, &D.43441);
                        try
                          {
                            D.43530 = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::connect (&sig.D.42445, &D.43451);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43451);
                            D.43451 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43441 = {CLOBBER};
                      }
                    D.48172.__pfn = foo;
                    D.48172.__delta = 0;
                    D.43648 = sigc::mem_fun1<int, int, {anonymous}::A, {anonymous}::A> (&a, D.48172); [return slot optimization]
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_mem_functor1<int, {anonymous}::A, int> > (&D.43658, &D.43648);
                        try
                          {
                            D.43659 = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::connect (&sig.D.42445, &D.43658);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43658);
                            D.43658 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43648 = {CLOBBER};
                      }
                    D.43693 = sigc::ptr_fun1<double, int> (bar);
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<double, int> > (&D.43703, &D.43693);
                        try
                          {
                            D.43704 = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::connect (&sig.D.42445, &D.43703);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43703);
                            D.43703 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43693 = {CLOBBER};
                      }
                    D.43705 = sigc::ptr_fun1<int, int> (foo);
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<int, int> > (&D.43706, &D.43705);
                        try
                          {
                            D.43707 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::connect (&sig_vec.D.42593, &D.43706);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43706);
                            D.43706 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43705 = {CLOBBER};
                      }
                    D.48173.__pfn = foo;
                    D.48173.__delta = 0;
                    D.43708 = sigc::mem_fun1<int, int, {anonymous}::A, {anonymous}::A> (&a, D.48173); [return slot optimization]
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::bound_mem_functor1<int, {anonymous}::A, int> > (&D.43709, &D.43708);
                        try
                          {
                            D.43710 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::connect (&sig_vec.D.42593, &D.43709);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43709);
                            D.43709 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43708 = {CLOBBER};
                      }
                    D.43711 = sigc::ptr_fun1<double, int> (bar);
                    try
                      {
                        sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot<sigc::pointer_functor1<double, int> > (&D.43712, &D.43711);
                        try
                          {
                            D.43713 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::connect (&sig_vec.D.42593, &D.43712);
                          }
                        finally
                          {
                            sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::~slot (&D.43712);
                            D.43712 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.43711 = {CLOBBER};
                      }
                    D.43715 = 1;
                    try
                      {
                        dres = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::operator() (&sig.D.42445, &D.43715);
                      }
                    finally
                      {
                        D.43715 = {CLOBBER};
                      }
                    D.48174 = std::setprecision (3);
                    D.48175 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Mean accumulator: Result (i=1): ");
                    D.48176 = std::basic_ostream<char>::operator<< (D.48175, fixed);
                    D.48177 = std::operator<< <char, std::char_traits<char> > (D.48176, D.48174);
                    std::basic_ostream<char>::operator<< (D.48177, dres);
                    std::allocator<char>::allocator (&D.43718);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.43719, "foo: 4, A::foo: 6, bar: 2, Mean accumulator: Result (i=1): 4.000", &D.43718);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.43719);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.43719);
                            D.43719 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.43718);
                        D.43718 = {CLOBBER};
                      }
                    D.43720 = 11;
                    try
                      {
                        dres = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::operator() (&sig.D.42445, &D.43720);
                      }
                    finally
                      {
                        D.43720 = {CLOBBER};
                      }
                    D.48178 = std::setprecision (3);
                    D.48179 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Mean accumulator: Plain Result (i=11): ");
                    D.48180 = std::basic_ostream<char>::operator<< (D.48179, fixed);
                    D.48181 = std::operator<< <char, std::char_traits<char> > (D.48180, D.48178);
                    std::basic_ostream<char>::operator<< (D.48181, dres);
                    std::allocator<char>::allocator (&D.43723);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.43724, "foo: 34, A::foo: 206, bar: 52, Mean accumulator: Plain Result (i=11): 97.333", &D.43723);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.43724);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.43724);
                            D.43724 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.43723);
                        D.43723 = {CLOBBER};
                      }
                    D.43726 = 1;
                    try
                      {
                        res1 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::operator() (&sig_vec.D.42593, &D.43726); [return slot optimization]
                      }
                    finally
                      {
                        try
                          {

                          }
                        catch
                          {
                            std::vector<int, std::allocator<int> >::~vector (&res1);
                          }
                        D.43726 = {CLOBBER};
                      }
                    try
                      {
                        std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Vector accumulator: Result (i=1): ");
                        {
                          struct iterator i;

                          try
                            {
                              i = std::vector<int, std::allocator<int> >::begin (&res1);
                              goto <D.43873>;
                              <D.43872>:
                              D.48182 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator* (&i);
                              D.48183 = *D.48182;
                              D.48184 = std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48183);
                              std::operator<< <std::char_traits<char> > (D.48184, " ");
                              __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++ (&i);
                              <D.43873>:
                              D.43851 = std::vector<int, std::allocator<int> >::end (&res1);
                              try
                                {
                                  retval.3 = __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > > (&i, &D.43851);
                                }
                              finally
                                {
                                  D.43851 = {CLOBBER};
                                }
                              if (retval.3 != 0) goto <D.43872>; else goto <D.43870>;
                              <D.43870>:
                            }
                          finally
                            {
                              i = {CLOBBER};
                            }
                        }
                        std::allocator<char>::allocator (&D.43859);
                        try
                          {
                            std::basic_string<char>::basic_string (&D.43860, "foo: 4, A::foo: 6, bar: 2, Vector accumulator: Result (i=1): 4 6 2 ", &D.43859);
                            try
                              {
                                TestUtilities::check_result (util, &result_stream, &D.43860);
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.43860);
                                D.43860 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.43859);
                            D.43859 = {CLOBBER};
                          }
                        D.43862 = 3;
                        try
                          {
                            res3 = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::operator() (&sig_vec.D.42593, &D.43862); [return slot optimization]
                          }
                        finally
                          {
                            try
                              {

                              }
                            catch
                              {
                                std::vector<int, std::allocator<int> >::~vector (&res3);
                              }
                            D.43862 = {CLOBBER};
                          }
                        try
                          {
                            std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "Vector accumulator: Result (i=3): ");
                            {
                              struct iterator i;

                              try
                                {
                                  i = std::vector<int, std::allocator<int> >::begin (&res3);
                                  goto <D.43877>;
                                  <D.43876>:
                                  D.48186 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator* (&i);
                                  D.48187 = *D.48186;
                                  D.48188 = std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48187);
                                  std::operator<< <std::char_traits<char> > (D.48188, " ");
                                  __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++ (&i);
                                  <D.43877>:
                                  D.43866 = std::vector<int, std::allocator<int> >::end (&res3);
                                  try
                                    {
                                      retval.4 = __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > > (&i, &D.43866);
                                    }
                                  finally
                                    {
                                      D.43866 = {CLOBBER};
                                    }
                                  if (retval.4 != 0) goto <D.43876>; else goto <D.43874>;
                                  <D.43874>:
                                }
                              finally
                                {
                                  i = {CLOBBER};
                                }
                            }
                            std::allocator<char>::allocator (&D.43868);
                            try
                              {
                                std::basic_string<char>::basic_string (&D.43869, "foo: 10, A::foo: 46, bar: 12, Vector accumulator: Result (i=3): 10 46 12 ", &D.43868);
                                try
                                  {
                                    TestUtilities::check_result (util, &result_stream, &D.43869);
                                  }
                                finally
                                  {
                                    std::basic_string<char>::~basic_string (&D.43869);
                                    D.43869 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                std::allocator<char>::~allocator (&D.43868);
                                D.43868 = {CLOBBER};
                              }
                            D.48191 = TestUtilities::get_result_and_delete_instance ();
                            if (D.48191 != 0) goto <D.48192>; else goto <D.48193>;
                            <D.48192>:
                            iftmp.5 = 0;
                            goto <D.48194>;
                            <D.48193>:
                            iftmp.5 = 1;
                            <D.48194>:
                            D.48158 = iftmp.5;
                            return D.48158;
                          }
                        finally
                          {
                            std::vector<int, std::allocator<int> >::~vector (&res3);
                          }
                      }
                    finally
                      {
                        std::vector<int, std::allocator<int> >::~vector (&res1);
                      }
                  }
                finally
                  {
                    {anonymous}::A::~A (&a);
                  }
              }
            finally
              {
                sigc::signal<int, int>::accumulated<{anonymous}::vector_accumulator<int> >::~accumulated (&sig_vec);
              }
          }
        finally
          {
            sigc::signal<int, int>::accumulated<{anonymous}::arithmetic_mean_accumulator>::~accumulated (&sig);
          }
      }
    finally
      {
        sig = {CLOBBER};
        sig_vec = {CLOBBER};
        a = {CLOBBER};
        res1 = {CLOBBER};
        res3 = {CLOBBER};
      }
  }
  D.48158 = 0;
  return D.48158;
}


std::ios_base& std::fixed(std::ios_base&) (struct ios_base & __base)
{
  struct ios_base & D.48264;

  std::ios_base::setf (__base, 4, 260);
  D.48264 = __base;
  return D.48264;
}


std::ios_base::fmtflags std::ios_base::setf(std::ios_base::fmtflags, std::ios_base::fmtflags) (struct ios_base * const this, fmtflags __fmtfl, fmtflags __mask)
{
  _Ios_Fmtflags D.48266;
  fmtflags * D.48267;
  _Ios_Fmtflags D.48268;
  fmtflags D.48269;
  fmtflags __old;

  __old = this->_M_flags;
  D.48266 = std::operator~ (__mask);
  D.48267 = &this->_M_flags;
  std::operator&= (D.48267, D.48266);
  D.48268 = std::operator& (__fmtfl, __mask);
  D.48267 = &this->_M_flags;
  std::operator|= (D.48267, D.48268);
  D.48269 = __old;
  return D.48269;
}


std::_Ios_Fmtflags std::operator~(std::_Ios_Fmtflags) (_Ios_Fmtflags __a)
{
  _Ios_Fmtflags D.48271;

  D.48271 = ~__a;
  return D.48271;
}


const std::_Ios_Fmtflags& std::operator&=(std::_Ios_Fmtflags&, std::_Ios_Fmtflags) (_Ios_Fmtflags & __a, _Ios_Fmtflags __b)
{
  const _Ios_Fmtflags & D.48273;
  _Ios_Fmtflags D.48274;
  _Ios_Fmtflags D.48275;

  D.48274 = *__a;
  D.48275 = std::operator& (D.48274, __b);
  *__a = D.48275;
  D.48273 = __a;
  return D.48273;
}


std::_Ios_Fmtflags std::operator&(std::_Ios_Fmtflags, std::_Ios_Fmtflags) (_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{
  _Ios_Fmtflags D.48277;
  int __a.6;
  int __b.7;
  int D.48280;

  __a.6 = (int) __a;
  __b.7 = (int) __b;
  D.48280 = __a.6 & __b.7;
  D.48277 = (_Ios_Fmtflags) D.48280;
  return D.48277;
}


const std::_Ios_Fmtflags& std::operator|=(std::_Ios_Fmtflags&, std::_Ios_Fmtflags) (_Ios_Fmtflags & __a, _Ios_Fmtflags __b)
{
  const _Ios_Fmtflags & D.48282;
  _Ios_Fmtflags D.48283;
  _Ios_Fmtflags D.48284;

  D.48283 = *__a;
  D.48284 = std::operator| (D.48283, __b);
  *__a = D.48284;
  D.48282 = __a;
  return D.48282;
}


std::_Ios_Fmtflags std::operator|(std::_Ios_Fmtflags, std::_Ios_Fmtflags) (_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{
  _Ios_Fmtflags D.48286;
  int __a.8;
  int __b.9;
  int D.48289;

  __a.8 = (int) __a;
  __b.9 = (int) __b;
  D.48289 = __a.8 | __b.9;
  D.48286 = (_Ios_Fmtflags) D.48289;
  return D.48286;
}


int {anonymous}::bar(double) (double i)
{
  int D.48291;
  int D.48292;
  struct basic_ostream & D.48293;
  struct basic_ostream & D.48294;
  int D.48295;
  const int result;

  D.48291 = (int) i;
  D.48292 = D.48291 * 5;
  result = D.48292 + -3;
  D.48293 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar: ");
  D.48294 = std::basic_ostream<char>::operator<< (D.48293, result);
  std::operator<< <std::char_traits<char> > (D.48294, ", ");
  D.48295 = result;
  return D.48295;
}


int {anonymous}::A::foo(int) (struct A * const this, int i)
{
  int D.48299;
  struct basic_ostream & D.48300;
  struct basic_ostream & D.48301;
  int D.48302;
  const int result;

  D.48299 = i * 20;
  result = D.48299 + -14;
  D.48300 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "A::foo: ");
  D.48301 = std::basic_ostream<char>::operator<< (D.48300, result);
  std::operator<< <std::char_traits<char> > (D.48301, ", ");
  D.48302 = result;
  return D.48302;
}


int {anonymous}::foo(int) (int i)
{
  int D.48306;
  struct basic_ostream & D.48307;
  struct basic_ostream & D.48308;
  int D.48309;
  const int result;

  D.48306 = i * 3;
  result = D.48306 + 1;
  D.48307 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo: ");
  D.48308 = std::basic_ostream<char>::operator<< (D.48307, result);
  std::operator<< <std::char_traits<char> > (D.48308, ", ");
  D.48309 = result;
  return D.48309;
}


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::accumulated<T_accumulator>::accumulated() [with T_accumulator = {anonymous}::arithmetic_mean_accumulator; T_return = int; T_arg1 = int] (struct accumulated * const this)
{
  struct signal1 * D.48313;

  D.48313 = &this->D.42445;
  sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::signal1 (D.48313);
  try
    {

    }
  catch
    {
      D.48313 = &this->D.42445;
      sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::~signal1 (D.48313);
    }
}


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

  D.48314 = &this->D.42427;
  sigc::signal_base::signal_base (D.48314);
  try
    {

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


sigc::signal<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::accumulated<T_accumulator>::accumulated() [with T_accumulator = {anonymous}::vector_accumulator<int>; T_return = int; T_arg1 = int] (struct accumulated * const this)
{
  struct signal1 * D.48315;

  D.48315 = &this->D.42593;
  sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::signal1 (D.48315);
  try
    {

    }
  catch
    {
      D.48315 = &this->D.42593;
      sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::~signal1 (D.48315);
    }
}


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

  D.48316 = &this->D.42575;
  sigc::signal_base::signal_base (D.48316);
  try
    {

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


bool std::vector<_Tp, _Alloc>::empty() const [with _Tp = int; _Alloc = std::allocator<int>] (const struct vector * const this)
{
  bool D.48317;
  struct const_iterator D.44255;
  struct const_iterator D.44256;

  D.44255 = std::vector<int, std::allocator<int> >::end (this);
  try
    {
      D.44256 = std::vector<int, std::allocator<int> >::begin (this);
      try
        {
          D.48317 = __gnu_cxx::operator==<const int*, std::vector<int, std::allocator<int> > > (&D.44256, &D.44255);
          return D.48317;
        }
      finally
        {
          D.44256 = {CLOBBER};
        }
    }
  finally
    {
      D.44255 = {CLOBBER};
    }
}


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::end() const [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const int*] (const struct vector * const this)
{
  struct const_iterator D.48324;
  struct const_iterator D.44603;
  const int * const D.44602;
  int * D.48325;

  D.48325 = this->D.43374._M_impl._M_finish;
  D.44602 = D.48325;
  try
    {
      __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >::__normal_iterator (&D.44603, &D.44602);
      try
        {
          D.48324 = D.44603;
          return D.48324;
        }
      finally
        {
          D.44603 = {CLOBBER};
        }
    }
  finally
    {
      D.44602 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = const int*; _Container = std::vector<int, std::allocator<int> >] (struct __normal_iterator * const this, const int * const & __i)
{
  const int * D.48329;

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


std::vector<_Tp, _Alloc>::const_iterator std::vector<_Tp, _Alloc>::begin() const [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::const_iterator = __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >; typename __gnu_cxx::__alloc_traits<typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_pointer = const int*] (const struct vector * const this)
{
  struct const_iterator D.48330;
  struct const_iterator D.44606;
  const int * const D.44605;
  int * D.48331;

  D.48331 = this->D.43374._M_impl._M_start;
  D.44605 = D.48331;
  try
    {
      __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >::__normal_iterator (&D.44606, &D.44605);
      try
        {
          D.48330 = D.44606;
          return D.48330;
        }
      finally
        {
          D.44606 = {CLOBBER};
        }
    }
  finally
    {
      D.44605 = {CLOBBER};
    }
}


bool __gnu_cxx::operator==(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = const int*; _Container = std::vector<int, std::allocator<int> >] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  bool D.48335;
  const int * const & D.48336;
  const int * D.48337;
  const int * const & D.48338;
  const int * D.48339;

  D.48336 = __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >::base (__lhs);
  D.48337 = *D.48336;
  D.48338 = __gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >::base (__rhs);
  D.48339 = *D.48338;
  D.48335 = D.48337 == D.48339;
  return D.48335;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = const int*; _Container = std::vector<int, std::allocator<int> >] (const struct __normal_iterator * const this)
{
  const int * const & D.48341;

  D.48341 = &this->_M_current;
  return D.48341;
}


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

  D.48343 = &this->D.42077;
  sigc::trackable::trackable (D.48343);
  try
    {

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


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::arithmetic_mean_accumulator; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.48344;
  struct iterator D.44303;
  struct iterator_type D.44293;
  const struct slot_base * D.48345;
  struct signal_base * D.48346;

  D.48345 = &slot_->D.42198.D.42156;
  D.48346 = &this->D.42427;
  D.44293 = sigc::signal_base::connect (D.48346, D.48345);
  try
    {
      sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.44303, &D.44293);
      try
        {
          D.48344 = D.44303;
          return D.48344;
        }
      finally
        {
          D.44303 = {CLOBBER};
        }
    }
  finally
    {
      D.44293 = {CLOBBER};
    }
}


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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = int] (int (*<T7a4b>) (int) _A_func)
{
  struct pointer_functor1 D.48350;
  struct pointer_functor1 D.44273;

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


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


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

}


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

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

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<int, int>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.45135;
  struct slot_base * D.48354;
  struct rep_type * D.48355;
  void * (*<T1711>) (void *) D.48356;

  D.45135 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<int, int> >::typed_slot_rep (D.45135, _A_func);
    }
  catch
    {
      operator delete (D.45135);
    }
  D.48354 = &this->D.42156;
  sigc::slot_base::slot_base (D.48354, D.45135);
  try
    {
      D.48355 = this->D.42156.rep_;
      D.48356 = sigc::internal::slot_call1<sigc::pointer_functor1<int, int>, int, int>::address ();
      D.48355->call_ = D.48356;
    }
  catch
    {
      D.48354 = &this->D.42156;
      sigc::slot_base::~slot_base (D.48354);
    }
}


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

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


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

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


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<int, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.48367;
  struct slot_rep * D.48368;
  struct adaptor_type * D.48369;
  struct slot_do_bind D.47370;

  D.48367 = cl->D.45117.call_;
  D.48368 = &this->D.45117;
  sigc::internal::slot_rep::slot_rep (D.48368, D.48367, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.48369 = &this->functor_;
      D.48368 = &this->D.45117;
      sigc::internal::slot_do_bind::slot_do_bind (&D.47370, D.48368);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<int, int> > > (&D.47370, D.48369);
        }
      finally
        {
          D.47370 = {CLOBBER};
        }
    }
  catch
    {
      D.48368 = &this->D.45117;
      sigc::internal::slot_rep::~slot_rep (D.48368);
    }
}


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

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


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


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

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


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


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


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

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


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


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


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


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


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

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


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


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


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


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

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


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


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


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

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


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


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


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


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


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

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


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

  D.48384 = this->destroy_;
  if (D.48384 != 0B) goto <D.48385>; else goto <D.48386>;
  <D.48385>:
  D.48384 = this->destroy_;
  D.48384 (this);
  goto <D.48387>;
  <D.48386>:
  <D.48387>:
}


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

  D.48388 = call_it;
  return D.48388;
}


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

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


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

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


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = int; T_return = int; typename sigc::type_trait<T_base>::take = const int&] (const struct pointer_functor1 * const this, const int & _A_a1)
{
  int D.48398;
  int (*<T7a4b>) (int) D.48399;
  int D.48400;

  D.48399 = this->func_ptr_;
  D.48400 = *_A_a1;
  D.48398 = D.48399 (D.48400);
  return D.48398;
}


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


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

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


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


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

  D.48407 = &_A_target->D.42077;
  this->visited = D.48407;
  this->invoked = _A_target;
}


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

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

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


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

  D.45647 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bound_mem_functor1<int, {anonymous}::A, int> >::typed_slot_rep (D.45647, _A_func);
    }
  catch
    {
      operator delete (D.45647);
    }
  D.48409 = &this->D.42156;
  sigc::slot_base::slot_base (D.48409, D.45647);
  try
    {
      D.48410 = this->D.42156.rep_;
      D.48411 = sigc::internal::slot_call1<sigc::bound_mem_functor1<int, {anonymous}::A, int>, int, int>::address ();
      D.48410->call_ = D.48411;
    }
  catch
    {
      D.48409 = &this->D.42156;
      sigc::slot_base::~slot_base (D.48409);
    }
}


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

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


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

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


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

  D.48422 = cl->D.45635.call_;
  D.48423 = &this->D.45635;
  sigc::internal::slot_rep::slot_rep (D.48423, D.48422, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.48424 = &this->functor_;
      D.48423 = &this->D.45635;
      sigc::internal::slot_do_bind::slot_do_bind (&D.47429, D.48423);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::bound_mem_functor1<int, {anonymous}::A, int> > > (&D.47429, D.48424);
        }
      finally
        {
          D.47429 = {CLOBBER};
        }
    }
  catch
    {
      D.48423 = &this->D.45635;
      sigc::internal::slot_rep::~slot_rep (D.48423);
    }
}


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

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


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

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


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


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

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


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


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

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


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


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

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


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

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


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

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

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


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


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

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


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


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

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


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


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

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


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


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

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


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

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

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


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

  D.48445 = call_it;
  return D.48445;
}


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

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


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

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


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = int; T_obj = {anonymous}::A; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_mem_functor1 * const this, const int & _A_a1)
{
  int D.48455;
  const struct limit_reference * D.48456;
  struct A & D.48457;
  int A::<T76c5> (struct A *, int) * iftmp.10;
  int A::<T76c5> (struct A *, int) * D.48459;
  long int D.48460;
  long int D.48461;
  long int D.48465;
  sizetype D.48466;
  struct A * D.48467;
  int (*__vtbl_ptr_type) () * D.48468;
  long int D.48469;
  sizetype D.48470;
  int (*__vtbl_ptr_type) () * D.48471;
  int D.48472;

  D.48456 = &this->obj_;
  D.48457 = sigc::limit_reference<{anonymous}::A, true>::invoke (D.48456);
  D.48459 = this->D.43645.func_ptr_.__pfn;
  D.48460 = (long int) D.48459;
  D.48461 = D.48460 & 1;
  if (D.48461 == 0) goto <D.48462>; else goto <D.48463>;
  <D.48462>:
  iftmp.10 = this->D.43645.func_ptr_.__pfn;
  goto <D.48464>;
  <D.48463>:
  D.48465 = this->D.43645.func_ptr_.__delta;
  D.48466 = (sizetype) D.48465;
  D.48467 = D.48457 + D.48466;
  D.48468 = MEM[(int (*__vtbl_ptr_type) () * *)D.48467];
  D.48459 = this->D.43645.func_ptr_.__pfn;
  D.48460 = (long int) D.48459;
  D.48469 = D.48460 + -1;
  D.48470 = (sizetype) D.48469;
  D.48471 = D.48468 + D.48470;
  iftmp.10 = *D.48471;
  <D.48464>:
  D.48472 = *_A_a1;
  D.48465 = this->D.43645.func_ptr_.__delta;
  D.48466 = (sizetype) D.48465;
  D.48467 = D.48457 + D.48466;
  D.48455 = iftmp.10 (D.48467, D.48472);
  return D.48455;
}


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

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = double; T_return = int] (int (*<T7ae8>) (double) _A_func)
{
  struct pointer_functor1 D.48477;
  struct pointer_functor1 D.44337;

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


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


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

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

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


sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<double, int>; T_return = int; T_arg1 = int] (struct slot1 * const this, const struct pointer_functor1 & _A_func)
{
  void * D.46144;
  struct slot_base * D.48481;
  struct rep_type * D.48482;
  void * (*<T1711>) (void *) D.48483;

  D.46144 = operator new (64);
  try
    {
      sigc::internal::typed_slot_rep<sigc::pointer_functor1<double, int> >::typed_slot_rep (D.46144, _A_func);
    }
  catch
    {
      operator delete (D.46144);
    }
  D.48481 = &this->D.42156;
  sigc::slot_base::slot_base (D.48481, D.46144);
  try
    {
      D.48482 = this->D.42156.rep_;
      D.48483 = sigc::internal::slot_call1<sigc::pointer_functor1<double, int>, int, int>::address ();
      D.48482->call_ = D.48483;
    }
  catch
    {
      D.48481 = &this->D.42156;
      sigc::slot_base::~slot_base (D.48481);
    }
}


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

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


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

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


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::pointer_functor1<double, int>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.48494;
  struct slot_rep * D.48495;
  struct adaptor_type * D.48496;
  struct slot_do_bind D.47466;

  D.48494 = cl->D.46126.call_;
  D.48495 = &this->D.46126;
  sigc::internal::slot_rep::slot_rep (D.48495, D.48494, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.48496 = &this->functor_;
      D.48495 = &this->D.46126;
      sigc::internal::slot_do_bind::slot_do_bind (&D.47466, D.48495);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::adaptor_functor<sigc::pointer_functor1<double, int> > > (&D.47466, D.48496);
        }
      finally
        {
          D.47466 = {CLOBBER};
        }
    }
  catch
    {
      D.48495 = &this->D.46126;
      sigc::internal::slot_rep::~slot_rep (D.48495);
    }
}


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

  self_ = data;
  self_->D.46126.call_ = 0B;
  self_->D.46126.destroy_ = 0B;
  D.48499 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.47115, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::adaptor_functor<sigc::pointer_functor1<double, int> > > (&D.47115, D.48499);
    }
  finally
    {
      D.47115 = {CLOBBER};
    }
  D.48500 = 0B;
  return D.48500;
}


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

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


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


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

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


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


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


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


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


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


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

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


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


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

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


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


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


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


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


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

  D.48507 = call_it;
  return D.48507;
}


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

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


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const int&; T_functor = sigc::pointer_functor1<double, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = int] (const struct adaptor_functor * const this, const int & _A_arg1)
{
  type D.48513;
  const double D.47485;
  int D.48514;
  double D.48515;
  struct pointer_functor1 * D.48516;

  D.48514 = *_A_arg1;
  D.48515 = (double) D.48514;
  D.47485 = D.48515;
  try
    {
      D.48516 = &this->functor_;
      D.48513 = sigc::pointer_functor1<double, int>::operator() (D.48516, &D.47485);
      return D.48513;
    }
  finally
    {
      D.47485 = {CLOBBER};
    }
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = double; T_return = int; typename sigc::type_trait<T_base>::take = const double&] (const struct pointer_functor1 * const this, const double & _A_a1)
{
  int D.48521;
  int (*<T7ae8>) (double) D.48522;
  double D.48523;

  D.48522 = this->func_ptr_;
  D.48523 = *_A_a1;
  D.48521 = D.48522 (D.48523);
  return D.48521;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::iterator sigc::signal1<T_return, T_arg1, T_accumulator>::connect(const slot_type&) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; sigc::signal1<T_return, T_arg1, T_accumulator>::iterator = sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >; sigc::signal1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct signal1 * const this, const struct slot_type & slot_)
{
  struct iterator D.48526;
  struct iterator D.44358;
  struct iterator_type D.44357;
  const struct slot_base * D.48527;
  struct signal_base * D.48528;

  D.48527 = &slot_->D.42198.D.42156;
  D.48528 = &this->D.42575;
  D.44357 = sigc::signal_base::connect (D.48528, D.48527);
  try
    {
      sigc::slot_iterator<sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::slot_iterator (&D.44358, &D.44357);
      try
        {
          D.48526 = D.44358;
          return D.48526;
        }
      finally
        {
          D.44358 = {CLOBBER};
        }
    }
  finally
    {
      D.44357 = {CLOBBER};
    }
}


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

  D.48532 = sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::emit (this, _A_a1);
  return D.48532;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::emit(typename sigc::type_trait<T_derived>::take) const [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::arithmetic_mean_accumulator; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = double; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  result_type D.48535;
  struct signal_impl * D.48536;

  D.48536 = this->D.42427.impl_;
  D.48535 = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>::emit (D.48536, _A_a1);
  return D.48535;
}


static sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_derived>::take) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::arithmetic_mean_accumulator; sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type = double; typename sigc::type_trait<T_derived>::take = const int&] (struct signal_impl * impl, const int & _A_a1)
{
  result_type D.48541;
  struct slot_iterator_buf_type D.46361;
  struct slot_iterator_buf_type D.46360;
  struct list * D.48542;
  struct slot_iterator_buf_type D.46383;
  const struct iterator_type D.46382;
  struct iterator D.46381;
  struct slot_iterator_buf_type D.46380;
  const struct iterator_type D.46379;
  struct iterator D.46378;
  struct arithmetic_mean_accumulator accumulator;
  struct signal_exec exec;
  struct temp_slot_list slots;
  struct self_type self;

  try
    {
      if (impl == 0B) goto <D.48539>; else goto <D.48540>;
      <D.48539>:
      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::slot_iterator_buf (&D.46361);
      try
        {
          sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::slot_iterator_buf (&D.46360);
          try
            {
              D.48541 = {anonymous}::arithmetic_mean_accumulator::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int> > (&accumulator, D.46360, D.46361);
              return D.48541;
            }
          finally
            {
              D.46360 = {CLOBBER};
            }
        }
      finally
        {
          D.46361 = {CLOBBER};
        }
      <D.48540>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.48542 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.48542);
          try
            {
              sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>::signal_emit1 (&self, _A_a1);
              D.46381 = sigc::internal::temp_slot_list::end (&slots);
              try
                {
                  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.46382, &D.46381);
                  try
                    {
                      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::slot_iterator_buf (&D.46383, &D.46382, &self);
                      try
                        {
                          D.46378 = sigc::internal::temp_slot_list::begin (&slots);
                          try
                            {
                              std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.46379, &D.46378);
                              try
                                {
                                  sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::slot_iterator_buf (&D.46380, &D.46379, &self);
                                  try
                                    {
                                      D.48541 = {anonymous}::arithmetic_mean_accumulator::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int> > (&accumulator, D.46380, D.46383);
                                      return D.48541;
                                    }
                                  finally
                                    {
                                      D.46380 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.46379 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.46378 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.46383 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.46382 = {CLOBBER};
                    }
                }
              finally
                {
                  D.46381 = {CLOBBER};
                }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      accumulator = {CLOBBER};
      exec = {CLOBBER};
      slots = {CLOBBER};
      self = {CLOBBER};
    }
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf() [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.48568;

  D.48568 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (D.48568);
  this->c_ = 0B;
  this->invoked_ = 0;
}


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


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

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


void sigc::internal::signal_impl::reference_exec() (struct signal_impl * const this)
{
  short int D.48570;
  unsigned short D.48571;
  unsigned short D.48572;
  short int D.48573;
  short int D.48574;
  unsigned short D.48575;
  unsigned short D.48576;
  short int D.48577;

  D.48570 = this->ref_count_;
  D.48571 = (unsigned short) D.48570;
  D.48572 = D.48571 + 1;
  D.48573 = (short int) D.48572;
  this->ref_count_ = D.48573;
  D.48574 = this->exec_count_;
  D.48575 = (unsigned short) D.48574;
  D.48576 = D.48575 + 1;
  D.48577 = (short int) D.48576;
  this->exec_count_ = D.48577;
}


sigc::internal::temp_slot_list::temp_slot_list(sigc::internal::temp_slot_list::slot_list&) (struct temp_slot_list * const this, struct slot_list & slots)
{
  struct iterator * D.48578;
  struct slot_base D.35400;
  struct slot_list & D.48579;
  struct _List_iterator D.48580;

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


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


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

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


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


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, struct iterator __position, const struct value_type & __x)
{
  struct _Self D.43992;
  struct _List_node_base * D.48586;
  struct _List_node_base * D.48587;
  struct iterator D.48588;
  struct iterator D.43993;
  struct _Node * __tmp;

  __tmp = std::list<sigc::slot_base>::_M_create_node (this, __x);
  D.43992 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
  D.48586 = D.43992._M_node;
  D.48587 = &__tmp->D.43989;
  std::__detail::_List_node_base::_M_hook (D.48587, D.48586);
  std::_List_iterator<sigc::slot_base>::_List_iterator (&D.43993, __tmp);
  try
    {
      D.48588 = D.43993;
      return D.48588;
    }
  finally
    {
      D.43993 = {CLOBBER};
    }
}


std::list<_Tp, _Alloc>::_Node* std::list<_Tp, _Alloc>::_M_create_node(const value_type&) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::_Node = std::_List_node<sigc::slot_base>; std::list<_Tp, _Alloc>::value_type = sigc::slot_base] (struct list * const this, const struct value_type & __x)
{
  struct _List_base * D.48592;
  struct slot_base * D.48593;
  struct slot_base * D.48594;
  struct _Tp_alloc_type D.44488;
  void * D.48595;
  struct _Node * D.48596;
  struct _Node * __p;

  D.48592 = &this->D.35179;
  __p = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_node (D.48592);
  try
    {
      D.48593 = &__p->_M_data;
      D.48594 = std::__addressof<sigc::slot_base> (D.48593);
      D.48592 = &this->D.35179;
      D.44488 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (D.48592); [return slot optimization]
      try
        {
          __gnu_cxx::new_allocator<sigc::slot_base>::construct (&D.44488, D.48594, __x);
        }
      finally
        {
          std::allocator<sigc::slot_base>::~allocator (&D.44488);
          D.44488 = {CLOBBER};
        }
    }
  catch
    {
      catch (NULL)
        {
          try
            {
              D.48595 = __builtin_eh_pointer (0);
              __cxa_begin_catch (D.48595);
              D.48592 = &this->D.35179;
              std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (D.48592, __p);
              __cxa_rethrow ();
            }
          finally
            {
              __cxa_end_catch ();
            }
        }
    }
  D.48596 = __p;
  return D.48596;
}


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

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


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

  D.48608 = __gnu_cxx::new_allocator<std::_List_node<sigc::slot_base> >::max_size (this);
  retval.11 = D.48608 < __n;
  if (retval.11 != 0) goto <D.48609>; else goto <D.48610>;
  <D.48609>:
  std::__throw_bad_alloc ();
  <D.48610>:
  D.48612 = __n * 32;
  D.48611 = operator new (D.48612);
  return D.48611;
}


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

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


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

  D.48618 = __r;
  return D.48618;
}


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

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


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

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


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

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

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


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

  try
    {
      {

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


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

  D.46267 = __p;
  D.46268 = operator new (16, D.46267);
  if (D.46268 != 0B) goto <D.48628>; else goto <D.48629>;
  <D.48628>:
  try
    {
      sigc::slot_base::slot_base (D.46268, __val);
    }
  catch
    {
      operator delete (D.46268, D.46267);
    }
  iftmp.12 = D.46268;
  goto <D.48630>;
  <D.48629>:
  iftmp.12 = D.46268;
  <D.48630>:
}


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

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


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

  try
    {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

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


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


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

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


sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::signal_emit1(typename sigc::type_trait<T_derived>::take) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::arithmetic_mean_accumulator; typename sigc::type_trait<T_derived>::take = const int&] (struct signal_emit1 * const this, const int & _A_a1)
{
  this->_A_a1_ = _A_a1;
}


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

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


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

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


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

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


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

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


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf(const iterator_type&, const emitter_type*) [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::iterator_type = std::_List_const_iterator<sigc::slot_base>; sigc::internal::slot_iterator_buf<T_emitter, T_result>::emitter_type = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>] (struct slot_iterator_buf * const this, const struct iterator_type & i, const struct emitter_type * c)
{
  this->i_ = MEM[(const struct _List_const_iterator &)i];
  this->c_ = c;
  this->invoked_ = 0;
}


double {anonymous}::arithmetic_mean_accumulator::operator()(T_iterator, T_iterator) const [with T_iterator = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>] (const struct arithmetic_mean_accumulator * const this, struct slot_iterator_buf first, struct slot_iterator_buf last)
{
  result_type D.46712;
  double D.48651;
  bool retval.13;
  double D.48653;
  double iftmp.14;
  double D.48657;
  double value_;
  int n_;

  value_ = 0.0;
  n_ = 0;
  goto <D.46716>;
  <D.46715>:
  D.46712 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::operator* (&first);
  D.48651 = (double) D.46712;
  value_ = D.48651 + value_;
  sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::operator++ (&first);
  n_ = n_ + 1;
  <D.46716>:
  retval.13 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>, int>::operator!= (&first, &last);
  if (retval.13 != 0) goto <D.46715>; else goto <D.46713>;
  <D.46713>:
  if (n_ != 0) goto <D.48655>; else goto <D.48656>;
  <D.48655>:
  D.48657 = (double) n_;
  iftmp.14 = value_ / D.48657;
  goto <D.48658>;
  <D.48656>:
  iftmp.14 = -1.0e+0;
  <D.48658>:
  D.48653 = iftmp.14;
  return D.48653;
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator*() const [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type = int] (const struct slot_iterator_buf * const this)
{
  bool retval.15;
  bool iftmp.16;
  const struct iterator_type * D.48665;
  const struct slot_base * D.48666;
  bool D.48667;
  bool D.48668;
  const struct slot_base * D.48670;
  bool D.48671;
  bool D.48672;
  bool D.48674;
  bool D.48675;
  const struct slot_base & D.48679;
  const struct emitter_type * D.48680;
  int D.48681;
  result_type D.48683;

  D.48665 = &this->i_;
  D.48666 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.48665);
  D.48667 = sigc::slot_base::empty (D.48666);
  D.48668 = ~D.48667;
  if (D.48668 != 0) goto <D.48669>; else goto <D.48663>;
  <D.48669>:
  D.48665 = &this->i_;
  D.48670 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.48665);
  D.48671 = sigc::slot_base::blocked (D.48670);
  D.48672 = ~D.48671;
  if (D.48672 != 0) goto <D.48673>; else goto <D.48663>;
  <D.48673>:
  D.48674 = this->invoked_;
  D.48675 = ~D.48674;
  if (D.48675 != 0) goto <D.48676>; else goto <D.48663>;
  <D.48676>:
  iftmp.16 = 1;
  goto <D.48664>;
  <D.48663>:
  iftmp.16 = 0;
  <D.48664>:
  retval.15 = iftmp.16;
  if (retval.15 != 0) goto <D.48677>; else goto <D.48678>;
  <D.48677>:
  D.48665 = &this->i_;
  D.48679 = std::_List_const_iterator<sigc::slot_base>::operator* (D.48665);
  D.48680 = this->c_;
  D.48681 = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>::operator() (D.48680, D.48679);
  this->r_ = D.48681;
  this->invoked_ = 1;
  goto <D.48682>;
  <D.48678>:
  <D.48682>:
  D.48683 = this->r_;
  return D.48683;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.48688;
  bool iftmp.17;
  struct rep_type * D.48693;
  void * (*<T1711>) (void *) D.48695;

  D.48693 = this->rep_;
  if (D.48693 == 0B) goto <D.48690>; else goto <D.48694>;
  <D.48694>:
  D.48693 = this->rep_;
  D.48695 = D.48693->call_;
  if (D.48695 == 0B) goto <D.48690>; else goto <D.48691>;
  <D.48690>:
  iftmp.17 = 1;
  goto <D.48692>;
  <D.48691>:
  iftmp.17 = 0;
  <D.48692>:
  D.48688 = iftmp.17;
  return D.48688;
}


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

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


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

  D.48701 = __r;
  return D.48701;
}


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

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


const _Tp& std::_List_const_iterator<_Tp>::operator*() const [with _Tp = sigc::slot_base; std::_List_const_iterator<_Tp>::reference = const sigc::slot_base&] (const struct _List_const_iterator * const this)
{
  const struct slot_base & D.48705;
  const struct _List_node_base * D.48706;

  D.48706 = this->_M_node;
  D.48705 = &MEM[(const struct _Node *)D.48706]._M_data;
  return D.48705;
}


T_return sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::operator()(const slot_type&) const [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::arithmetic_mean_accumulator; sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct signal_emit1 * const this, const struct slot_type & _A_slot)
{
  int D.48708;
  struct rep_type * D.48709;
  void * (*<T1711>) (void *) D.48710;
  const int & D.48711;

  D.48709 = _A_slot->D.42198.D.42156.rep_;
  D.48710 = D.48709->call_;
  D.48711 = this->_A_a1_;
  D.48709 = _A_slot->D.42198.D.42156.rep_;
  D.48708 = D.48710 (D.48709, D.48711);
  return D.48708;
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>& sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator++() [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.48714;
  struct slot_iterator_buf & D.48715;

  D.48714 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::operator++ (D.48714);
  this->invoked_ = 0;
  D.48715 = this;
  return D.48715;
}


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

  D.48717 = this->_M_node;
  D.48718 = D.48717->_M_next;
  this->_M_node = D.48718;
  D.48719 = this;
  return D.48719;
}


bool sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator!=(const sigc::internal::slot_iterator_buf<T_emitter, T_result>&) const [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::arithmetic_mean_accumulator>; T_result = int] (const struct slot_iterator_buf * const this, const struct slot_iterator_buf & other)
{
  bool D.48721;
  bool iftmp.18;
  const struct emitter_type * D.48725;
  const struct iterator_type * D.48727;
  const struct iterator_type * D.48728;
  bool D.48729;

  D.48725 = this->c_;
  if (D.48725 != 0B) goto <D.48726>; else goto <D.48723>;
  <D.48726>:
  D.48727 = &other->i_;
  D.48728 = &this->i_;
  D.48729 = std::_List_const_iterator<sigc::slot_base>::operator!= (D.48728, D.48727);
  if (D.48729 != 0) goto <D.48730>; else goto <D.48723>;
  <D.48730>:
  iftmp.18 = 1;
  goto <D.48724>;
  <D.48723>:
  iftmp.18 = 0;
  <D.48724>:
  D.48721 = iftmp.18;
  return D.48721;
}


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

  D.48733 = this->_M_node;
  D.48734 = __x->_M_node;
  D.48732 = D.48733 != D.48734;
  return D.48732;
}


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

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


std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.48738;
  struct _List_node_base * D.48739;
  struct _List_iterator D.48740;
  struct iterator D.48741;
  struct iterator __ret;

  try
    {
      D.48738 = __position._M_node;
      D.48739 = D.48738->_M_next;
      std::_List_iterator<sigc::slot_base>::_List_iterator (&__ret, D.48739);
      D.48740 = std::_List_iterator<sigc::slot_base>::_M_const_cast (&__position);
      std::list<sigc::slot_base>::_M_erase (this, D.48740);
      D.48741 = __ret;
      return D.48741;
    }
  finally
    {
      __ret = {CLOBBER};
    }
}


void std::list<_Tp, _Alloc>::_M_erase(std::list<_Tp, _Alloc>::iterator) [with _Tp = sigc::slot_base; _Alloc = std::allocator<sigc::slot_base>; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<sigc::slot_base>] (struct list * const this, struct iterator __position)
{
  struct _List_node_base * D.48745;
  struct slot_base * D.48746;
  struct slot_base * D.48747;
  struct _Tp_alloc_type D.44494;
  struct _List_base * D.48748;
  struct _Node * __n;

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


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


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

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


void sigc::internal::signal_impl::unreference_exec() (struct signal_impl * const this)
{
  bool retval.19;
  short int D.48753;
  unsigned short D.48754;
  unsigned short D.48755;
  short int D.48756;
  bool retval.20;
  bool iftmp.21;
  short int D.48767;
  unsigned short D.48768;
  unsigned short D.48769;
  short int D.48770;
  bool D.48772;

  D.48753 = this->ref_count_;
  D.48754 = (unsigned short) D.48753;
  D.48755 = D.48754 + 65535;
  D.48756 = (short int) D.48755;
  this->ref_count_ = D.48756;
  D.48753 = this->ref_count_;
  retval.19 = D.48753 == 0;
  if (retval.19 != 0) goto <D.48757>; else goto <D.48758>;
  <D.48757>:
  if (this != 0B) goto <D.48759>; else goto <D.48760>;
  <D.48759>:
  sigc::internal::signal_impl::~signal_impl (this);
  operator delete (this);
  goto <D.48761>;
  <D.48760>:
  <D.48761>:
  goto <D.48762>;
  <D.48758>:
  D.48767 = this->exec_count_;
  D.48768 = (unsigned short) D.48767;
  D.48769 = D.48768 + 65535;
  D.48770 = (short int) D.48769;
  this->exec_count_ = D.48770;
  D.48767 = this->exec_count_;
  if (D.48767 == 0) goto <D.48771>; else goto <D.48765>;
  <D.48771>:
  D.48772 = this->deferred_;
  if (D.48772 != 0) goto <D.48773>; else goto <D.48765>;
  <D.48773>:
  iftmp.21 = 1;
  goto <D.48766>;
  <D.48765>:
  iftmp.21 = 0;
  <D.48766>:
  retval.20 = iftmp.21;
  if (retval.20 != 0) goto <D.48774>; else goto <D.48775>;
  <D.48774>:
  sigc::internal::signal_impl::sweep (this);
  goto <D.48776>;
  <D.48775>:
  <D.48776>:
  <D.48762>:
}


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

  {
    try
      {
        try
          {

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


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

  {
    try
      {
        try
          {

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


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

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


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

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

    __tmp = __cur;
    __cur = __cur->D.43989._M_next;
    D.48784 = &__tmp->_M_data;
    D.48785 = std::__addressof<sigc::slot_base> (D.48784);
    D.44477 = std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_get_Tp_allocator (this); [return slot optimization]
    try
      {
        __gnu_cxx::new_allocator<sigc::slot_base>::destroy (&D.44477, D.48785);
      }
    finally
      {
        std::allocator<sigc::slot_base>::~allocator (&D.44477);
        D.44477 = {CLOBBER};
      }
    std::_List_base<sigc::slot_base, std::allocator<sigc::slot_base> >::_M_put_node (this, __tmp);
  }
  <D.44481>:
  D.48786 = &this->_M_impl._M_node;
  if (D.48786 != __cur) goto <D.44482>; else goto <D.44480>;
  <D.44480>:
}


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

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::_Setprecision std::setprecision(int) (int __n)
{
  struct _Setprecision D.48790;

  D.48790._M_n = __n;
  return D.48790;
}


std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>] (struct basic_ostream * const this, struct ios_base & (*<T3313>) (struct ios_base &) __pf)
{
  int (*__vtbl_ptr_type) () * D.48792;
  int (*__vtbl_ptr_type) () * D.48793;
  long int D.48794;
  sizetype D.48795;
  struct ios_base * D.48796;
  struct __ostream_type & D.48797;

  D.48792 = this->_vptr.basic_ostream;
  D.48793 = D.48792 + 18446744073709551592;
  D.48794 = MEM[(long int *)D.48793];
  D.48795 = (sizetype) D.48794;
  D.48796 = this + D.48795;
  __pf (D.48796);
  D.48797 = this;
  return D.48797;
}


std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setprecision) [with _CharT = char; _Traits = std::char_traits<char>] (struct basic_ostream & __os, struct _Setprecision __f)
{
  int D.48799;
  long int D.48800;
  int (*__vtbl_ptr_type) () * D.48801;
  int (*__vtbl_ptr_type) () * D.48802;
  long int D.48803;
  sizetype D.48804;
  struct ios_base * D.48805;
  struct basic_ostream & D.48806;

  D.48799 = __f._M_n;
  D.48800 = (long int) D.48799;
  D.48801 = __os->_vptr.basic_ostream;
  D.48802 = D.48801 + 18446744073709551592;
  D.48803 = MEM[(long int *)D.48802];
  D.48804 = (sizetype) D.48803;
  D.48805 = __os + D.48804;
  std::ios_base::precision (D.48805, D.48800);
  D.48806 = __os;
  return D.48806;
}


std::streamsize std::ios_base::precision(std::streamsize) (struct ios_base * const this, streamsize __prec)
{
  streamsize D.48808;
  streamsize __old;

  __old = this->_M_precision;
  this->_M_precision = __prec;
  D.48808 = __old;
  return D.48808;
}


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

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


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::operator()(typename sigc::type_trait<T_derived>::take) const [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = std::vector<int, std::allocator<int> >; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  *<retval> = sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::emit (this, _A_a1); [return slot optimization]
  return <retval>;
}


sigc::signal1<T_return, T_arg1, T_accumulator>::result_type sigc::signal1<T_return, T_arg1, T_accumulator>::emit(typename sigc::type_trait<T_derived>::take) const [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; sigc::signal1<T_return, T_arg1, T_accumulator>::result_type = std::vector<int, std::allocator<int> >; typename sigc::type_trait<T_derived>::take = const int&] (const struct signal1 * const this, const int & _A_a1)
{
  struct signal_impl * D.48818;

  D.48818 = this->D.42575.impl_;
  *<retval> = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >::emit (D.48818, _A_a1); [return slot optimization]
  return <retval>;
}


static sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::emit(sigc::internal::signal_impl*, typename sigc::type_trait<T_derived>::take) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::result_type = std::vector<int, std::allocator<int> >; typename sigc::type_trait<T_derived>::take = const int&] (struct signal_impl * impl, const int & _A_a1)
{
  struct slot_iterator_buf_type D.46466;
  struct slot_iterator_buf_type D.46465;
  struct list * D.48823;
  struct slot_iterator_buf_type D.46489;
  const struct iterator_type D.46488;
  struct iterator D.46487;
  struct slot_iterator_buf_type D.46486;
  const struct iterator_type D.46485;
  struct iterator D.46484;
  struct vector_accumulator accumulator;
  struct signal_exec exec;
  struct temp_slot_list slots;
  struct self_type self;

  try
    {
      if (impl == 0B) goto <D.48821>; else goto <D.48822>;
      <D.48821>:
      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::slot_iterator_buf (&D.46466);
      try
        {
          sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::slot_iterator_buf (&D.46465);
          try
            {
              *<retval> = {anonymous}::vector_accumulator<int>::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int> > (&accumulator, D.46465, D.46466); [return slot optimization]
              return <retval>;
            }
          finally
            {
              D.46465 = {CLOBBER};
            }
        }
      finally
        {
          D.46466 = {CLOBBER};
        }
      <D.48822>:
      sigc::internal::signal_exec::signal_exec (&exec, impl);
      try
        {
          D.48823 = &impl->slots_;
          sigc::internal::temp_slot_list::temp_slot_list (&slots, D.48823);
          try
            {
              sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >::signal_emit1 (&self, _A_a1);
              D.46487 = sigc::internal::temp_slot_list::end (&slots);
              try
                {
                  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.46488, &D.46487);
                  try
                    {
                      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::slot_iterator_buf (&D.46489, &D.46488, &self);
                      try
                        {
                          D.46484 = sigc::internal::temp_slot_list::begin (&slots);
                          try
                            {
                              std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (&D.46485, &D.46484);
                              try
                                {
                                  sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::slot_iterator_buf (&D.46486, &D.46485, &self);
                                  try
                                    {
                                      *<retval> = {anonymous}::vector_accumulator<int>::operator()<sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int> > (&accumulator, D.46486, D.46489); [return slot optimization]
                                      return <retval>;
                                    }
                                  finally
                                    {
                                      D.46486 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.46485 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.46484 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.46489 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      D.46488 = {CLOBBER};
                    }
                }
              finally
                {
                  D.46487 = {CLOBBER};
                }
            }
          finally
            {
              sigc::internal::temp_slot_list::~temp_slot_list (&slots);
            }
        }
      finally
        {
          sigc::internal::signal_exec::~signal_exec (&exec);
        }
    }
  finally
    {
      accumulator = {CLOBBER};
      exec = {CLOBBER};
      slots = {CLOBBER};
      self = {CLOBBER};
    }
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf() [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.48847;

  D.48847 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::_List_const_iterator (D.48847);
  this->c_ = 0B;
  this->invoked_ = 0;
}


sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::signal_emit1(typename sigc::type_trait<T_derived>::take) [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; typename sigc::type_trait<T_derived>::take = const int&] (struct signal_emit1 * const this, const int & _A_a1)
{
  this->_A_a1_ = _A_a1;
}


sigc::internal::slot_iterator_buf<T_emitter, T_result>::slot_iterator_buf(const iterator_type&, const emitter_type*) [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::iterator_type = std::_List_const_iterator<sigc::slot_base>; sigc::internal::slot_iterator_buf<T_emitter, T_result>::emitter_type = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >] (struct slot_iterator_buf * const this, const struct iterator_type & i, const struct emitter_type * c)
{
  this->i_ = MEM[(const struct _List_const_iterator &)i];
  this->c_ = c;
  this->invoked_ = 0;
}


{anonymous}::vector_accumulator<Ret>::result_type {anonymous}::vector_accumulator<Ret>::operator()(T_iterator, T_iterator) const [with T_iterator = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>; Ret = int; {anonymous}::vector_accumulator<Ret>::result_type = std::vector<int, std::allocator<int> >] (const struct vector_accumulator * const this, struct slot_iterator_buf first, struct slot_iterator_buf last)
{
  const value_type D.46731;
  int D.48849;
  bool retval.22;
  struct result_type vec [value-expr: *<retval>];

  std::vector<int, std::allocator<int> >::vector (<retval>);
  try
    {
      goto <D.46736>;
      <D.46735>:
      D.48849 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::operator* (&first);
      D.46731 = D.48849;
      try
        {
          std::vector<int, std::allocator<int> >::push_back (<retval>, &D.46731);
        }
      finally
        {
          D.46731 = {CLOBBER};
        }
      sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::operator++ (&first);
      <D.46736>:
      retval.22 = sigc::internal::slot_iterator_buf<sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >, int>::operator!= (&first, &last);
      if (retval.22 != 0) goto <D.46735>; else goto <D.46733>;
      <D.46733>:
      return <retval>;
    }
  catch
    {
      std::vector<int, std::allocator<int> >::~vector (<retval>);
    }
}


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

  D.48855 = &this->D.43374;
  std::_Vector_base<int, std::allocator<int> >::_Vector_base (D.48855);
  try
    {

    }
  catch
    {
      D.48855 = &this->D.43374;
      std::_Vector_base<int, std::allocator<int> >::~_Vector_base (D.48855);
    }
}


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

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

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


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


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

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

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


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

  try
    {
      {

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


sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator*() const [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >; T_result = int; sigc::internal::slot_iterator_buf<T_emitter, T_result>::result_type = int] (const struct slot_iterator_buf * const this)
{
  bool retval.23;
  bool iftmp.24;
  const struct iterator_type * D.48863;
  const struct slot_base * D.48864;
  bool D.48865;
  bool D.48866;
  const struct slot_base * D.48868;
  bool D.48869;
  bool D.48870;
  bool D.48872;
  bool D.48873;
  const struct slot_base & D.48877;
  const struct emitter_type * D.48878;
  int D.48879;
  result_type D.48881;

  D.48863 = &this->i_;
  D.48864 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.48863);
  D.48865 = sigc::slot_base::empty (D.48864);
  D.48866 = ~D.48865;
  if (D.48866 != 0) goto <D.48867>; else goto <D.48861>;
  <D.48867>:
  D.48863 = &this->i_;
  D.48868 = std::_List_const_iterator<sigc::slot_base>::operator-> (D.48863);
  D.48869 = sigc::slot_base::blocked (D.48868);
  D.48870 = ~D.48869;
  if (D.48870 != 0) goto <D.48871>; else goto <D.48861>;
  <D.48871>:
  D.48872 = this->invoked_;
  D.48873 = ~D.48872;
  if (D.48873 != 0) goto <D.48874>; else goto <D.48861>;
  <D.48874>:
  iftmp.24 = 1;
  goto <D.48862>;
  <D.48861>:
  iftmp.24 = 0;
  <D.48862>:
  retval.23 = iftmp.24;
  if (retval.23 != 0) goto <D.48875>; else goto <D.48876>;
  <D.48875>:
  D.48863 = &this->i_;
  D.48877 = std::_List_const_iterator<sigc::slot_base>::operator* (D.48863);
  D.48878 = this->c_;
  D.48879 = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >::operator() (D.48878, D.48877);
  this->r_ = D.48879;
  this->invoked_ = 1;
  goto <D.48880>;
  <D.48876>:
  <D.48880>:
  D.48881 = this->r_;
  return D.48881;
}


T_return sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::operator()(const slot_type&) const [with T_return = int; T_arg1 = int; T_accumulator = {anonymous}::vector_accumulator<int>; sigc::internal::signal_emit1<T_return, T_arg1, T_accumulator>::slot_type = sigc::slot<int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct signal_emit1 * const this, const struct slot_type & _A_slot)
{
  int D.48886;
  struct rep_type * D.48887;
  void * (*<T1711>) (void *) D.48888;
  const int & D.48889;

  D.48887 = _A_slot->D.42198.D.42156.rep_;
  D.48888 = D.48887->call_;
  D.48889 = this->_A_a1_;
  D.48887 = _A_slot->D.42198.D.42156.rep_;
  D.48886 = D.48888 (D.48887, D.48889);
  return D.48886;
}


void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::value_type = int] (struct vector * const this, const value_type & __x)
{
  int * D.48892;
  int * D.48893;
  struct _Vector_impl * D.48896;
  int * D.48897;
  struct __normal_iterator D.48899;

  D.48892 = this->D.43374._M_impl._M_finish;
  D.48893 = this->D.43374._M_impl._M_end_of_storage;
  if (D.48892 != D.48893) goto <D.48894>; else goto <D.48895>;
  <D.48894>:
  D.48892 = this->D.43374._M_impl._M_finish;
  D.48896 = &this->D.43374._M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<int> >::construct<int> (D.48896, D.48892, __x);
  D.48892 = this->D.43374._M_impl._M_finish;
  D.48897 = D.48892 + 4;
  this->D.43374._M_impl._M_finish = D.48897;
  goto <D.48898>;
  <D.48895>:
  D.48899 = std::vector<int, std::allocator<int> >::end (this);
  std::vector<int, std::allocator<int> >::_M_insert_aux (this, D.48899, __x);
  <D.48898>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::construct(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, const _Tp&) [with _Tp = int; _Alloc = std::allocator<int>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = int*] (struct allocator & __a, int * __p, const int & __arg)
{
  __gnu_cxx::new_allocator<int>::construct (__a, __p, __arg);
}


void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = int; __gnu_cxx::new_allocator<_Tp>::pointer = int*] (struct new_allocator * const this, int * __p, const int & __val)
{
  void * D.47651;
  void * D.47652;
  int * iftmp.25;
  int D.48903;

  D.47651 = __p;
  D.47652 = operator new (4, D.47651);
  if (D.47652 != 0B) goto <D.48901>; else goto <D.48902>;
  <D.48901>:
  try
    {
      D.48903 = *__val;
      MEM[(int *)D.47652] = D.48903;
    }
  catch
    {
      operator delete (D.47652, D.47651);
    }
  iftmp.25 = D.47652;
  goto <D.48904>;
  <D.48902>:
  iftmp.25 = D.47652;
  <D.48904>:
}


void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >; typename std::_Vector_base<_Tp, _Alloc>::pointer = int*] (struct vector * const this, struct iterator __position, const int & __x)
{
  int * D.48905;
  int * D.48906;
  const int * D.48909;
  struct _Vector_impl * D.48910;
  int * D.48911;
  int * D.48912;
  int * D.48913;
  int * const & D.48914;
  int * D.48915;
  int & D.48916;
  struct iterator D.47553;
  long int D.48918;
  struct _Vector_base * D.48919;
  long unsigned int D.48920;
  int * D.48921;
  struct _Tp_alloc_type & D.48922;
  int * const & D.48923;
  int * D.48924;
  int * D.48925;
  struct _Tp_alloc_type & D.48926;
  int * const & D.48927;
  int * D.48928;
  void * D.48929;
  struct _Tp_alloc_type & D.48933;
  struct _Tp_alloc_type & D.48934;
  long int D.48935;
  long int D.48936;
  long int D.48937;
  long int D.48938;
  long unsigned int D.48939;
  long unsigned int D.48940;
  int * D.48941;

  {
    D.48905 = this->D.43374._M_impl._M_finish;
    D.48906 = this->D.43374._M_impl._M_end_of_storage;
    if (D.48905 != D.48906) goto <D.48907>; else goto <D.48908>;
    <D.48907>:
    {
      int __x_copy;

      D.48905 = this->D.43374._M_impl._M_finish;
      D.48909 = D.48905 + 18446744073709551612;
      D.48905 = this->D.43374._M_impl._M_finish;
      D.48910 = &this->D.43374._M_impl;
      __gnu_cxx::__alloc_traits<std::allocator<int> >::construct<int> (D.48910, D.48905, D.48909);
      D.48905 = this->D.43374._M_impl._M_finish;
      D.48911 = D.48905 + 4;
      this->D.43374._M_impl._M_finish = D.48911;
      __x_copy = *__x;
      D.48905 = this->D.43374._M_impl._M_finish;
      D.48912 = D.48905 + 18446744073709551612;
      D.48905 = this->D.43374._M_impl._M_finish;
      D.48913 = D.48905 + 18446744073709551608;
      D.48914 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (&__position);
      D.48915 = *D.48914;
      std::copy_backward<int*, int*> (D.48915, D.48913, D.48912);
      D.48916 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator* (&__position);
      *D.48916 = __x_copy;
    }
    goto <D.48917>;
    <D.48908>:
    {
      const size_type __len;
      const size_type __elems_before;
      int * __new_start;
      int * __new_finish;

      __len = std::vector<int, std::allocator<int> >::_M_check_len (this, 1, "vector::_M_insert_aux");
      D.47553 = std::vector<int, std::allocator<int> >::begin (this);
      try
        {
          D.48918 = __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > > (&__position, &D.47553);
          __elems_before = (const size_type) D.48918;
        }
      finally
        {
          D.47553 = {CLOBBER};
        }
      D.48919 = &this->D.43374;
      __new_start = std::_Vector_base<int, std::allocator<int> >::_M_allocate (D.48919, __len);
      __new_finish = __new_start;
      try
        {
          D.48920 = __elems_before * 4;
          D.48921 = __new_start + D.48920;
          D.48910 = &this->D.43374._M_impl;
          __gnu_cxx::__alloc_traits<std::allocator<int> >::construct<int> (D.48910, D.48921, __x);
          __new_finish = 0B;
          D.48919 = &this->D.43374;
          D.48922 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.48919);
          D.48923 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (&__position);
          D.48924 = *D.48923;
          D.48925 = this->D.43374._M_impl._M_start;
          __new_finish = std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> > (D.48925, D.48924, __new_start, D.48922);
          __new_finish = __new_finish + 4;
          D.48919 = &this->D.43374;
          D.48926 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.48919);
          D.48905 = this->D.43374._M_impl._M_finish;
          D.48927 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (&__position);
          D.48928 = *D.48927;
          __new_finish = std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> > (D.48928, D.48905, __new_finish, D.48926);
        }
      catch
        {
          catch (NULL)
            {
              try
                {
                  D.48929 = __builtin_eh_pointer (0);
                  __cxa_begin_catch (D.48929);
                  if (__new_finish == 0B) goto <D.48930>; else goto <D.48931>;
                  <D.48930>:
                  D.48920 = __elems_before * 4;
                  D.48921 = __new_start + D.48920;
                  D.48910 = &this->D.43374._M_impl;
                  __gnu_cxx::__alloc_traits<std::allocator<int> >::destroy (D.48910, D.48921);
                  goto <D.48932>;
                  <D.48931>:
                  D.48919 = &this->D.43374;
                  D.48933 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.48919);
                  std::_Destroy<int*, int> (__new_start, __new_finish, D.48933);
                  <D.48932>:
                  D.48919 = &this->D.43374;
                  std::_Vector_base<int, std::allocator<int> >::_M_deallocate (D.48919, __new_start, __len);
                  __cxa_rethrow ();
                }
              finally
                {
                  __cxa_end_catch ();
                }
            }
        }
      D.48919 = &this->D.43374;
      D.48934 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.48919);
      D.48905 = this->D.43374._M_impl._M_finish;
      D.48925 = this->D.43374._M_impl._M_start;
      std::_Destroy<int*, int> (D.48925, D.48905, D.48934);
      D.48906 = this->D.43374._M_impl._M_end_of_storage;
      D.48935 = (long int) D.48906;
      D.48925 = this->D.43374._M_impl._M_start;
      D.48936 = (long int) D.48925;
      D.48937 = D.48935 - D.48936;
      D.48938 = D.48937 /[ex] 4;
      D.48939 = (long unsigned int) D.48938;
      D.48925 = this->D.43374._M_impl._M_start;
      D.48919 = &this->D.43374;
      std::_Vector_base<int, std::allocator<int> >::_M_deallocate (D.48919, D.48925, D.48939);
      this->D.43374._M_impl._M_start = __new_start;
      this->D.43374._M_impl._M_finish = __new_finish;
      D.48940 = __len * 4;
      D.48941 = __new_start + D.48940;
      this->D.43374._M_impl._M_end_of_storage = D.48941;
    }
    <D.48917>:
  }
}


_BI2 std::copy_backward(_BI1, _BI1, _BI2) [with _BI1 = int*; _BI2 = int*] (int * __first, int * __last, int * __result)
{
  int * D.48949;
  int * D.48950;
  int * D.48951;

  D.48950 = std::__miter_base<int*> (__last);
  D.48951 = std::__miter_base<int*> (__first);
  D.48949 = std::__copy_move_backward_a2<false, int*, int*> (D.48951, D.48950, __result);
  return D.48949;
}


typename std::_Miter_base<_Iterator>::iterator_type std::__miter_base(_Iterator) [with _Iterator = int*; typename std::_Miter_base<_Iterator>::iterator_type = int*] (int * __it)
{
  int * D.48956;

  D.48956 = std::_Iter_base<int*, false>::_S_base (__it);
  return D.48956;
}


static std::_Iter_base<_Iterator, _HasBase>::iterator_type std::_Iter_base<_Iterator, _HasBase>::_S_base(_Iterator) [with _Iterator = int*; bool _HasBase = false; std::_Iter_base<_Iterator, _HasBase>::iterator_type = int*] (int * __it)
{
  int * D.48958;

  D.48958 = __it;
  return D.48958;
}


_BI2 std::__copy_move_backward_a2(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = int*; _BI2 = int*] (int * __first, int * __last, int * __result)
{
  int * D.48960;
  int * D.48961;
  int * D.48962;
  int * D.48963;

  D.48961 = std::__niter_base<int*> (__result);
  D.48962 = std::__niter_base<int*> (__last);
  D.48963 = std::__niter_base<int*> (__first);
  D.48960 = std::__copy_move_backward_a<false, int*, int*> (D.48963, D.48962, D.48961);
  return D.48960;
}


typename std::_Niter_base<_Iterator>::iterator_type std::__niter_base(_Iterator) [with _Iterator = int*; typename std::_Niter_base<_Iterator>::iterator_type = int*] (int * __it)
{
  int * D.48969;

  D.48969 = std::_Iter_base<int*, false>::_S_base (__it);
  return D.48969;
}


_BI2 std::__copy_move_backward_a(_BI1, _BI1, _BI2) [with bool _IsMove = false; _BI1 = int*; _BI2 = int*] (int * __first, int * __last, int * __result)
{
  int * D.48971;
  typedef _ValueType1 _ValueType1;
  typedef _ValueType2 _ValueType2;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.48971 = std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<int> (__first, __last, __result);
  return D.48971;
}


static _Tp* std::__copy_move_backward<_IsMove, true, std::random_access_iterator_tag>::__copy_move_b(const _Tp*, const _Tp*, _Tp*) [with _Tp = int; bool _IsMove = false] (const int * __first, const int * __last, int * __result)
{
  long int __last.26;
  long int __first.27;
  long int D.48975;
  long unsigned int _Num.28;
  long unsigned int D.48979;
  sizetype D.48980;
  int * D.48981;
  int * D.48983;
  const ptrdiff_t _Num;

  __last.26 = (long int) __last;
  __first.27 = (long int) __first;
  D.48975 = __last.26 - __first.27;
  _Num = D.48975 /[ex] 4;
  if (_Num != 0) goto <D.48976>; else goto <D.48977>;
  <D.48976>:
  _Num.28 = (long unsigned int) _Num;
  D.48979 = _Num.28 * 4;
  _Num.28 = (long unsigned int) _Num;
  D.48979 = _Num.28 * 4;
  D.48980 = -D.48979;
  D.48981 = __result + D.48980;
  __builtin_memmove (D.48981, __first, D.48979);
  goto <D.48982>;
  <D.48977>:
  <D.48982>:
  _Num.28 = (long unsigned int) _Num;
  D.48979 = _Num.28 * 4;
  D.48980 = -D.48979;
  D.48983 = __result + D.48980;
  return D.48983;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::_M_check_len(std::vector<_Tp, _Alloc>::size_type, const char*) const [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this, size_type __n, const char * __s)
{
  bool retval.29;
  long unsigned int D.48986;
  long unsigned int D.48987;
  long unsigned int D.48988;
  long unsigned int __n.30;
  long unsigned int D.48992;
  const long unsigned int D.47673;
  long unsigned int D.48993;
  const long unsigned int & D.48994;
  long unsigned int D.48995;
  size_type D.48996;
  size_type iftmp.31;
  long unsigned int D.49001;
  long unsigned int D.49003;
  const size_type __len;

  D.48986 = std::vector<int, std::allocator<int> >::max_size (this);
  D.48987 = std::vector<int, std::allocator<int> >::size (this);
  D.48988 = D.48986 - D.48987;
  __n.30 = __n;
  retval.29 = D.48988 < __n.30;
  if (retval.29 != 0) goto <D.48990>; else goto <D.48991>;
  <D.48990>:
  std::__throw_length_error (__s);
  <D.48991>:
  D.48992 = std::vector<int, std::allocator<int> >::size (this);
  D.48993 = std::vector<int, std::allocator<int> >::size (this);
  D.47673 = D.48993;
  try
    {
      D.48994 = std::max<long unsigned int> (&D.47673, &__n);
      D.48995 = *D.48994;
      __len = D.48992 + D.48995;
    }
  finally
    {
      D.47673 = {CLOBBER};
    }
  D.49001 = std::vector<int, std::allocator<int> >::size (this);
  if (D.49001 > __len) goto <D.48998>; else goto <D.49002>;
  <D.49002>:
  D.49003 = std::vector<int, std::allocator<int> >::max_size (this);
  if (D.49003 < __len) goto <D.48998>; else goto <D.48999>;
  <D.48998>:
  iftmp.31 = std::vector<int, std::allocator<int> >::max_size (this);
  goto <D.49000>;
  <D.48999>:
  iftmp.31 = __len;
  <D.49000>:
  D.48996 = iftmp.31;
  return D.48996;
}


const _Tp& std::max(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.49008;
  long unsigned int D.49009;
  const long unsigned int & D.49012;

  D.49008 = *__a;
  D.49009 = *__b;
  if (D.49008 < D.49009) goto <D.49010>; else goto <D.49011>;
  <D.49010>:
  D.49012 = __b;
  return D.49012;
  <D.49011>:
  D.49012 = __a;
  return D.49012;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::size() const [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.49014;
  int * D.49015;
  long int D.49016;
  int * D.49017;
  long int D.49018;
  long int D.49019;
  long int D.49020;

  D.49015 = this->D.43374._M_impl._M_finish;
  D.49016 = (long int) D.49015;
  D.49017 = this->D.43374._M_impl._M_start;
  D.49018 = (long int) D.49017;
  D.49019 = D.49016 - D.49018;
  D.49020 = D.49019 /[ex] 4;
  D.49014 = (size_type) D.49020;
  return D.49014;
}


std::vector<_Tp, _Alloc>::size_type std::vector<_Tp, _Alloc>::max_size() const [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::size_type = long unsigned int] (const struct vector * const this)
{
  size_type D.49022;
  const struct _Vector_base * D.49023;
  const struct _Tp_alloc_type & D.49024;

  D.49023 = &this->D.43374;
  D.49024 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.49023);
  D.49022 = __gnu_cxx::__alloc_traits<std::allocator<int> >::max_size (D.49024);
  return D.49022;
}


const _Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() const [with _Tp = int; _Alloc = std::allocator<int>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<int>] (const struct _Vector_base * const this)
{
  const struct _Tp_alloc_type & D.49026;

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


static __gnu_cxx::__alloc_traits<_Alloc>::size_type __gnu_cxx::__alloc_traits<_Alloc>::max_size(const _Alloc&) [with _Alloc = std::allocator<int>; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (const struct allocator & __a)
{
  size_type D.49028;

  D.49028 = __gnu_cxx::new_allocator<int>::max_size (__a);
  return D.49028;
}


__gnu_cxx::new_allocator<_Tp>::size_type __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = int; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (const struct new_allocator * const this)
{
  size_type D.49030;
  void * D.49031;

  try
    {
      D.49030 = 4611686018427387903;
      return D.49030;
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.49031 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.49031);
          
        }
    }
}


typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type __gnu_cxx::operator-(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = int*; _Container = std::vector<int, std::allocator<int> >; typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type = long int] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  difference_type D.49033;
  int * const & D.49034;
  int * D.49035;
  long int D.49036;
  int * const & D.49037;
  int * D.49038;
  long int D.49039;
  long int D.49040;

  D.49034 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (__lhs);
  D.49035 = *D.49034;
  D.49036 = (long int) D.49035;
  D.49037 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (__rhs);
  D.49038 = *D.49037;
  D.49039 = (long int) D.49038;
  D.49040 = D.49036 - D.49039;
  D.49033 = D.49040 /[ex] 4;
  return D.49033;
}


std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>; std::_Vector_base<_Tp, _Alloc>::pointer = int*; std::size_t = long unsigned int] (struct _Vector_base * const this, size_t __n)
{
  int * D.49042;
  int * iftmp.32;
  struct _Vector_impl * D.49046;
  typedef struct _Tr _Tr;

  if (__n != 0) goto <D.49044>; else goto <D.49045>;
  <D.49044>:
  D.49046 = &this->_M_impl;
  iftmp.32 = __gnu_cxx::__alloc_traits<std::allocator<int> >::allocate (D.49046, __n);
  goto <D.49047>;
  <D.49045>:
  iftmp.32 = 0B;
  <D.49047>:
  D.49042 = iftmp.32;
  return D.49042;
}


static __gnu_cxx::__alloc_traits<_Alloc>::pointer __gnu_cxx::__alloc_traits<_Alloc>::allocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<int>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = int*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, size_type __n)
{
  int * D.49050;

  D.49050 = __gnu_cxx::new_allocator<int>::allocate (__a, __n, 0B);
  return D.49050;
}


_Tp* __gnu_cxx::new_allocator<_Tp>::allocate(__gnu_cxx::new_allocator<_Tp>::size_type, const void*) [with _Tp = int; __gnu_cxx::new_allocator<_Tp>::pointer = int*; __gnu_cxx::new_allocator<_Tp>::size_type = long unsigned int] (struct new_allocator * const this, size_type __n, const void * D.42687)
{
  bool retval.33;
  long unsigned int D.49054;
  int * D.49057;
  long unsigned int D.49058;

  D.49054 = __gnu_cxx::new_allocator<int>::max_size (this);
  retval.33 = D.49054 < __n;
  if (retval.33 != 0) goto <D.49055>; else goto <D.49056>;
  <D.49055>:
  std::__throw_bad_alloc ();
  <D.49056>:
  D.49058 = __n * 4;
  D.49057 = operator new (D.49058);
  return D.49057;
}


const _Iterator& __gnu_cxx::__normal_iterator<_Iterator, _Container>::base() const [with _Iterator = int*; _Container = std::vector<int, std::allocator<int> >] (const struct __normal_iterator * const this)
{
  int * const & D.49061;

  D.49061 = &this->_M_current;
  return D.49061;
}


_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = int*; _ForwardIterator = int*; _Allocator = std::allocator<int>] (int * __first, int * __last, int * __result, struct allocator & __alloc)
{
  int * D.49063;

  D.49063 = std::__uninitialized_copy_a<int*, int*, int> (__first, __last, __result, __alloc);
  return D.49063;
}


_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = int*; _ForwardIterator = int*; _Tp = int] (int * __first, int * __last, int * __result, struct allocator & D.47680)
{
  int * D.49066;

  D.49066 = std::uninitialized_copy<int*, int*> (__first, __last, __result);
  return D.49066;
}


_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = int*; _ForwardIterator = int*] (int * __first, int * __last, int * __result)
{
  int * D.49069;
  typedef _ValueType1 _ValueType1;
  typedef _ValueType2 _ValueType2;
  const bool __assignable;

  __assignable = 1;
  D.49069 = std::__uninitialized_copy<true>::__uninit_copy<int*, int*> (__first, __last, __result);
  return D.49069;
}


static _ForwardIterator std::__uninitialized_copy<true>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = int*; _ForwardIterator = int*] (int * __first, int * __last, int * __result)
{
  int * D.49072;

  D.49072 = std::copy<int*, int*> (__first, __last, __result);
  return D.49072;
}


_OI std::copy(_II, _II, _OI) [with _II = int*; _OI = int*] (int * __first, int * __last, int * __result)
{
  int * D.49075;
  int * D.49076;
  int * D.49077;

  D.49076 = std::__miter_base<int*> (__last);
  D.49077 = std::__miter_base<int*> (__first);
  D.49075 = std::__copy_move_a2<false, int*, int*> (D.49077, D.49076, __result);
  return D.49075;
}


_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = int*; _OI = int*] (int * __first, int * __last, int * __result)
{
  int * D.49082;
  int * D.49083;
  int * D.49084;
  int * D.49085;

  D.49083 = std::__niter_base<int*> (__result);
  D.49084 = std::__niter_base<int*> (__last);
  D.49085 = std::__niter_base<int*> (__first);
  D.49082 = std::__copy_move_a<false, int*, int*> (D.49085, D.49084, D.49083);
  return D.49082;
}


_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = int*; _OI = int*] (int * __first, int * __last, int * __result)
{
  int * D.49090;
  typedef _ValueTypeI _ValueTypeI;
  typedef _ValueTypeO _ValueTypeO;
  typedef struct _Category _Category;
  const bool __simple;

  __simple = 1;
  D.49090 = std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<int> (__first, __last, __result);
  return D.49090;
}


static _Tp* std::__copy_move<_IsMove, true, std::random_access_iterator_tag>::__copy_m(const _Tp*, const _Tp*, _Tp*) [with _Tp = int; bool _IsMove = false] (const int * __first, const int * __last, int * __result)
{
  long int __last.34;
  long int __first.35;
  long int D.49094;
  long unsigned int _Num.36;
  long unsigned int D.49098;
  int * D.49100;
  const ptrdiff_t _Num;

  __last.34 = (long int) __last;
  __first.35 = (long int) __first;
  D.49094 = __last.34 - __first.35;
  _Num = D.49094 /[ex] 4;
  if (_Num != 0) goto <D.49095>; else goto <D.49096>;
  <D.49095>:
  _Num.36 = (long unsigned int) _Num;
  D.49098 = _Num.36 * 4;
  __builtin_memmove (__result, __first, D.49098);
  goto <D.49099>;
  <D.49096>:
  <D.49099>:
  _Num.36 = (long unsigned int) _Num;
  D.49098 = _Num.36 * 4;
  D.49100 = __result + D.49098;
  return D.49100;
}


static void __gnu_cxx::__alloc_traits<_Alloc>::destroy(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer) [with _Alloc = std::allocator<int>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = int*] (struct allocator & __a, int * __p)
{
  __gnu_cxx::new_allocator<int>::destroy (__a, __p);
}


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


std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type& std::_Vector_base<_Tp, _Alloc>::_M_get_Tp_allocator() [with _Tp = int; _Alloc = std::allocator<int>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = std::allocator<int>] (struct _Vector_base * const this)
{
  struct _Tp_alloc_type & D.49102;

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


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


void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = int*] (int * __first, int * __last)
{
  typedef _Value_type _Value_type;

  std::_Destroy_aux<true>::__destroy<int*> (__first, __last);
}


static void std::_Destroy_aux<true>::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = int*] (int * D.46503, int * D.46504)
{
  GIMPLE_NOP
}


void std::_Vector_base<_Tp, _Alloc>::_M_deallocate(std::_Vector_base<_Tp, _Alloc>::pointer, std::size_t) [with _Tp = int; _Alloc = std::allocator<int>; std::_Vector_base<_Tp, _Alloc>::pointer = int*; std::size_t = long unsigned int] (struct _Vector_base * const this, int * __p, size_t __n)
{
  struct _Vector_impl * D.49106;
  typedef struct _Tr _Tr;

  if (__p != 0B) goto <D.49104>; else goto <D.49105>;
  <D.49104>:
  D.49106 = &this->_M_impl;
  __gnu_cxx::__alloc_traits<std::allocator<int> >::deallocate (D.49106, __p, __n);
  goto <D.49107>;
  <D.49105>:
  <D.49107>:
}


static void __gnu_cxx::__alloc_traits<_Alloc>::deallocate(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, __gnu_cxx::__alloc_traits<_Alloc>::size_type) [with _Alloc = std::allocator<int>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = int*; __gnu_cxx::__alloc_traits<_Alloc>::size_type = long unsigned int] (struct allocator & __a, int * __p, size_type __n)
{
  __gnu_cxx::new_allocator<int>::deallocate (__a, __p, __n);
}


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


sigc::internal::slot_iterator_buf<T_emitter, T_result>& sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator++() [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >; T_result = int] (struct slot_iterator_buf * const this)
{
  struct iterator_type * D.49108;
  struct slot_iterator_buf & D.49109;

  D.49108 = &this->i_;
  std::_List_const_iterator<sigc::slot_base>::operator++ (D.49108);
  this->invoked_ = 0;
  D.49109 = this;
  return D.49109;
}


bool sigc::internal::slot_iterator_buf<T_emitter, T_result>::operator!=(const sigc::internal::slot_iterator_buf<T_emitter, T_result>&) const [with T_emitter = sigc::internal::signal_emit1<int, int, {anonymous}::vector_accumulator<int> >; T_result = int] (const struct slot_iterator_buf * const this, const struct slot_iterator_buf & other)
{
  bool D.49111;
  bool iftmp.37;
  const struct emitter_type * D.49115;
  const struct iterator_type * D.49117;
  const struct iterator_type * D.49118;
  bool D.49119;

  D.49115 = this->c_;
  if (D.49115 != 0B) goto <D.49116>; else goto <D.49113>;
  <D.49116>:
  D.49117 = &other->i_;
  D.49118 = &this->i_;
  D.49119 = std::_List_const_iterator<sigc::slot_base>::operator!= (D.49118, D.49117);
  if (D.49119 != 0) goto <D.49120>; else goto <D.49113>;
  <D.49120>:
  iftmp.37 = 1;
  goto <D.49114>;
  <D.49113>:
  iftmp.37 = 0;
  <D.49114>:
  D.49111 = iftmp.37;
  return D.49111;
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::begin() [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >; typename std::_Vector_base<_Tp, _Alloc>::pointer = int*] (struct vector * const this)
{
  struct iterator D.49122;
  struct iterator D.44433;
  int * * D.49123;

  D.49123 = &this->D.43374._M_impl._M_start;
  __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator (&D.44433, D.49123);
  try
    {
      D.49122 = D.44433;
      return D.49122;
    }
  finally
    {
      D.44433 = {CLOBBER};
    }
}


__gnu_cxx::__normal_iterator<_Iterator, _Container>::__normal_iterator(const _Iterator&) [with _Iterator = int*; _Container = std::vector<int, std::allocator<int> >] (struct __normal_iterator * const this, int * const & __i)
{
  int * D.49126;

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


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

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


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.49131;
  int (*__vtbl_ptr_type) () * D.49132;
  long int D.49133;
  sizetype D.49134;
  struct basic_ios * D.49135;
  long unsigned int D.49137;
  long int D.49138;
  struct basic_ostream & D.49139;

  if (__s == 0B) goto <D.49129>; else goto <D.49130>;
  <D.49129>:
  D.49131 = __out->_vptr.basic_ostream;
  D.49132 = D.49131 + 18446744073709551592;
  D.49133 = MEM[(long int *)D.49132];
  D.49134 = (sizetype) D.49133;
  D.49135 = __out + D.49134;
  std::basic_ios<char>::setstate (D.49135, 1);
  goto <D.49136>;
  <D.49130>:
  D.49137 = std::char_traits<char>::length (__s);
  D.49138 = (long int) D.49137;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.49138);
  <D.49136>:
  D.49139 = __out;
  return D.49139;
}


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.49141;
  _Ios_Iostate D.49142;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.49146;
  int __a.38;
  int __b.39;
  int D.49149;

  __a.38 = (int) __a;
  __b.39 = (int) __b;
  D.49149 = __a.38 | __b.39;
  D.49146 = (_Ios_Iostate) D.49149;
  return D.49146;
}


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

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


__gnu_cxx::__normal_iterator<_Iterator, _Container>& __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator++() [with _Iterator = int*; _Container = std::vector<int, std::allocator<int> >] (struct __normal_iterator * const this)
{
  int * D.49153;
  int * D.49154;
  struct __normal_iterator & D.49155;

  D.49153 = this->_M_current;
  D.49154 = D.49153 + 4;
  this->_M_current = D.49154;
  D.49155 = this;
  return D.49155;
}


std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::end() [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >; typename std::_Vector_base<_Tp, _Alloc>::pointer = int*] (struct vector * const this)
{
  struct iterator D.49157;
  struct iterator D.44435;
  int * * D.49158;

  D.49158 = &this->D.43374._M_impl._M_finish;
  __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator (&D.44435, D.49158);
  try
    {
      D.49157 = D.44435;
      return D.49157;
    }
  finally
    {
      D.44435 = {CLOBBER};
    }
}


bool __gnu_cxx::operator!=(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = int*; _Container = std::vector<int, std::allocator<int> >] (const struct __normal_iterator & __lhs, const struct __normal_iterator & __rhs)
{
  bool D.49161;
  int * const & D.49162;
  int * D.49163;
  int * const & D.49164;
  int * D.49165;

  D.49162 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (__lhs);
  D.49163 = *D.49162;
  D.49164 = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base (__rhs);
  D.49165 = *D.49164;
  D.49161 = D.49163 != D.49165;
  return D.49161;
}


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

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

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


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

  try
    {
      {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49169 = &this->D.42198;
            sigc::slot1<int, int>::~slot1 (D.49169);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.43481>:
}


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49171 = &this->D.42156;
            sigc::slot_base::~slot_base (D.49171);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.43476>:
}


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.44144;
  struct _Rep * D.49173;
  struct _Alloc_hider * D.49174;

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


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

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

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


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

  try
    {
      {

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


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.49184;
  char * D.49185;

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


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

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


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.40;
  struct _Rep & D.49191;
  bool D.49192;
  long int D.49193;
  long int D.49194;
  bool retval.41;
  _Atomic_word * D.49198;
  int D.49199;

  D.49191 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.49192 = D.49191 != this;
  D.49193 = (long int) D.49192;
  D.49194 = __builtin_expect (D.49193, 0);
  retval.40 = D.49194 != 0;
  if (retval.40 != 0) goto <D.49195>; else goto <D.49196>;
  <D.49195>:
  D.49198 = &this->D.11865._M_refcount;
  D.49199 = __gnu_cxx::__exchange_and_add_dispatch (D.49198, -1);
  retval.41 = D.49199 <= 0;
  if (retval.41 != 0) goto <D.49200>; else goto <D.49201>;
  <D.49200>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.49202>;
  <D.49201>:
  <D.49202>:
  goto <D.49203>;
  <D.49196>:
  <D.49203>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.42;
  int D.49208;
  _Atomic_word D.49211;

  D.49208 = __gthread_active_p ();
  retval.42 = D.49208 != 0;
  if (retval.42 != 0) goto <D.49209>; else goto <D.49210>;
  <D.49209>:
  D.49211 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.49211;
  <D.49210>:
  D.49211 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.49211;
}


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

  D.49214 = __gthrw___pthread_key_create != 0B;
  D.49213 = (int) D.49214;
  return D.49213;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.49216;
  unsigned int __val.43;
  unsigned int D.49218;

  __val.43 = (unsigned int) __val;
  D.49218 = __atomic_fetch_add_4 (__mem, __val.43, 4);
  D.49216 = (_Atomic_word) D.49218;
  return D.49216;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.49220;
  int D.49221;
  _Atomic_word D.49222;
  _Atomic_word __result;

  __result = *__mem;
  D.49220 = *__mem;
  D.49221 = D.49220 + __val;
  *__mem = D.49221;
  D.49222 = __result;
  return D.49222;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


std::vector<_Tp, _Alloc>::~vector() [with _Tp = int; _Alloc = std::allocator<int>] (struct vector * const this)
{
  struct _Vector_base * D.49226;
  struct _Tp_alloc_type & D.49227;
  int * D.49228;
  int * D.49229;

  {
    try
      {
        try
          {
            D.49226 = &this->D.43374;
            D.49227 = std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator (D.49226);
            D.49228 = this->D.43374._M_impl._M_finish;
            D.49229 = this->D.43374._M_impl._M_start;
            std::_Destroy<int*, int> (D.49229, D.49228, D.49227);
          }
        finally
          {
            D.49226 = &this->D.43374;
            std::_Vector_base<int, std::allocator<int> >::~_Vector_base (D.49226);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44162>:
}


std::_Vector_base<_Tp, _Alloc>::~_Vector_base() [with _Tp = int; _Alloc = std::allocator<int>] (struct _Vector_base * const this)
{
  int * D.49232;
  long int D.49233;
  int * D.49234;
  long int D.49235;
  long int D.49236;
  long int D.49237;
  long unsigned int D.49238;
  struct _Vector_impl * D.49239;

  {
    try
      {
        try
          {
            D.49232 = this->_M_impl._M_end_of_storage;
            D.49233 = (long int) D.49232;
            D.49234 = this->_M_impl._M_start;
            D.49235 = (long int) D.49234;
            D.49236 = D.49233 - D.49235;
            D.49237 = D.49236 /[ex] 4;
            D.49238 = (long unsigned int) D.49237;
            D.49234 = this->_M_impl._M_start;
            std::_Vector_base<int, std::allocator<int> >::_M_deallocate (this, D.49234, D.49238);
          }
        finally
          {
            D.49239 = &this->_M_impl;
            std::_Vector_base<int, std::allocator<int> >::_Vector_impl::~_Vector_impl (D.49239);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44593>:
}


std::_Vector_base<int, std::allocator<int> >::_Vector_impl::~_Vector_impl() (struct _Vector_impl * const this)
{
  {
    try
      {
        try
          {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


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

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49244 = &this->D.42077;
            sigc::trackable::~trackable (D.49244);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.43412>:
}


sigc::signal<int, int>::accumulated<{anonymous}::vector_accumulator<int> >::~accumulated() (struct accumulated * const this)
{
  struct signal1 * D.49246;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49246 = &this->D.42593;
            sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::~signal1 (D.49246);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42624>:
}


sigc::signal1<int, int, {anonymous}::vector_accumulator<int> >::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.49248;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49248 = &this->D.42575;
            sigc::signal_base::~signal_base (D.49248);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42619>:
}


sigc::signal<int, int>::accumulated<{anonymous}::arithmetic_mean_accumulator>::~accumulated() (struct accumulated * const this)
{
  struct signal1 * D.49250;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49250 = &this->D.42445;
            sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::~signal1 (D.49250);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42476>:
}


sigc::signal1<int, int, {anonymous}::arithmetic_mean_accumulator>::~signal1() (struct signal1 * const this)
{
  struct signal_base * D.49252;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.49252 = &this->D.42427;
            sigc::signal_base::~signal_base (D.49252);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.42471>:
}


(static initializers for test_accumulated.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.49254>; else goto <D.49255>;
  <D.49254>:
  if (__priority == 65535) goto <D.49256>; else goto <D.49257>;
  <D.49256>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.49258>;
  <D.49257>:
  <D.49258>:
  goto <D.49259>;
  <D.49255>:
  <D.49259>:
}


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.44;
  const void * * D.49263;
  sizetype iftmp.45;
  int (*__vtbl_ptr_type) () * D.49268;
  int (*__vtbl_ptr_type) () * D.49269;
  long int D.49270;
  struct basic_ios * D.49272;
  int (*__vtbl_ptr_type) () * iftmp.46;
  struct __stringbuf_type * D.49277;
  const void * * iftmp.47;
  struct basic_ostream * D.49282;
  int D.49283;
  struct basic_ios * D.49286;
  int D.49288;

  {
    if (2 == 0) goto <D.49261>; else goto <D.49262>;
    <D.49261>:
    D.49263 = 0B;
    iftmp.44 = *D.49263;
    goto <D.49264>;
    <D.49262>:
    iftmp.44 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.49264>:
    this->D.22312._vptr.basic_ostream = iftmp.44;
    if (2 == 0) goto <D.49266>; else goto <D.49267>;
    <D.49266>:
    D.49268 = this->D.22312._vptr.basic_ostream;
    D.49269 = D.49268 + 18446744073709551592;
    D.49270 = MEM[(long int *)D.49269];
    iftmp.45 = (sizetype) D.49270;
    goto <D.49271>;
    <D.49267>:
    iftmp.45 = 88;
    <D.49271>:
    D.49272 = this + iftmp.45;
    if (2 == 0) goto <D.49274>; else goto <D.49275>;
    <D.49274>:
    iftmp.46 = MEM[(const void * *)0B + 24B];
    goto <D.49276>;
    <D.49275>:
    iftmp.46 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.49276>:
    D.49272->D.19008._vptr.ios_base = iftmp.46;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.49277 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.49277);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.49279>; else goto <D.49280>;
                <D.49279>:
                iftmp.47 = 8B;
                goto <D.49281>;
                <D.49280>:
                iftmp.47 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.49281>:
                D.49282 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.49282, iftmp.47);
              }
          }
        finally
          {
            D.49283 = 2;
            if (D.49283 != 0) goto <D.49284>; else goto <D.49285>;
            <D.49284>:
            D.49286 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.49286);
            goto <D.49287>;
            <D.49285>:
            <D.49287>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.48103>:
  D.49288 = 0;
  if (D.49288 != 0) goto <D.49289>; else goto <D.49290>;
  <D.49289>:
  operator delete (this);
  goto <D.49291>;
  <D.49290>:
  <D.49291>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.49301;
  struct basic_streambuf * D.49302;
  int D.49303;

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

              }
            finally
              {
                D.49301 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.49301);
              }
          }
        finally
          {
            D.49302 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.49302);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44097>:
  D.49303 = 0;
  if (D.49303 != 0) goto <D.49304>; else goto <D.49305>;
  <D.49304>:
  operator delete (this);
  goto <D.49306>;
  <D.49305>:
  <D.49306>:
}


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

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

          }
        finally
          {
            D.49309 = &this->_M_buf_locale;
            std::locale::~locale (D.49309);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44544>:
  D.49310 = 0;
  if (D.49310 != 0) goto <D.49311>; else goto <D.49312>;
  <D.49311>:
  operator delete (this);
  goto <D.49313>;
  <D.49312>:
  <D.49313>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.44101>:
  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.48;
  sizetype iftmp.49;
  int (*__vtbl_ptr_type) () * D.49321;
  int (*__vtbl_ptr_type) () * D.49322;
  long int D.49323;
  struct basic_ios * D.49325;
  int (*__vtbl_ptr_type) () * iftmp.50;
  int D.49330;
  struct basic_ios * D.49333;
  int D.49335;

  {
    if (0 == 0) goto <D.49315>; else goto <D.49316>;
    <D.49315>:
    iftmp.48 = *__vtt_parm;
    goto <D.49317>;
    <D.49316>:
    iftmp.48 = &MEM[(void *)&_ZTVSo + 24B];
    <D.49317>:
    this->_vptr.basic_ostream = iftmp.48;
    if (0 == 0) goto <D.49319>; else goto <D.49320>;
    <D.49319>:
    D.49321 = this->_vptr.basic_ostream;
    D.49322 = D.49321 + 18446744073709551592;
    D.49323 = MEM[(long int *)D.49322];
    iftmp.49 = (sizetype) D.49323;
    goto <D.49324>;
    <D.49320>:
    iftmp.49 = 8;
    <D.49324>:
    D.49325 = this + iftmp.49;
    if (0 == 0) goto <D.49327>; else goto <D.49328>;
    <D.49327>:
    iftmp.50 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.49329>;
    <D.49328>:
    iftmp.50 = &MEM[(void *)&_ZTVSo + 64B];
    <D.49329>:
    D.49325->D.19008._vptr.ios_base = iftmp.50;
    try
      {
        try
          {

          }
        finally
          {
            D.49330 = 0;
            if (D.49330 != 0) goto <D.49331>; else goto <D.49332>;
            <D.49331>:
            D.49333 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.49333);
            goto <D.49334>;
            <D.49332>:
            <D.49334>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44529>:
  D.49335 = 0;
  if (D.49335 != 0) goto <D.49336>; else goto <D.49337>;
  <D.49336>:
  operator delete (this);
  goto <D.49338>;
  <D.49337>:
  <D.49338>:
}


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

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

          }
        finally
          {
            D.49340 = &this->D.19008;
            std::ios_base::~ios_base (D.49340);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44517>:
  D.49341 = 0;
  if (D.49341 != 0) goto <D.49342>; else goto <D.49343>;
  <D.49342>:
  operator delete (this);
  goto <D.49344>;
  <D.49343>:
  <D.49344>:
}


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.44521>:
  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.49348;
  const void * * iftmp.51;
  struct basic_ostream * D.49354;
  int (*__vtbl_ptr_type) () * iftmp.52;
  const void * * D.49358;
  sizetype iftmp.53;
  int (*__vtbl_ptr_type) () * D.49363;
  int (*__vtbl_ptr_type) () * D.49364;
  long int D.49365;
  struct basic_ios * D.49367;
  int (*__vtbl_ptr_type) () * iftmp.54;
  _Ios_Openmode D.49372;
  struct __stringbuf_type * D.49373;
  struct basic_streambuf * D.49374;
  sizetype iftmp.55;
  struct basic_ios * D.49379;
  const void * * iftmp.56;

  if (1 != 0) goto <D.49346>; else goto <D.49347>;
  <D.49346>:
  D.49348 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.49348);
  goto <D.49349>;
  <D.49347>:
  <D.49349>:
  try
    {
      if (1 == 0) goto <D.49351>; else goto <D.49352>;
      <D.49351>:
      iftmp.51 = 8B;
      goto <D.49353>;
      <D.49352>:
      iftmp.51 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.49353>:
      D.49354 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.49354, iftmp.51);
      try
        {
          if (1 == 0) goto <D.49356>; else goto <D.49357>;
          <D.49356>:
          D.49358 = 0B;
          iftmp.52 = *D.49358;
          goto <D.49359>;
          <D.49357>:
          iftmp.52 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.49359>:
          this->D.22312._vptr.basic_ostream = iftmp.52;
          if (1 == 0) goto <D.49361>; else goto <D.49362>;
          <D.49361>:
          D.49363 = this->D.22312._vptr.basic_ostream;
          D.49364 = D.49363 + 18446744073709551592;
          D.49365 = MEM[(long int *)D.49364];
          iftmp.53 = (sizetype) D.49365;
          goto <D.49366>;
          <D.49362>:
          iftmp.53 = 88;
          <D.49366>:
          D.49367 = this + iftmp.53;
          if (1 == 0) goto <D.49369>; else goto <D.49370>;
          <D.49369>:
          iftmp.54 = MEM[(const void * *)0B + 24B];
          goto <D.49371>;
          <D.49370>:
          iftmp.54 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.49371>:
          D.49367->D.19008._vptr.ios_base = iftmp.54;
          D.49372 = std::operator| (__mode, 16);
          D.49373 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.49373, D.49372);
          try
            {
              D.49374 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.49376>; else goto <D.49377>;
              <D.49376>:
              D.49363 = this->D.22312._vptr.basic_ostream;
              D.49364 = D.49363 + 18446744073709551592;
              D.49365 = MEM[(long int *)D.49364];
              iftmp.55 = (sizetype) D.49365;
              goto <D.49378>;
              <D.49377>:
              iftmp.55 = 88;
              <D.49378>:
              D.49379 = this + iftmp.55;
              std::basic_ios<char>::init (D.49379, D.49374);
            }
          catch
            {
              D.49373 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.49373);
            }
        }
      catch
        {
          if (1 == 0) goto <D.49381>; else goto <D.49382>;
          <D.49381>:
          iftmp.56 = 8B;
          goto <D.49383>;
          <D.49382>:
          iftmp.56 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.49383>:
          D.49354 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.49354, iftmp.56);
        }
    }
  catch
    {
      if (1 != 0) goto <D.49384>; else goto <D.49385>;
      <D.49384>:
      D.49348 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.49348);
      goto <D.49386>;
      <D.49385>:
      <D.49386>:
    }
}


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

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


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.49393;
  int (*__vtbl_ptr_type) () * iftmp.57;
  sizetype iftmp.58;
  int (*__vtbl_ptr_type) () * D.49402;
  int (*__vtbl_ptr_type) () * D.49403;
  long int D.49404;
  struct basic_ios * D.49406;
  int (*__vtbl_ptr_type) () * iftmp.59;
  sizetype iftmp.60;
  struct basic_ios * D.49415;

  if (0 != 0) goto <D.49391>; else goto <D.49392>;
  <D.49391>:
  D.49393 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.49393);
  goto <D.49394>;
  <D.49392>:
  <D.49394>:
  try
    {
      if (0 == 0) goto <D.49396>; else goto <D.49397>;
      <D.49396>:
      iftmp.57 = *__vtt_parm;
      goto <D.49398>;
      <D.49397>:
      iftmp.57 = &MEM[(void *)&_ZTVSo + 24B];
      <D.49398>:
      this->_vptr.basic_ostream = iftmp.57;
      if (0 == 0) goto <D.49400>; else goto <D.49401>;
      <D.49400>:
      D.49402 = this->_vptr.basic_ostream;
      D.49403 = D.49402 + 18446744073709551592;
      D.49404 = MEM[(long int *)D.49403];
      iftmp.58 = (sizetype) D.49404;
      goto <D.49405>;
      <D.49401>:
      iftmp.58 = 8;
      <D.49405>:
      D.49406 = this + iftmp.58;
      if (0 == 0) goto <D.49408>; else goto <D.49409>;
      <D.49408>:
      iftmp.59 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.49410>;
      <D.49409>:
      iftmp.59 = &MEM[(void *)&_ZTVSo + 64B];
      <D.49410>:
      D.49406->D.19008._vptr.ios_base = iftmp.59;
      if (0 == 0) goto <D.49412>; else goto <D.49413>;
      <D.49412>:
      D.49402 = this->_vptr.basic_ostream;
      D.49403 = D.49402 + 18446744073709551592;
      D.49404 = MEM[(long int *)D.49403];
      iftmp.60 = (sizetype) D.49404;
      goto <D.49414>;
      <D.49413>:
      iftmp.60 = 8;
      <D.49414>:
      D.49415 = this + iftmp.60;
      std::basic_ios<char>::init (D.49415, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.49416>; else goto <D.49417>;
      <D.49416>:
      D.49393 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.49393);
      goto <D.49418>;
      <D.49417>:
      <D.49418>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.49420;
  int __a.61;
  int __b.62;
  int D.49423;

  __a.61 = (int) __a;
  __b.62 = (int) __b;
  D.49423 = __a.61 | __b.62;
  D.49420 = (_Ios_Openmode) D.49423;
  return D.49420;
}


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.49425;
  struct __string_type * D.49426;

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

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


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

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

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


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.46291;
  struct _Rep & D.49429;
  char * D.49430;
  struct _Alloc_hider * D.49431;

  std::allocator<char>::allocator (&D.46291);
  try
    {
      D.49429 = std::basic_string<char>::_S_empty_rep ();
      D.49430 = std::basic_string<char>::_Rep::_M_refdata (D.49429);
      D.49431 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.49431, D.49430, &D.46291);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.46291);
      D.46291 = {CLOBBER};
    }
  try
    {

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


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

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


_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.49437;
  void * D.49438;

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


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


